多态中，方法的调用优先级

以前对java中多态的理解只停留在重写Overriding和重载Overloading上，但是对于经过重写，重载的方法的调用顺序，尤其涉及父类对象以子类实例化，又或者经过向上向下转型后，经过重写的方法调用的优先级往往会使人混乱。。例如：

        class A {
            public String show(final A obj) {
                return ("A and A");
            }
        }
        class B extends A {
            public String show(final B obj) {
                return ("B and B");
            }

            @Override
            public String show(final A obj) {
                return ("B and A");
            }
        }
        final A a2 = new B();
        final B b = new B();
        System.out.println(a2.show(b));


输出的结果为：B and A

对此，在网上看到一条准则： 当超类对象引用变量引用子类对象时，被引用对象的类型而不是引用变量的类型决定了调用谁的成员方法，但是这个被调用的方法必须是在超类中定义过的，也就是说被子类覆盖的方法。

实际上这里涉及方法调用的优先问题 ，优先级由高到低依次为：this.show(O)、super.show(O)、this.show((super)O)、super.show((super)O)。以此准则，推算下结果的思路。

a2是一个引用变量，类型为A，它引用的是B的一个对象。记得在core java中有过这么一个定论：一个对象有哪些方法，是由声明的类型决定，而不是实例化的类型决定，这个没有疑问，用eclipse看a2的方法确实只看到show(A obj)，并没有show(B obj)。再结合上面说的顺序，this为a2，于是它到类A里面找show(B obj)方法，没有找到，于是到A的super(超类)找，而A没有超类，因此转到第三优先级this.show((super)O)，(super)O即(super)B即A，因此它到类A里面找show(A obj)的方法，类A有这个方法，但是，按照红字的准则，调用谁的成员方法是由被引用对象的类型来决定，由于a2引用的是类B的一个对象，B覆盖了A的show(A obj)方法，因此最终锁定到类B的show(A obj)，输出为"B and A”。

当然，另一种思路可以直接按照准则去找，a2是一个引用变量，类型为A，它引用的是B的一个对象，因此这句话的意思是由B来决定调用的是哪个方法。因此应该调用B的show(B obj)从而输出"B and B”才对。但是请注意红字的后半部分，这个被调用的方法必须是在超类中定义过的，也就是说被子类覆盖的方法。B里面的show(B obj)在超类A中有定义吗？没有！那就更谈不上被覆盖了。它在类A中找到了show(A obj)，如果子类B没有覆盖show(A obj)方法，那么它就调用A的show(A obj)（由于B继承A，虽然没有覆盖这个方法，但从超类A那里继承了这个方法，从某种意义上说，还是由B确定调用的方法，只是方法是在A中实现而已）。现在子类B覆盖了show(A obj)，因此它最终锁定到B的show(A obj)，所以输出"B and A”。

以下参考题目来源于网络：

（一）相关类

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

（二）问题：以下输出结果是什么？

    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));   ①  
            System.out.println(a1.show(c));   ②  
            System.out.println(a1.show(d));   ③  
            System.out.println(a2.show(b));   ④  
            System.out.println(a2.show(c));   ⑤  
            System.out.println(a2.show(d));   ⑥  
            System.out.println(b.show(b));    ⑦  
            System.out.println(b.show(c));    ⑧  
            System.out.println(b.show(d));    ⑨     

（三）答案

①   A and A

②   A and A

③   A and D

④   B and A

⑤   B and A

⑥   A and D

⑦   B and B

⑧   B and B

⑨   A and D