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)。