Java 修饰符(访问修饰符 非访问修饰符)详解

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

    访问修饰符

    非访问修饰符

    修饰符用来定义类、方法或者变量，通常放在语句的最前端。我们通过下面的例子来说明：

public class className {
   // ...
}
private boolean myFlag;
static final double weeks = 9.5;
protected static final int BOXWIDTH = 42;
public static void main(String[] arguments) {
   // 方法体
}

 

2.访问控制修饰符

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

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

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

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

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

我们可以可以通过以下表来说明访问权限：

修饰符	当前类内部	同一包内	子孙类	其他包	其他包子孙类
public	Y	Y	Y	Y	Y
protected	Y	Y	Y	N	Y/N
default（缺省）	Y	Y	N	N	N
private	Y	N	N	N	N

 

3.非访问修饰符

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

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

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

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

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

 

3.1 static 修饰符

静态变量：

    static 关键字用来声明独立于对象的静态变量，无论一个类实例化多少对象，它的静态变量只有一份拷贝。 静态变量也被称为类变量。局部变量不能被声明为 static 变量。

静态方法：

    static 关键字用来声明独立于对象的静态方法。静态方法不能使用类的非静态变量。静态方法从参数列表得到数据，然后计算这些数据。

对类变量和方法的访问可以直接使用 classname.variablename 和 classname.methodname 的方式访问。

如下例所示，static修饰符用来创建类方法和类变量。

public class InstanceCounter {
   private static int numInstances = 0;
   protected static int getCount() {
      return numInstances;
   }
 
   private static void addInstance() {
      numInstances++;
   }
 
   InstanceCounter() {
      InstanceCounter.addInstance();
   }
 
   public static void main(String[] arguments) {
      System.out.println("Starting with " +
      InstanceCounter.getCount() + " instances");
      for (int i = 0; i < 500; ++i){
         new InstanceCounter();
          }
      System.out.println("Created " +
      InstanceCounter.getCount() + " instances");
   }
}
以上实例运行编辑结果如下:
Started with 0 instances
Created 500 instances

 

3.2 final 修饰符

    final从字面上理解含义为“最后的，最终的”。在Java中也同样表示出此种含义。final可以用来修饰变量（包括类属性、对象属性、局部变量和形参）、方法（包括类方法和对象方法）和类。

① final修饰类:

    final修饰类即表示此类已经是“最后的、最终的”含义。因此，用final修饰的类不能被继承，即不能拥有自己的子类。

    如果视图对一个已经用final修饰的类进行继承，在编译期间或发生错误。

② final修饰方法：

    final修饰的方法表示此方法已经是“最后的、最终的”含义，亦即此方法不能被重写（可以重载多个final修饰的方法）。

    此处需要注意的一点是：因为重写的前提是子类可以从父类中继承此方法，如果父类中final修饰的方法同时访问控制权限为private，将会导致子类中不能直接继承到此方法，因此，此时可以在子类中定义相同的方法名和参数，此时不再产生重写与final的矛盾，而是在子类中重新定义了新的方法。

public class B extends A {
 
     public static void main(String[] args) {
 
     }
 
     public void getName() {
         
     }
 }
 
 class A {
 
     /**
      * 因为private修饰，子类中不能继承到此方法，因此，子类中的getName方法是重新定义的、
      * 属于子类本身的方法，编译正常
      */
     private final void getName() {
         
     }
 
     /* 因为pblic修饰，子类可以继承到此方法，导致重写了父类的final方法，编译出错
     public final void getName() {
     
     }
     */
 }

③  final 修饰变量：

    final修饰的变量表示此变量是“最后的、最终的”含义。一旦定义了final变量并在首次为其显示初始化后，final修饰的变量值不可被改变。

3.3 abstract 修饰符：后续讲解

3.4 synchronized 修饰符：后续讲解

3.5 transient 修饰符：后续讲解

3.6 volatile 修饰符：后续讲解

 

 

4.说明

4.1 static 修饰符 ： 代表静态的，可用于修饰  属性、方法、代码块，内部类。

(1) static 修饰的属性（静态变量或类变量）：

    ① 随着类的加载而加载，随着类的消失而消失(生命周期最长)。

    ② static修饰的属性被所有该类的对象所共享

    ③ 一旦某个对象改变该属性值，其他对象该属性值也会随之改变

    ④ 静态变量的存在优先于对象

    ⑤ 可以通过 "类名.类变量"的方式调用

(2) static 修饰的方法（静态方法或类方法）：

    ① 随着类的加载而加载

    ② 静态方法的存在优先于对象

    ③ 可以通过"类名.类方法"的方式调用

    ④ 静态方法中不能调用非静态成员

    ⑤ 静态方法不能使用 this 和 super

(3) static 修饰的代码块

① 静态代码块

① 格式：  static{}

② 随着类的加载而加载，并且只加载一次

③ 静态代码块的执行优先于非静态代码块

④ 静态代码块中不能调用非静态成员

⑤ 静态代码块可以有多个，依次向下的顺序执行

② 非静态代码块

① 格式：类中的一对 {}

② 在每次创建对象时被调用

③ 非静态代码块的执行优先于构造器

④ 用于为对象初始化。（通常为共性内容进行初始化）

⑤ 非静态代码块可以有多个，依次向下的顺序执行

(4) 内部类

① 静态内部类

public class Hello {
    static int a = 2; 
       public static void main(String[] args){
            //  new newHello().count(); 
            System.out.println(new newHello().b); 
        }  
       public static class newHello{ 
           int b = 3; 
           public void count(){   
           System.out.println(a); 
           }     
       }  
}

② 非静态内部类

public class Hello {
    int a = 2;
    public static void main(String[] args){
        new Hello().new newHello().count();
    }
   public class newHello {
       public void count(){
           new Hello().a = 1;
           System.out.println("aaa");
       }
   }
}

(5) 为属性赋初始值的方式顺序：

    ① 默认赋值

    ② 直接显示赋值

    ③ 代码块（静态代码块 非静态代码块）

    ④ 构造器

 

4.2 final 修饰符：代表最终的，可用于修饰方法 变量、类。

    ① final 修饰的类不能被继承

    ② final 修饰的方法不能被重写

    ③ final 修饰的变量叫常量，一旦被赋值，值不能改变。       

说明：命名规范

    ① 所有字母都大写，每个单词之间以 "_” 分隔

    ② 常量没有默认值。在使用前必须赋值(直接显示赋值、构造器、代码块)

    ③ 若选择使用构造器为常量赋值，必须保证“所有”构造器都为常量赋值。          

 

4.3 联合使用 static final

     适用范围：只能修饰成员变量、方法、内部类。

     成员变量：属于类的变量且只能赋值一次。

     方法：属于类的方法且不可以被重写。

     内部类：属于外部类，且不能被继承。

    static和final的意义是不同的，static修饰的时候代表对象是静态的，而final修饰的时候代表对象只能赋值一次，他们连用的时候是因为定义的那个对象既要它是静态的，也要求它的值不能再被修改。

    举例说明：

    static int a=1;

    static final b=1;

    这里a和b的区别在于，a在程序里可以被重新赋值为2或3或等等的整数，而b在程序里不能被重新赋值，b永远都为1，也就是说b是一个常量。

    final int c=1;    

    static final b=1;

    这里c和b的区别在于，b存放在静态空间，不会在程序运行时被释放，它永远占着内存直到程序终止，而c在程序用完它而不会再用到它的时候就会被自动释放，不再占用内存。

    当一个常数或字符串我们需要在程序里反复反复使用的时候，我们就可以把它定义为static final，这样内存就不用重复的申请和释放空间。