面向对象的三大特性：封装、继承、多态，其中最难理解的就是多态
以下是网上某大神给的一个例子：
1.继承关系
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 {}
2. 测试
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(a1.show(b)); //1
System.out.println(a1.show(c)); //2
System.out.println(a1.show(d)); //3
System.out.println(a2.show(b)); //4
System.out.println(a2.show(c)); //5
System.out.println(a2.show(d)); //6
System.out.println(b.show(b)); //7
System.out.println(b.show(c)); //8
System.out.println(b.show(d)); //9
}
}
3. 输出结果
A and A //1
A and A //2
A and D //3
B and A //4，这是要理解的重点
B and A //5，这是要理解的重点
A and D //6
B and B //7
B and B //8
A and D //9
4. 理解
class A{}
class B extends A{}
A a = new B();
/*
* 1. 上面的结果是产生了一个 A 类对象，虽然实际上传递过来的是 B 类对象(向上转型)
* 2. 此时 a 只能调用 A 类中的方法，而看不到B类中的【特有】方法
* 3. 如果 B 中复写了 A 类中的某些方法，那么此时 a 能调用到的都是被复写的方法
*
* 形象一点就是 B 偷偷换了 A 中的一些方法，此时的 a 并不知道！
*/
)
