java学习笔记 多态

java引用变量有两个类型：编译时类型，运行时类型。编译时类型由声明该变量时使用的类型决定，运行时类型由实际赋给该变量的对象决定。如果编译时类型和运行时类型不一致，就可能出现所谓的多态。

多态主要有以下两种表现方式：

1.方法的重载（overload）。重载是指同一个类中有多个同名的方法，但这些方法有着不同的参数，因此在编译时就可以确定到底调用哪个方法，它是一种编译时多态。重载可以被看做一个类中的方法多态性。

2.方法的覆盖（override）。子类可以覆盖父类的方法，因此同样的方法会在父类与子类中有着不同的变现形式。在java语言中，基类的引用变量不仅可以指向基类的实例对象，也可以指向其子类的实例对象。同样，接口的引用变量同样也可以指向其实现类的实例对象。而程序调用的方法在运行期才动态绑定（绑定指的是将一个方法调用和一个方法主体连接到一起），就是引用变量所指向的具体实例对象的方法，也就是内存里正运行的那个对象的方法，而不是引用变量的类型中定义的方法，通过这种动态绑定的方法实现了多态。由于只有运行时才能确定调用哪个方法，因此通过方法覆盖实现的多态也被称为运行时多态。

看一个例子：

class BaseClass
{
    public int book = 6;
    public void base()
    {
        System.out.println("父类的普通方法");
    }
    public void test()
    {
        System.out.println("父类的被覆盖的方法");
    }
}
public class SubClass extends BaseClass
{
    //重新定义一个book实例变量隐藏父类的book实例变量
    public String book = "轻量级Java EE企业应用实战";
    public void test()
    {
        System.out.println("子类的覆盖父类的方法");
    }
    public void sub()
    {
        System.out.println("子类的普通方法");
    }
    public static void main(String[] args)
    {
        // 下面编译时类型和运行时类型完全一样，因此不存在多态
        BaseClass bc = new BaseClass();
        // 输出 6
        System.out.println(bc.book);
        // 下面两次调用将执行BaseClass的方法
        bc.base();
        bc.test();
        // 下面编译时类型和运行时类型完全一样，因此不存在多态
        SubClass sc = new SubClass();
        // 输出"轻量级Java EE企业应用实战"
        System.out.println(sc.book);
        // 下面调用将执行从父类继承到的base()方法
        sc.base();
        // 下面调用将执行从当前类的test()方法
        sc.test();
        // 下面编译时类型和运行时类型不一样，多态发生
        BaseClass ploymophicBc = new SubClass();
        // 输出6 —— 表明访问的是父类对象的实例变量
        System.out.println(ploymophicBc.book);
        // 下面调用将执行从父类继承到的base()方法
        ploymophicBc.base();
        // 下面调用将执行从当前类的test()方法
        ploymophicBc.test();
        // 因为ploymophicBc的编译类型是BaseClass，
        // BaseClass类没有提供sub方法,所以下面代码编译时会出现错误。
        // ploymophicBc.sub();
    }
}

输出如下：
6
父类的普通方法
父类的被覆盖的方法
轻量级Java EE企业应用实战
父类的普通方法
子类的覆盖父类的方法
6
父类的普通方法
子类的覆盖父类的方法

上面程序main()方法中显式创建了三个引用变量，对于前两个引用变量bc和sc，它们编译时类型和运行时类型完全相同，因此调用它们的成员变量和方法非常正常完全没有任何问题，但是第三个引用变量 ploymophicBc比较特殊，它的编译时类型是BaseClass，而运行时类型是SubClass，当调用该应用变量的test()方法时，实际执行的是SubClass类中覆盖后的test()方法，这就可能出现多态。

与方法不同的是，对象的实例变量则不具备多态性，比如上面的 ploymophicBc引用变量，程序中输出它的book实例变量时，并不是输出SubClass类里定义的实例变量，而是输出BaseClass类的实例变量。

再看两个例子程序，对上述分析加以理解

class Base{
    public Base(){
        g();
    }

    public void f(){
        System.out.println("Base f()");
    }

    public void g(){
        System.out.println("Base g()");
    }
}

class Derived extends Base{
    public void f(){
        System.out.println("Derived f()");
    }

    public void g(){
        System.out.println("Derived g()");
    }
}
public class Test {
    public static void main(String [] args){
        Base b=new Derived();
        b.f();
        b.g();
    }

}
程序输出：
Derived g()
Derived f()
Derived g()

解析：执行Base b=new Derived();语句时，调用Base类的构造函数，而在Base类的构造函数中，执行了g()方法，由于java语言的多态性，此时会输出子类的g()方法，而非父类的g()方法，即输出Derived g()。由于实际创建的是Derive的对象，后面的方法调用都会调用子类Derive的方法。

class Base{
    public int i=1;
}

class Derived extends Base{
    public int i=2;
}
public class Test {
    public static void main(String [] args){
        Base b=new Derived();
        System.out.println(b.i);
    }

}

输出i为1，由此可见，成员变量是无法实现多态的，成员变量的值取父类还是子类并不取决于创建对象的类型，而是取决于所定义变量的类型，这是在编译期间决定的。在上例中，b所属的类型为Base，b.i指的是Base类中定义的i，因此程序输出结果为1.

总结：引用变量在编译阶段只能调用其编译时类型所具有的方法，但运行时则执行它运行时所具有的方法。因此，编写java代码时，引用变量只能调用声明该变量时所用类里包含的方法。eg：Object p=new Person()定义一个变量p，则这个p只能调用Object类的方法，而不能调用Person类里定义的方法。