Java 修饰符、运算符笔记总结

1. 访问控制修饰符

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

• default (即缺省，什么也不写）: 在同一包内可见，不使用任何修饰符。使用对象：类、接口、变量、方法。
• private : 在同一类内可见。使用对象：变量、方法。 注意：不能修饰类（外部类）
• public : 对所有类可见。使用对象：类、接口、变量、方法
• **重点内容**protected : 对同一包内的类和所有子类可见。使用对象：变量、方法。 注意：不能修饰类（外部类）。
  

1.1 默认访问修饰符-不使用任何关键字

使用默认访问修饰符声明的变量和方法，对同一个包内的类是可见的。接口里的变量都隐式声明为 public static final,而接口里的方法默认情况下访问权限为 public。

1.2 私有访问修饰符-private

私有访问修饰符是最严格的访问级别，所以被声明为 private 的方法、变量和构造方法只能被所属类访问，并且类和接口不能声明为 private。
声明为私有访问类型的变量只能通过类中公共的 getter 方法被外部类访问。
Private 访问修饰符的使用主要用来隐藏类的实现细节和保护类的数据。

1.3 受保护的访问修饰符-protected

被声明为 protected 的变量、方法和构造器能被同一个包中的任何其他类访问，也能够被不同包中的子类访问。
protected 访问修饰符不能修饰类和接口，方法和成员变量能够声明为 protected，但是接口的成员变量和成员方法不能声明为 protected。
子类能访问 protected 修饰符声明的方法和变量，这样就能保护不相关的类使用这些方法和变量。

JAVA 的类（外部类）有 2 种访问权限: public、default。
而方法和变量有 4 种：public、default、protected、private。
其中默认访问权限和 protected 很相似，有着细微的差别。

public 意味着任何地方的其他类都能访问。
default 则是同一个包的类可以访问。
protected 表示同一个包的类可以访问，其他的包的该类的子类也可以访问。
private 表示只有自己类能访问。

修饰符：abstract、static、final

abstract: 表示是抽象类。 使用对象：类、接口、方法
static: 可以当做普通类使用，而不用先实例化一个外部类。（用他修饰后，就成了静态内部类了）。 使用对象：类、变量、方法、初始化函数（注意：修饰类时只能修饰 内部类 ）
final: 表示类不可以被继承。 使用对象：类、变量、方法

关于static修饰符的理解
怎么理解静态变量呢？简单来说静态变量就是一个类的公有属性。在这里可以打个拙劣的比方：假设”班里的学生”是一个类，班里的任何一个同学都相当于一个对象。那么所有学生的学费是一样的对吧？”学费”就相当于一个”静态变量”，其特征是它不属于任何一个”对象”（即学生）的专有属性，是大家”公有”的，若是变了，那就所有的同学的学费都会变。我们假设每个同学都有修改学费的权力，那么任何一个同学修改了学费（这个静态变量），所有同学的学费就都会变。
另外：静态方法只能使用类的静态变量。

2. 访问控制和继承

• 父类中声明为 public 的方法在子类中也必须为 public。
• 父类中声明为 protected 的方法在子类中要么声明为 protected，要么声明为 public，不能声明为 private。
• 父类中声明为 private 的方法，不能够被继承。

3. 非访问修饰符

• static 修饰符，用来修饰类方法和类变量。
• final 修饰符，用来修饰类、方法和变量，final 修饰的类不能够被继承，修饰的方法不能被继承类重新定义，修饰的变量为常量，是不可修改的。
• abstract 修饰符，用来创建抽象类和抽象方法。
• synchronized 和 volatile 修饰符，主要用于线程的编程。

3.1 static 修饰符

静态变量：
static 关键字用来声明独立于对象的静态变量，无论一个类实例化多少对象，它的静态变量只有一份拷贝。 静态变量也被称为类变量。局部变量不能被声明为 static 变量。
静态方法：
static 关键字用来声明独立于对象的静态方法。静态方法不能使用类的非静态变量。静态方法从参数列表得到数据，然后计算这些数据。

3.2 final 修饰符

final 变量：
final 变量能被显式地初始化并且只能初始化一次。被声明为 final 的对象的引用不能指向不同的对象。但是 final 对象里的数据可以被改变。也就是说 final 对象的引用不能改变，但是里面的值可以改变。
final 修饰符通常和 static 修饰符一起使用来创建类常量。

final 方法
类中的 final 方法可以被子类继承，但是不能被子类修改。
声明 final 方法的主要目的是防止该方法的内容被修改。

final 类
final 类不能被继承，没有类能够继承 final 类的任何特性。

3.3 abstract 修饰符

抽象类：
抽象类不能用来实例化对象，声明抽象类的唯一目的是为了将来对该类进行扩充。
一个类不能同时被 abstract 和 final 修饰。如果一个类包含抽象方法，那么该类一定要声明为抽象类，否则将出现编译错误。
抽象类可以包含抽象方法和非抽象方法。

抽象方法
抽象方法是一种没有任何实现的方法，该方法的的具体实现由子类提供。
抽象方法不能被声明成 final 和 static。
任何继承抽象类的子类必须实现父类的所有抽象方法，除非该子类也是抽象类。
如果一个类包含若干个抽象方法，那么该类必须声明为抽象类。抽象类可以不包含抽象方法。

3.4 synchronized 修饰符

synchronized 关键字声明的方法同一时间只能被一个线程访问。synchronized 修饰符可以应用于四个访问修饰符。

3.5 transient 修饰符

序列化的对象包含被 transient 修饰的实例变量时，java 虚拟机(JVM)跳过该特定的变量。
该修饰符包含在定义变量的语句中，用来预处理类和变量的数据类型。

public transient int limit = 55;   // 不会持久化
public int b; // 持久化

3.6 volatile 修饰符

volatile 修饰的成员变量在每次被线程访问时，都强制从共享内存中重新读取该成员变量的值。而且，当成员变量发生变化时，会强制线程将变化值回写到共享内存。这样在任何时刻，两个不同的线程总是看到某个成员变量的同一个值。
一个 volatile 对象引用可能是 null。

public class MyRunnable implements Runnable
{
    private volatile boolean active;
    public void run()
    {
        active = true;
        while (active) // 第一行
        {
            // 代码
        }
    }
    public void stop()
    {
        active = false; // 第二行
    }
}

通常情况下，在一个线程调用 run() 方法（在 Runnable 开启的线程），在另一个线程调用 stop() 方法。 如果 第一行 中缓冲区的 active 值被使用，那么在 第二行 的 active 值为 false 时循环不会停止。
但是以上代码中我们使用了 volatile 修饰 active，所以该循环会停止.

4. final以及final static修饰的变量的初始化方式：

 //-----------------成员变量------------------//  
    //初始化方式一，在定义变量时直接赋值  
    private final int i = 3;  

    //初始化方式二,声明完变量后在构造方法中为其赋值  
    //如果采用用这种方式，那么每个构造方法中都要有j赋值的语句  
    private final int j;  

    public FinalTest() {  
        j = 3;  
    }  

    //如果取消该构造方法的注释，程序就会报错，因此它没有为j赋值  
    /*public FinalTest1(String str) { 

    }*/  

    //为了方便我们可以这样写  
    public FinalTest(String str) {  
        this();  //调用无参构造器
    }  

    //下面的代码同样会报错，因为对j重复赋值  
    /*public FinalTest1(String str1, String str2) { 
        this(); 
        j = 3; 
    }*/  


    //初始化方式三，声明完变量后在构造代码块中为其赋值  
    //如果采用此方式，就不能在构造方法中再次为其赋值  
    //构造代码块中的代码会在构造函数之前执行，如果在构造函数中再次赋值，  
    //就会造成final变量的重复赋值  
    private final int k;  

    {  
        k = 4;  
    }  

    //-----------------类变量（静态变量）------------------//  
    //初始化方式一，在定义类变量时直接赋值  
    public final static int p = 3;  

    //初始化方式二，在静态代码块中赋值  
    //成员变量可以在构造函数中赋值，但是类变量却不可以。  
    //因此成员变量属于对象独有，每个对象创建时只会调用一次构造函数，  
    //因此可以保证该成员变量只被初始化一次；  
    //而类变量是该类的所有对象共有，每个对象创建时都会对该变量赋值  
    //这样就会造成变量的重复赋值。  
    public final static int q;  

    static {  
        q = 3;  
    }

5. instanceof 运算符

运算符的总结只需要看一下instanceof 运算符即可

该运算符用于操作对象实例，检查该对象是否是一个特定类型（类类型或接口类型）。

( Object reference variable ) instanceof  (class/interface type)

如果被比较的对象兼容于右侧类型,该运算符仍然返回true。

class Vehicle {}

public class Car extends Vehicle {
   public static void main(String[] args){
      Vehicle a = new Car();
      boolean result =  a instanceof Car;  //true
      System.out.println( result);  
   }
}

运算符总结：
1. 在判断一个实例引用的类型时，使用的是实际类型，而不是声明的类型。在下面的代码中

Vehicle v2 = new Car();    // v2 是 Car 类型

v2 是 Car 类型，而不是 Vehicle 类型。
也即是子类是父类的类型，但父类不是子类的类型。子类的实例可以声明为父类型，但父类的实例不能声明为子类型。

class Vehicle {}

public class Car extends Vehicle {
    public static void main(String args[]){
        Vehicle v1 = new Vehicle(); //父类型
        Vehicle v2 = new Car(); //子类的实例可以声明为父类型
        Car c1 = new Car();    // 子类型
        Car c2 = new Vehicle(); //这句会报错，父类型的实例不能声明为子类型

        //Car（子类）是Vehicle（父类）类型, Vehicle（父类）不是Car（子类）类型
        boolean result1 =  c1 instanceof Vehicle;    // true
        boolean result2 =  c1 instanceof Car;        // true
        boolean result3 =  v1 instanceof Vehicle;    // true
        boolean result4 =  v1 instanceof Car;          // false
        boolean result5 =  v2 instanceof Vehicle;    // true
        boolean result6 =  v2 instanceof Car;          // true

        System.out.println(result1);
        System.out.println(result2);
        System.out.println(result3);
        System.out.println(result4);
        System.out.println(result5);
        System.out.println(result6);
   }
}

从执行结果来看，虽然 v2 被声明为了 Vehicle（父类），但它既是 instanceof Vehicle，又是 instanceof Car，所以 v2 其实是 Car（子类），否则 v2 instanceof Car 应该为 false。

摘自：http://www.runoob.com/java/java-modifier-types.html