java中什么是修饰符

JAVA方法修饰符是什么．有多少．全写了下来

1.static修饰符： a．有时候程序员可能需要定义一个类成员，对它的使用不依赖于该类的任何对象，要创建这样的成员，成员的变量声明前必须加上关键字static。成员声明为static后，在创建该类的任何对象之前就可以访问它。 b．关键字static可应用于变量、方法，甚至不属于方法的一段代码块。生命静态类的对象时，不会生成静态变量的副本。类的所有实例都共享一些静态变量。 c．可以通过类名称来调用静态变量，也可以通过对类实例的引用来调用静态变量。但建议通过类名称来调用静态变量。 d．方法声明为静态时具有某些限制，具体如：它们只能调用其他静态方法。 它们必须只访问静态数据。 不能使用关键字this或super。 2.final修饰符： a．final修饰符可应用于类、方法、和变量。final变量的内容不能更改。因此，声明final变量时，必须将其初始化。 b．声明为final的变量不会在每个实例中都占用内存，也就是说，可以认为final变量就是常量。 c．通常的做法是为final变量选择大写的标识符。 d．当关键字final应用于方法时，它意味着方法不能被重写。如果对象已声明为final，对该对象的引用则不能更改，但它的值可以更改。 3．abstract修饰符： a．父类中的某些方法不包含任何逻辑，并且需要由子类重写。在这种情况下，应该使用关键字abstract来声明父类中的方法。 b．子类提供这种abstract这种方法的实现细节，而父类仅提供此方法的名称和声明，没有方法的主体。 c．任何一个或多个抽象方法的类也应该声明为抽象。 d．要声明一个抽象类，在class关键字前应该加上abstract。 e．抽象类不能被实例化。构造方法和static类方法不能声明为abstract。Abstract类的任何子类必须实现在父类中声明的所有abstract方法，否则子类必须声明为抽象类。 f．abstract类不能有对象，但它们可以用来创建对象的引用，因为Java运行时多态性是通过父类引用实现的。因此，对象可用来创建对抽象类的引用，抽象类可以指向子类的对象。 g．如果方法定义为抽象，那么此方法所在的类也必须为抽象。

java修饰符作用范围

1、java中的修饰符

1）访问修饰符：

private

被private修饰的属性和方法，不能被其他类访问，子类不能继承也不能访问。只能在所在类内部访问。

缺省

变量或者方法前没有访问修饰符时，可以被所在类访问，可以被同一包内的其他类访问 或者继承。但是不能被其他包访问。

protected

被protected修饰的方法和属性，在同一包内可被访问和继承。不同包内，子类可继承，非子类不能访问。

public

方法和属性前有public修饰，可以被任意包内的类访问。

另外，类要想被其他包导入，必须声明为public。被public修饰的类，类名必须与文件名相同。

2）静态修饰符：

static是一个修饰符，用于修饰成员(成员变量和成员函数)

静态成员随着类的加载而加载。

静态成员优先于对象存在。

静态成员被所有对象所共享

静态成员多了一个中调用方式，可以被类名直接调用。

java中类修饰符有哪些？

java的修饰符有：权限修饰符：public、protected、default、private

修饰符：abstract、static、final

public 使用对象：最广，类、接口、变量、方法

protected使用对象：变量、方法 注意：不能修饰类（外部类）

default 使用对象：类、接口、变量、方法。（即缺省，什么也不写）

private 使用对象：变量、方法 注意：不能修饰类（外部类）

abstract使用对象：类、接口、方法

static 使用对象：类、变量、方法、初始化函数（注意：修饰类时只能修饰 内部类 ）

final 使用对象：类、变量、方法

transient：告诉编译器，在类对象序列化的时候，此变量不需要持久保存

volatile：指出可能有多个线程修改此变量，要求编译器优化以保证对此变量的修改能够被正确的处理

native：用该修饰符定义的方法在类中没有实现，而大多数情况下该方法的实现是用C、C++编写的。

synchronized：修饰方法，多线程的支持

类分外部类和内部类，他们的访问控制是相同的吗

外部类是相对于内部类而言的，内部类是定义在类里面的类。

外部类的修饰符有：

default（缺省，不写）：类定义时前面未加任何修饰符，表示同一个包中可见。

public：修饰类时表示该类能被项目中所有类可见

abstract：表示是抽象类

final：表示类不可以被继承

scrictpf:(java关键字) 当对一个类或接口使用 strictfp 关键字时，该类中的所有代码，包括嵌套类型中的初始设定值和代码，都将严格地进行计算。严格约束意味着所有表达式的结果都必须是 IEEE 754 算法对操作数预期的结果，以单精度和双精度格式表示

内部类又分：成员内部类、局部内部类、静态内部类、匿名内部类

成员内部类：作为外部类的一个成员存在，与外部类的属性、方法并列

局部内部类：定义在外部类的方法体里面的类

静态内部类：使用static修饰的内部类

匿名内部类：就是没有名字的内部类

成员内部类修饰符有：

public：

protected：

private：private不能修饰外部类，

abstract：

final：

static：可以当做普通类使用，而不用先实例化一个外部类。（用他修饰后，就成了静态内部类了）

strictfp：（java关键字） 即 strict float point (精确浮点)。（可修饰类、接口、方法）

扩展资料：

java中的类修饰符、成员变量修饰符、方法修饰符。

类修饰符：

public（访问控制符），将一个类声明为公共类，他可以被任何对象访问，一个程序的主类必须是公共类。

abstract，将一个类声明为抽象类，没有实现的方法，需要子类提供方法实现。

final，将一个类生命为最终（即非继承类），表示他不能被其他类继承。

friendly，默认的修饰符，只有在相同包中的对象才能使用这样的类。

成员变量修饰符：

public（公共访问控制符），指定该变量为公共的，他可以被任何对象的方法访问。

private（私有访问控制符）指定该变量只允许自己的类的方法访问，其他任何类（包括子类）中的方法均不能访问。

protected（保护访问控制符）指定该变量可以别被自己的类和子类访问。在子类中可以覆盖此变量。

friendly ，在同一个包中的类可以访问，其他包中的类不能访问。

final，最终修饰符，指定此变量的值不能变。

static（静态修饰符）指定变量被所有对象共享，即所有实例都可以使用该变量。变量属于这个类。

transient（过度修饰符）指定该变量是系统保留，暂无特别作用的临时性变量。

volatile（易失修饰符）指定该变量可以同时被几个线程控制和修改。

方法修饰符：

public（公共控制符）

private（私有控制符）指定此方法只能有自己类等方法访问，其他的类不能访问（包括子类）

protected（保护访问控制符）指定该方法可以被它的类和子类进行访问。

final，指定该方法不能被重载。

static，指定不需要实例化就可以激活的一个方法。

synchronize，同步修饰符，在多个线程中，该修饰符用于在运行前，对他所属的方法加锁，以防止其他线程的访问，运行结束后解锁。

native，本地修饰符。指定此方法的方法体是用其他语言在程序外部编写的。

参考资料：百度百科-修饰符

java中的修饰符

static 表示静态，它可以修饰属性，方法和代码块。

1，static修饰属性（类变量），那么这个属性就可以用 类名.属性名 来访问，也就是使这个属性成为本类的类变量，为本类对象所共有。这个属性就是全类公有。（共有的类变量与对象无关，只和类有关）。

类加载的过程，类本身也是保存在文件中（字节码文件保存着类的信息）的，java会通过I/O流把类的文件（字节码文件）读入JVM（java虚拟机），这个过程成为类的加载。JVM（java虚拟机）会通过类路径（CLASSPATH）来找字节码文件。

类变量，会在加载时自动初始化，初始化规则和实例变量相同。

注意：类中的实例变量是在创建对象时被初始化的，被static修饰的属性，也就是类变量，是在类加载时被创建并进行初始化，类加载的过程是进行一次。也就是类变量只会被创建一次。

2，static修饰方法（静态方法），会使这个方法成为整个类所公有的方法，可以用类名.方法名 访问。

注意：static修饰的方法，不直接能访问（可以通过组合方式访问）本类中的非静态(static)成员（包括方法和属性），本类的非静态（static）方法可以访问本类的静态成员（包括方法和属性），可以调用静态方法。静态方法要慎重使用。在静态方法中不能出现this关键字。

注意：父类中是静态方法，子类中不能覆盖为非静态方法，在符合覆盖规则的前提下，在父子类中，父类中的静态方法可以被子类中的静态方法覆盖，但是没有多态。（在使用对象调用静态方法是其实是调用编译时类型的静态方法）

注意：父子类中，静态方法只能被静态方法覆盖，父子类中，非静态方法只能被非静态方法覆盖。

java中的main方法必须写成static的因为，在类加载时无法创建对象，因为静态方法可以不通过对象调用

所以在类的main方法。所在在类加载时就可以通过main方法入口来运行程序。

注意：组合方式，就是需要在方法中创建一个所需要的对象，并用这个对象来调用任意所需的该对象的内容，不会再受只能访问静态的约束。

3，static修饰初始代码块，这时这个初始代码块就叫做静态初始代码块，这个代码块只在类加载时被执行一次。可以用静态初始代码块初始化一个类。

动态初始代码块，写在类体中的“{}”，这个代码块是在生成对象的初始化属性是运行。这种代码块叫动态初始代码块。

类在什么时候会被加载，构造（创建）对象时会加载类，调用类中静态方法或访问静态属性也是会加载这个静态方法真正所在的类。在构造子类对象时必会先加载父类，类加载会有延迟加载原则，只有在必须加载时才会加载。

final修饰符，可以修饰变量，方法，类

1,final修饰变量

被fianl修饰的变量就会变成常量（常量应当大写），一旦赋值不能改变，（可以在初始化时直接赋值，也可以在构造方法里也可以赋值，只能在这两种方法里二选一，不能不为常量赋值），fianl的常量不会有默认初始值，对于直接在初始化是赋值时final修饰符常和static修饰符一起使用。

2，final修饰方法，被final修饰的方法将不能被其子类覆盖，保持方法的稳定不能被覆盖。

3，final修饰类，被final修饰的类将不能被继承。final类中的方法也都是final的。

注意：final，不能用来修饰构造方法，在父类中如果有常量属性，在子类中使用常量属性时是不会进行父类的类加载。静态常量如果其值可以确定，就不会加载该类，如果不能确定则会加载该常量所在的类。

不变模式，对象一旦创建属性就不会改变。用final修饰属性，也用final修饰类（强不变模式），用final修饰属性（弱不变模式）。

不变模式的典型体现：java.lang.String类，不变模式可以实现对象的共享（可以用一个对象实例赋值给多个对象变量。）

池化的思想，把需要共享的数据放在池中（节省空间，共享数据）

只有String类可以用“”中的字面值创建对象。在String类中，以字面值创建时，会到Java方法空间的串池空间中去查找，如果有就返回串池中字符串的地址，并把这个地址付给对象变量。如果没有则会在串池里创建一个字符串对象，并返回其地址付购对象变量，当另一个以字面值创建对象时则会重复上述过程。

如果是new在堆空间中创建String类的对象，则不会有上述的过程。

String类中的intern()方法会将在堆空间中创建的String类对象中的字符串和串池中的比对，如果有相同的串就返回这个串的串池中的地址。

不变模式在对于对象进行修改，添加操作是使相当麻烦的，他会产生很多的中间垃圾对象。创建和销毁的资源的开销是相当大的。

String类在字符串连接时会先的效率很低，就是因为它所产生的对象的书性是不能够修改的，当连接字符串时也就是只能创建新的对象。

对于很多的字符串连接，应当使用StringBuffer类，在使用这个类的对象来进行字符串连接时就不会有多余的中间对象生成，从而优化了效率。

abstract（抽象）修饰符，可以修饰类和方法

1，abstract修饰类，会使这个类成为一个抽象类，这个类将不能生成对象实例，但可以做为对象变量声明的类型，也就是编译时类型，抽象类就像当于一类的半成品，需要子类继承并覆盖其中的抽象方法。

2，abstract修饰方法，会使这个方法变成抽象方法，也就是只有声明（定义）而没有实现，实现部分以”;”代替。需要子类继承实现（覆盖）。

注意：有抽象方法的类一定是抽象类。但是抽象类中不一定都是抽象方法，也可以全是具体方法。

abstract修饰符在修饰类时必须放在类名前。

abstract修饰方法就是要求其子类覆盖（实现）这个方法。调用时可以以多态方式调用子类覆盖（实现）后的方法，也就是说抽象方法必须在其子类中实现，除非子类本身也是抽象类。

注意：父类是抽象类，其中有抽象方法，那么子类继承父类，并把父类中的所有抽象方法都实现（覆盖）了，子类才有创建对象的实例的能力，否则子类也必须是抽象类。抽象类中可以有构造方法，是子类在构造子类对象时需要调用的父类（抽象类）的构造方法。

final和abstract，private和abstract，static和abstract，这些是不能放在一起的修饰符，因为abstract修饰的方法是必须在其子类中实现（覆盖），才能以多态方式调用，以上修饰符在修饰方法时期子类都覆盖不了这个方法，final是不可以覆盖，private是不能够继承到子类，所以也就不能覆盖，static是可以覆盖的，但是在调用时会调用编译时类型的方法，因为调用的是父类的方法，而父类的方法又是抽象的方法，又不能够调用，所以上的修饰符不能放在一起。

抽象（abstract）方法代表了某种标准，定义标准，定义功能，在子类中去实现功能（子类继承了父类并需要给出从父类继承的抽象方法的实现）。

方法一时间想不到怎么被实现，或有意要子类去实现而定义某种标准，这个方法可以被定义为抽象。(abstract)

模板方法模式

用abstract把制订标准和实现标准分开，制定的标准就是模板，实现就是按模板标准来实现，也就是继承模板，实现模板中相应功能的方法。模板中不允许修改的方法可以用fianl来修饰，这个方法不能使抽象方法，为保证安全，封装，把模板中不公开的部分用protected（保护）修饰。

java中修饰符是什么？用来干什么的？

public 是访问修饰符 就是访问级别的设置

Public

所有包所有地方都可以访问

Protected

同包以及子类可以访问

Friendly(default)

同包可以访问

Private

除了当前类任何地方都不可以访问

static 修饰的话就是静态块、只会执行一次

Java修饰符都有什么，请详细解答下？

Java语言提供了很多修饰符，主要分为以下两类：

1、访问修饰符；

2、非访问修饰符。

（视频教程推荐：java视频教程）

访问控制修饰符

Java中，可以使用访问控制符来保护对类、变量、方法和构造方法的访问。Java 支持 4 种不同的访问权限。

default (即默认，什么也不写）: 在同一包内可见，不使用任何修饰符。使用对象：类、接口、变量、方法。

private : 在同一类内可见。使用对象：变量、方法。 注意：不能修饰类（外部类）

public : 对所有类可见。使用对象：类、接口、变量、方法

protected : 对同一包内的类和所有子类可见。使用对象：变量、方法。 注意：不能修饰类（外部类）。

非访问修饰符

为了实现一些其他的功能，Java 也提供了许多非访问修饰符，如下：

static 修饰符，用来修饰类方法和类变量。

final 修饰符，用来修饰类、方法和变量，final 修饰的类不能够被继承，修饰的方法不能被继承类重新定义，修饰的变量为常量，是不可修改的。

abstract 修饰符，用来创建抽象类和抽象方法。

synchronized 和 volatile 修饰符，主要用于线程的编程。