java中的多态

    有两种多态的机制：编译时多态、运行时多态

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

      2、方法的覆盖：子类可以覆盖父类的方法，因此同样的方法会在父类中与子类中有着不同的表现形式。在java语言中，基类的引用变量不仅可以指向基类的实例对象，也可以指向子类的实例对象，同样，接口中的引用变量也可以指向其实现类的实例对象。  

JAVA 运行继承重载的方法先后顺序

      1、程序首先保证的是编译不能出错，所以，方法调用以引用类型为准，引用调用方法的优先级：
  this.show(object) > super.show(object) > this.show(super(object))
 
      2、运行阶段的调用规则是，变量和静态方法优先按引用类型来调用，
 其余方法优先按实例类型来调用！
 

 

public class A {
    public void show(A a){
        System.out.println("A & A");
    }

    public void show(D d){
        System.out.println("A & D");
    }
}
/**
 * @program: 
 * @description:
 * @author: Mr.ZY
 * @create: 2019-07-04 22:54
 * B 继续与A 并且重写A的一个show方法 show(A obj)
 **/
public class B extends A{
    public void show(B obj){
        System.out.println ("B & B");
    }
    //重写父类方法
    public void show(A obj){
        System.out.println ("B & A");
    }


}

 

public class C extends B {
}
public class D extends B{
}

 

下面是执行代码

public class TestMain {

    public static void main(String [] args){
        /**
         * 程序首先保证的是编译不能出错，所以，方法调用以引用类型为准，引用调用方法的优先级：
         * this.show(object) > super.show(object) > this.show(super(object))
         *
         * 运行阶段的调用规则是，变量和静态方法优先按引用类型来调用，
         * 其余方法优先按实例类型来调用！
         */

        A a1 = new A();//实列是A,引用也是A
        A a2 = new B();//实列是B,继承了A ,引用是A
        B b = new B();//实列是B,继承了A,引用是B
        C c = new C();//实列是C,继承了B
        D d = new D();//实列是D,继承了B
        a1.show(b);//a1 b是继承的A, 输出结果为A & A
        a1.show(c);//c是继承的b b又是继承的A, 输出结果为 A & A
        a1.show(d);/** 参照“其余方法优先按实例类型来调用”
                       a1的实列是A,重载方法有第一继承人,所以这里输出的是 A & D
                        */
        a2.show(b);/**实列是B 这里一般会认为调用的是B & B 其实是错误的,
                      因为这里this.show(object) > super.show(object) > this.show(super(object))
                      的顺序,最后调用的this.show(super(object)).所以这里是
                      this.show(A a). 因为B是继承于A  所以显示 B & A
                    */
        a2.show(c); //实列是B, c继承B,B又继承A,原理同上. 所以输出的是 B & A
        a2.show(d); /** 实列是B, A的引用,那么会先查找实列B中是否有 show(D d)的实现
                        当B类中的实现没有,则会从A类中找,刚好A类中有这个方法的实现,
                        所以这里输出的是: A & D
                    */
    }
}