在判断一个实例引用的类型时，使用的是实际类型，而不是声明的类型。在下面的代码中，

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

v2 是 Car 类型，而不是 Vehicle 类型。

class Vehicle {}

public class Car extends Vehicle {
    public static void main(String args[]){
        Car c1 = new Car();

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

        //Car 是 Vehicle类型, Vehicle 不是 Car 类型
        boolean result1 =  c1 instanceof Vehicle;    // true
        boolean result2 =  v2 instanceof Car;        // true
        boolean result3 =  v2 instanceof Vehicle;    // true
        boolean result4 =  v3 instanceof Car;          // false

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

fina、static、abstract 之间不能同时使用的问题：

1、final 不能同时和 abstract 使用，例子：

abstract final void m();

原因：因为 abstract 是需要被子类继承覆盖的，否则毫无意义，而 final 作用是禁止继承的，两者相互排斥，所以不呢能 共用。

2：static 和 abstract 也是不能连用的，例子：

abstract static void m(){}

原因：因为 static 是类级别的不能被子类覆盖，而 abstract 需要被继承实现，两者相互矛盾。

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;  
    }

关于final变量:

• 1、 final 修饰符通常和 static 修饰符一起使用来创建类常量。用final修饰的成员变量表示常量，值一旦给定就无法改变！
• 2、 final修饰的变量有三种：静态变量、实例变量和局部变量，分别表示三种类型的常量。final变量定义的时候，可以先声明，而不给初值，这中变量也称为final空白，无论什么情况，编译器都确保空白final在使用之前必须被初始化。但是，final空白在final关键字final的使用上提供了更大的灵活性，为此，一个类中的final数据成员就可以实现依对象而有所不同，却有保持其恒定不变的特征。

transient

当对象被序列化时（写入字节序列到目标文件）时，transient阻止实例中那些用此关键字声明的变量持久化；当对象被反序列化时（从源文件读取字节序列进行重构），这样的实例变量值不会被持久化和恢复。

import java.io.FileInputStream;
import java.io.FileNotFoundException;
import java.io.FileOutputStream;
import java.io.IOException;
import java.io.ObjectInputStream;
import java.io.ObjectOutputStream;
import java.io.Serializable;

//定义一个需要序列化的类

class People implements Serializable{
    String name; //姓名
    transient Integer age; //年龄
    public People(String name,int age){
        this.name = name;
        this.age = age;
    }

    public String toString(){
        return "姓名 = "+name+" ,年龄 = "+age;
    }

}

public class TransientPeople {
    public static void main(String[] args) throws FileNotFoundException, IOException, ClassNotFoundException {
        People a = new People("李雷",30);
        System.out.println(a); //打印对象的值
        ObjectOutputStream os = new ObjectOutputStream(new FileOutputStream("d://people.txt"));
        os.writeObject(a);//写入文件(序列化)
        os.close();
        ObjectInputStream is = new ObjectInputStream(new FileInputStream("d://people.txt"));
        a = (People)is.readObject();//将文件数据转换为对象（反序列化）
        System.out.println(a); // 年龄 数据未定义
        is.close();
    }
}

运行结果如下：

姓名 = 李雷 ,年龄 = 30
姓名 = 李雷 ,年龄 = null

volatile

volatile可以用在任何变量前面，但不能用于final变量前面，因为final型的变量是禁止修改的。

使用的场景之一，单例模式中采用DCL双锁检测（double checked locking）机制，在多线程访问的情况下，可使用volatitle修改，保证多线程下的可见性。缺点是性能有损失，因此单线程情况下不必用此修饰符。

class Singleton{
    private volatile static Singleton instance = null;
    private Singleton() {
    }

    public static Singleton getInstance() {
        if(instance==null) {
            synchronized (Singleton.class) {
                if(instance==null)
                    instance = new Singleton();
            }
        }
        return instance;
    }
}