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 {}

class E extends A {}

public class Polymorphism
{
    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();
        E e  = new E();
        /*
        先看调用对象是什么类的实例
        如a1是类A的实例，a2和b是类B的实例，c是类C的实例，d是类D的实例
        但是得根据实例的静态类型来决定使用哪一个类中的方法
        如a1.show(b)，a1.show(c)，a1.show(d)使用类A的方法
        尽管a2是类B是实例，但是静态类型是类A，所以a2.show(b)，a2.show(c)，a2.show(d)使用类A的方法
        b.show(b)，b.show(c)，b.show(d)使用类B中的方法
        然后再查找上一步决定好的类的方法列表中是否有某个方法的形参和调用方法时传入的实参类型匹配
        有的话就执行，没有的话就将实参自动向上转换成父类实例
        */
        System.out.println("1--" + a1.show(b));
        /*
        a1.show(b)先查找类A中是否存在形参为B类实例的方法，结果是类A中不存在show(B obj)
        那么再把类B实例b自动转换为其父类实例即类A实例，发现类A中存在show(A obj)，所以输出“A and A”
        */
        System.out.println("2--" + a1.show(c));
        /*
        a1.show(c)先查找类A中是否存在形参为类C实例的方法，结果是类A中不存在show(C obj)
        那么再把类C实例c自动转换为其父类实例即类B实例，结果是类A中不存在show(B obj)
        那么再把此时为类B实例的c自动转换为其父类实例即类A实例，发现类A中存在show(A obj)，所以输出“A and A”
        */
        System.out.println("3--" + a1.show(d));
        /*
        a1.show(d)先查找类A中是否存在形参为类D实例的方法，发现类A中存在show(D obj)，所以输出“A and D”
        */
        System.out.println("4--" + a2.show(b));
        /*
        a2.show(b)先查找类A中是否存在形参是类B实例的方法，结果是类A中不存在show(B obj)
        那么再把类B实例b自动转换为其父类实例即类A实例，发现类A中存在show(A obj)
        可是由于a2是类B实例，并且类B中重写了show(A obj)，所以执行类B中的show(A obj)，输出“B and A”
        */
        System.out.println("5--" + a2.show(c));
        /*
        a2.show(c)先查找类A中是否存在形参为类C实例的方法，结果是类A中不存在show(C obj)
        那么再把类C实例c自动转换为其父类实例即类B实例，结果是类A中不存在show(B obj)
        那么再把此时为类B实例的c自动转换为其父类实例即类A实例，发现类A中存在show(A obj)
        可是由于a2是类B实例，并且类B中重写了show(A obj)，所以执行类B中的show(A obj)，输出“B and A”
        */
        System.out.println("6--" + a2.show(d));
        /*
        a2.show(d)先查找类A中是否存在形参为类D实例的方法，发现类A中存在show(D obj)，所以输出“A and D”
        */
        System.out.println("7--" + b.show(b));
        /*
        b.show(b)先查找类B中是否存在形参为类B实例的方法，发现类B中存在show(B obj)，所以输出“B and B”
        */
        System.out.println("8--" + b.show(c));
        /*
        b.show(c)先查找类B中是否存在形参为类C实例的方法，结果是类B中不存在show(C obj)
        那么再把类C实例c自动转换为其父类实例即类B实例，发现类B中存在show(B obj)，所以输出“B and B”
        */
        System.out.println("9--" + b.show(d));
        /*
        b.show(d)先查找类B中是否存在形参为类D实例的方法，发现类B中存在继承自类A的show(D obj)，所以输出“A and D”
        */
        System.out.println("10--" + a1.show(e));
        System.out.println("11--" + a2.show(e));
        System.out.println("12--" + b.show(e));
    }
}