java向上转型时的逻辑关系

class A {
    public String show(D obj) {
        return ("A and D");
    }
 
    public String show(A obj) {
        return ("A and A.");
    }
 
}
 
class B extends A{
    public String show(B obj){
        return ("B and B");
    }
 
    public String show(A obj){
        return ("B and A");
    }
}
 
class C extends B{
 
}
 
class D extends B{
 
}
 
public class Main {
    public static void main(String[] args) {
        A a1 = new A();
        A a3 = 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));//可能疑惑为什么不是b and b，记住向上转型时，只有父类有的方法才能被调用，调用的方法如果被重写了就会调用重写的。所有show（B obj）根本不能调用，就会将B类编程A类（继承），也就输出了（B and A）
        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
 
//能看懂这个结果么？先自分析一下。

前三个，强行分析，还能看得懂。但是第四个，大概你就傻了吧。为什么不是b and b呢？

首先，a2是类型为A的引用类型，它指向类型为B的对象。A确定可调用的方法：show(D obj)和show(A obj)。
a2.show(b) ==> this.show(b)，这里this指的是B。
然后.在B类中找show（B obj），找到了，可惜没用，因为show（B obj）方法不在可调用范围内(父类没有， 必须时父类有的)，失败，进入下一级别：super.show(…)，super指的是A。
在A 中寻找show（B obj)，失败，因为没用定义这个方法。进入第三级别：this.show((super)…)，this指的是B。
在B中找show（（A）O）,找到了：show(A obj)，选择调用该方法。

输出：B and A

如果还找不到就会在super.show((super)…)中查找，再没有就报错

下面使用图解释：

如果你能看懂这个过程，并且能分析出其他的情况，那你就真的掌握了。

1.多态，简而言之就是同一个行为具有多个不同表现形式或形态的能力。

2.多态的分类：运行时多态和编译时多态。
运行时多态的前提：继承（实现），重写，向上转型
向上转型与向下转型。
继
3.承链中对象方法的调用的优先级：this.show(O)、super.show(O)、this.show((super)O)、super.show((super)O)。