java基础之多态

什么是多态

说多态前我们首先要知道Java的引用类型变量有两种更细类型：一个是编译时类型，一个是运行时类型。 编译时类型由声明这个变量的时候决定的，比如 String a="你好"; 运行时类型则是由实际赋值给这个变量的对象来决定的。Integer b=1; String a = b; 如果编译时类型和运行时类型不一致的时候，就可能出现所谓的多态！ 子类类型的对象赋值给父类类型的引用变量！

比如一个酒神，对酒情有独钟。某日回家发现桌上有几个杯子里面都装了白酒，从外面看我们是不可能知道这是些什么酒，只有喝了之后才能够猜出来是何种酒。酒神一喝，这是剑南春、再喝这是五粮液、再喝这是酒鬼酒….在这里我们可以描述成如下：
酒 a = 剑南春 // 这个时候就发生了java里边说的：多态
酒 b = 五粮液
酒 c = 酒鬼酒
说一句话：剑南春是白酒， 白酒做成父类，剑南春白酒的子类，java语言！
上面的例子中酒是一个类， 剑南春也是一个类， 酒类包含了剑南春这个子类，我们把子类的对象赋值给父类类型的引用变量叫做子类的向上转型。
用代码来表示：

public class Wine {
    public void fun1(){
        System.out.println("Wine 的Fun.....");
        fun2();
    }
    
    public void fun2(){
        System.out.println("Wine 的Fun2...");
    }
}

public class JNC extends Wine{
    /**
     * @desc 子类重载父类方法
     *        父类中不存在该方法，向上转型后，父类是不能引用该方法的
     * @param a
     * @return void
     */
    public void fun1(String a){
        System.out.println("JNC 的 Fun1...");
        fun2();
    }
    
    /**
     * 子类重写父类方法
     * 指向子类的父类引用调用fun2时，必定是调用该方法
     */
    public void fun2(){
        System.out.println("JNC 的Fun2...");
    }
}

public class Test {
    public static void main(String[] args) {
 Win a1 = new Win(); //声明的变量和赋值的对象同种类型，不存在多态
        Wine a = new JNC(); //声明的变量和赋值的对象不同类型，这就存在多态了
        a.fun1();
    }
}

从程序的运行结果中我们发现，a.fun1()首先是运行父类Wine中的fun1().然后再运行子类JNC中的fun2()。
分析：在这个程序中子类JNC重载了父类Wine的方法fun1()，重写fun2()，而且重载后的fun1(String a)与 fun1()不是同一个方法，父类中没有含参数的fun1方法，向上转型后会丢失子类里的特有方法，所以用JNC这个类的对象的Wine类型引用是不能引用有参数的fun1(String a)方法。而子类JNC重写了fun2() ，那么指向JNC的Wine引用会优先调用JNC中fun2()方法。

所以对于多态我们可以总结如下：

指向子类的父类引用由于向上转型了，它只能访问父类中拥有的方法和属性，如果有重名的属性，调用的是父类的属性，因为属性不能被重写，而对于子类中存在而父类中不存在的方法，该引用是不能使用的，尽管是重载该方法。若子类重写了父类中的某些方法，在调用该些方法的时候，必定是使用子类中定义的这些方法，他们优先级高于父类中的方法。

2、多态的实现机制

基于继承(包括我们后面要讲的接口，对接口的实现我们也可以理解为一种特殊的继承)的多态实现机制主要表现在父类和继承该父类的一个或多个子类对某些方法的重写，多个子类对同一方法的重写可以表现出不同的行为。多态：多种形态，就是多态性!（用代码是说明一下！）

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

在这里看结果1、2、3还好理解，从4开始就开始糊涂了，对于4来说为什么输出不是“B and B”呢？

其实在继承链中对象方法的调用存在优先级：this.show(O)、super.show(O)、this.show((super)O)、super.show((super)O)。

首先我们分析5，a2.show©，a2是A类型的引用变量，所以this就代表了A，a2.show©,它在A类中找发现没有找到，于是到A的超类中找(super)，由于A没有超类（Object除外），所以跳到第三级，也就是this.show((super)O)，C的超类有B、A，所以(super)O为B、A，this同样是A，这里在A中找到了show(A obj)，同时由于a2是B类的一个引用且B类重写了show(A obj)，因此最终会调用子类B类的show(A obj)方法，结果也就是B and A。

当超类对象引用变量引用子类对象时，被引用对象的类型决定了调用谁的成员方法，但是这个被调用的方法必须是在超类中定义过的，在看一个例子说明：a2.show(b)；

这里a2是引用变量，为A类型，它引用的是B对象，因此按照上面那句话的意思是说由B来决定调用谁的方法,所以a2.show(b)应该要调用B中的show(B obj)，产生的结果应该是“B and B”，但是为什么会与前面的运行结果产生差异呢？这里我们忽略了后面那句话“但是这儿被调用的方法必须是在超类中定义过的”，那么show(B obj)在A类中存在吗？根本就不存在！所以这句话在这里不适用？那么难道是这句话错误了？非也！其实这句话还隐含这这句话：它仍然要按照继承链中调用方法的优先级来确认。所以它才会在A类中找到show(A obj)，同时由于B重写了该方法所以才会调用B类中的方法，否则就会调用A类中的方法。