java关于多态的一些理解

多态是指程序中定义的定义的引用变量所指向的具体类型和通过该引用变量发出的方法调用并不确定，而是在程序确定期间才确定，即一个引用变量到底会指向那个类的实例对象，该引用对象发出的方法调用到底是哪个类中实现的方法，必须在程序运行期间才能确定。因为是程序在运行时才确定具体的类，这样，不用修改原程序代码，就可以让引用变量绑定到各种不同的实现类上，从而导致该引用调用的具体方法随之改变，即不修改原程序的代码就可以改变程序运行时所绑定的具体代码，让程序可以选择多个运行状态。

这句话看上去有点难理解，我理解的时候是把这句话抄了一遍，应该会好一点吧。

父类的引用指向子类的对象：Father obj = new Son();

当使用父类引用指向子类对象的时候，父类引用不能调用子类独有的方法。（方法重载也是一样）。注意方法重载和方法重写的区别。

若子类重写了父类中的某些方法，在调用这些方法的时候，必定是使用子类定义的这些方法。

例子：

class Drink{
    public void drink(){
        System.out.println("Drink");
    }
}
class Wine extends Drink{
    public void SayColor(){
        System.out.println("白色");
    }

    public void TestChongxie(){
        System.out.println("Wine");
    }

    public String toString(){
        return null;
    }
}


class JNC extends Wine{
    public void SayTaste(){
        System.out.println("JNC");
    }
    public void TestChongxie(){
        System.out.println("JNC");
    }
}
class GJG extends Wine{
    public void SayTaste(){
        System.out.println("JNC");
    }
}
class WLY extends Wine{
    public void SayTaste(){
        System.out.println("JNC");
    }

    @Override
    public String toString() {
        return "WLY";
    }
}

public class Duotai2 {
    public static void main(String []args){
        Wine jnc = new JNC();
        jnc.SayColor();
//        jnc.SayTaste();  当使用父类引用指向子类对象的时候，父类引用不能调用子类独有的方法。
        jnc.TestChongxie();//若子类重写了父类中的某些方法，在调用这些方法的时候，必定是使用子类定义的这些方法。
        /*Object wly = new WLY();   //当子类重写父类的方法被调用时，只有对象继承链中的最末端的方法才会被调用。
        System.out.println(wly.toString());
        Object wine = new Wine();
        System.out.println(wine.toString());*/
        Wine wine = new JNC();
        wine.drink();
    }
}

上面代码的最后一行wine.drink()；是测试父类引用指向子类对象，调用函数的时候 会先查看父类有没有方法，如果没有会向上（父类的父类）寻找。

当父类引用指向子类对象的时候，调用方法会首先看父类对象中是否有这样的方法，如果没有，就去找父类的父类有没有这样的方法。

如果有，会先查看是否被子类覆盖（重写），不是重载哦。如果被覆盖了，则会调用子类的方法，如果没有被覆盖，则使用本类中的方法。

另外附加上一个特殊一点的例子，本例子中：其实在继承链中对象方法的调用存在一个优先级：this.show(O)、super.show(O)、this.show((super)O)、super.show((super)O)。

public class A {
    public String show(D obj) {
        return ("A and D");
    }

    public String show(A obj) {
        return ("A and A");
    } 

}

public class B extends A{
    public String show(B obj){
        return ("B and B");
    }
    
    public String show(A obj){
        return ("B and A");
    } 
}

public class C extends B{

}

public class D extends B{

}

public class Test {
    public static void main(String[] args) {
        A a1 = new A();
        A a2 = new B();
        B b = new B();
        C c = new C();
        D d = new D();
        
        System.out.println("1--" + a1.show(b));
        System.out.println("2--" + a1.show(c));
        System.out.println("3--" + a1.show(d));
        System.out.println("4--" + a2.show(b));
        System.out.println("5--" + a2.show(c));
        System.out.println("6--" + a2.show(d));
        System.out.println("7--" + b.show(b));
        System.out.println("8--" + b.show(c));
        System.out.println("9--" + b.show(d));      
    }
}

输出：

1--A and A

2--A and A

3--A and D

4--B and A

5--B and A

6--A and D

7--B and B

8--B and B

9--A and D

详细解释可以查看 java提高篇(四)-----理解java的三大特性之多态