Java 编译时类型和运行时类型

编译时类型和运行时类型：

Java的引用变量有两个类型，一个是编译时类型，一个是运行时类型，编译时类型由声明该变量时使用的类型决定，运行时类型由实际赋给该变量的对象决定。如果编译时类型和运行时类型不一致，会出现所谓的多态。因为子类其实是一种特殊的父类，因此java允许把一个子类对象直接赋值给一个父类引用变量，无须任何类型转换，或者被称为向上转型，由系统自动完成。

引用变量在编译阶段只能调用其编译时类型所具有的方法，但运行时则执行它运行时类型所具有的方法（意思是说：编写代码时，只能调用父类中具有的方法，如果子类重写了该方法，运行时实际调用的是运行时类型的该方法。程序在编译时，会在编译类型中检查是否具有所调用的方法，如果编写代码时，使用引用变量调用子类中的特有方法，或者调用重载了父类中的方法，而父类中找不到该方法，则会报编译错误），因此，编写Java代码时，引用变量只能调用声明该变量所用类里包含的方法。与方法不同的是，对象的属性则不具备多态性。通过引用变量来访问其包含的实例属性时，系统总是试图访问它编译时类所定义的属性，而不是它运行时所定义的属性。

——要访问子类中特有的方法和属性，在编写代码时，则必须进行类型转换。

—— 以上摘自《疯狂Java讲义》

1.子类方法覆盖父类方法（ 子类重写父类中的方法，调用子类中的方法）

class Father {
    public void method() {
        System.out.println("父类方法：" + this.getClass());
    }
}

public class Son extends Father {
    public void method() {
        System.out.println("子类方法：" + this.getClass());
    }

    public static void main(String[] args) {
        Father instance = new Son();
        instance.method();
    }
}
//运行结果：子类方法：class Son

2. 子类没有重写父类中的方法，所以到父类中寻找相应的方法

class Father {
    public void method() {
        System.out.println("父类方法：" + this.getClass());
    }
}

public class Son extends Father {
    public static void main(String[] args) {
        Father instance = new Son();
        instance.method();
    }
}
//运行结果： 父类方法： class Father

3.动态绑定只是针对对象的方法，对于属性无效。因为属性不能被重写。

class Father {
    public String name = "Father'name";
}

public class Son extends Father {
    public String name = "Son'name";

    public static void main(String[] args) {
        Father instance = new Son();
        System.out.println(instance.name);
    }
}

//    运行结果：Father'name
//    这里还可以从另外一个方面来说明：如果将Father类的
//    public String name = "Father'name";修改为
//    private String name = "Father'name";
//System.out.println(instance.name);那么编译器将报错：
//    错误: Father中private name不可以访问
//说明在System.out.println(instance.name);
//    这行代码执行时，访问的是父类的name属性，而该属性被声明为private，所以无法访问，
//    因而报错！

4.下面再分析一个例子

class A {
    int count = 20;
}

class B extends A {
    int count = 200;
}

public class Test {
    public static void main(String[] args) {
        A a = new A();
        System.out.println(a.count);
        B b = new B();
        System.out.println(b.count);
        A ab = b; //向上转型
        System.out.println(ab.count);
    }
}

//    运行结果 ： 20   200    20
//    结果分析：
//    前两行的输出毫无疑问，问题在
//    A ab = b;
//System.out.println(ab.count);
//    的输出是20，而不是200；
//            在这之前我们可以用System.out.println(ab == b);
//    来进行简单的判断，结果输出为 true， 说明 ab 和 b 两个引用变量指向同一个实例，
//    既然 ab 和 b 指向同一个实例，为什么输出的是20不是200呢？原因在于：
//            1.对于 class A 和class B来说，class B是class A的子类，由于子类的变量并不会
//    覆盖父类的变量，所以实际上在class B中是存在来两个count，在这分别记作 A.count
//    和B.count ；
//            2.虽然在 class B中存在A.count 和B.count ，但是究竟输出那一个 count ，取决于
//    该引用变量的声明时类型（本文开头红色文字部分已经说明），
//    此处 声明时类型 是 class A，所以输出 20 即A.count ，同理若改为 B ab = b ；
//    则输出 200 即 B.count