多态的内涵：相同类型的对象，不同类型的引用，调用同样的方法，得到不同的结果。

更直观地解释是，发送相同的消息给同类型的对象，由对象自行决定响应何种行为。通过使用父类/超类对象的引用来实现动态方法调用。

如下例：

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

建议试着自己写出答案再和正确结果比较。

实现多态性的要点在于：向上转型，即子类对象可以通过父类对象引用。如上例，B是A的子类，通过A类的引用a2，引用B类的对象。

向上转型的引用方法有它独特的特性。

什么类型的引用只能调用什么类型中的方法。在a2中，只能调用A类中声明过的方法。相当于通过A类引用，只能给对象发送A类中规定的消息，也就是A类中定义的方法。由于A类引用的限制，B类对象收到的消息是受限的。

当B类对象收到消息后，也就是开始调用方法时，则按照B类对象的方法开始调用。在B类对象中，将会继承父类/超类的方法，同时能够对方法进行重载与重写。

通过语句调用方法的过程可以理解为，向一个实例对象传递消息，实例对象的引用是传话的中间人。引用的类型限制了所能够调用的方法，也就是限制了传话的内容。因此实例对象只能接受到受引用类型限制的消息。

实例对象接受到要调用什么方法的消息后，则在实例对象所属的类中，直接调用相应方法。

这里顺带复习重载与重写。（*JAVA中不能存在仅返回值类型不同的重载，因为这样会造成程序歧义，参考：https://blog.csdn.net/Xxacker/article/details/85107117。）

（*子类继承父类的方法，只是没有在子类代码中显示，因此父类的方法与子类的方法属于在同类中。）

便于记忆重写方法的特点，总结为：一大，两小，两相同。

一大：访问范围相同或更大；

两小：返回值类型相同或是子类，抛出异常相同或更少；

两相同：方法名相同，参数列表相同。

方法重写的本质是覆盖之前的方法。

便于记忆方法重载的特点，总结为：重载方法是完全不同的方法。

方法重载的本质是新的方法，仅仅是名称相同。