《疯狂JAVA讲义》——多态

Java引用变量有两个类型：一个是编译时的类型，一个是运行时的类型。

编译时的类型由声明该变量时所使用的类型决定；
运行时的类型由实际赋值给该变量的对象决定。

当编译时的类型与运行时的类型不一致时，会发生多态（Polymorphism）。

代码：

class BaseClass
{
    public int book = 6;
    public void base()
    {
        System.out.println("父类的普通方法");
    }
    public void test()
    {
        System.out.println("父类被覆盖的方法");
    }
}

class SubClass extends BaseClass
{
    //重新定义一个book实例Field隐藏父类的book实例Field
    public String book = "疯狂java讲义";
    public void test()
    {
        System.out.println("子类覆盖父类的方法");
    }
    public void sub()
    {
        System.out.println("子类的普通方法");
    }
}

public class PolymorphismTest
{
    public static void main(String[] args)
    {
        //编译时和运行时类型一样，不存在多态
        BaseClass bc = new BaseClass();
        System.out.println(bc.book);//输出6
        bc.base();//输出“父类的普通方法”
        bc.test();//输出“父类被覆盖的方法”

        //编译时和运行时类型一样，不存在多态
        SubClass sc = new SubClass();
        System.out.println(sc.book);//输出“疯狂java讲义”
        sc.base();//输出“父类的普通方法”，执行子类从父类继承的base方法
        sc.test();//输出“子类覆盖基类的方法”
        sc.sub();//输出“子类的普通方法”

        //编译时和运行时类型不一样，多态发生            
        BaseClass polymorphicBc = new SubClass();
        System.out.println(polymorphicBc.book);//输出6，表明访问的是父类的Field
        polymorphicBc.base();//输出“父类的普通方法”，执行子类从父类继承到的base方法
        polymorphicBc.test();//输出“子类覆盖基类的方法”，执行子类的test方法
        polymorphicBc.sub();//编译报错，BaseClass类没有sub方法
    }
}

Java允许把一个子类对象直接赋给一个父类引用，即父类引用可以指向子类对象，无需任何类型转换，被称为向上转型（upcasting），由系统自动完成。

代码中的polymorphicBc对象在编译时是BaseClass类型，而在运行时是SubClass类型。所以polymorphicBc.sub();语句在编译时会引发错误，因为BaseClass类没有sub方法。

通过引用变量来访问其包含的Field实例时，系统总是试图访问它编译时类型所定义的Field，而不是它运行时所定义的Field。所以System.out.println(polymorphicBc.book);输出6，即访问的是BaseClass类中定义的int类型的book。