Java面对对象14：方法调用的优先级问题

一、实现Java多态性的时候，关于方法调用的优先级

我们这样假设下，super（父类）、this（当前类对象）、show（方法）、object（对象），方法调用优先顺序：

• ①this.show（object）>②super.show（object）> ③this.show（（super）object）>④super.show（（super）object）
• 文字描述：
  ①当前类方法（当前类对象）> ② 父类方法（当前类对象）> ③当前类方法（父类对象）> ④父类方法（父类对象）

案例

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 Demo {
    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));//A - A  
        System.out.println("2--" + a1.show(c));//A - A
        System.out.println("3--" + a1.show(d));//A - D
        System.out.println("4--" + a2.show(b));//B - A
        System.out.println("5--" + a2.show(c));//B - A
        System.out.println("6--" + a2.show(d));//A - D
        System.out.println("7--" + b.show(b));// B - B
        System.out.println("8--" + b.show(c));// B - B
        System.out.println("9--" + b.show(d));// A - D
    }
}      

个人理解（如有误请指教）

1. a1.show( b ) —— a1为A类的引用变量，指向A类的对象；a1为A类，则a1.show( b )应该调用A类中的方法，然而A类中并没有show(B obj)方法，按照继承链中调用方法的优先级来确定，它会在A类中找到show(A obj) ，所以 a1.show( b ) 结果为 A and A

2. a1.show( c ) —— a1为A类的引用变量，指向A类的对象；a1为A类，则a1.show( c )应该调用A类中的方法，然而A类中并没有show(C obj)方法，按照继承链中调用方法的优先级来确定，它会在A类中找到show(A obj) ，所以 a1.show( c ) 结果为 A and A

3. a1.show( d ) —— a1为A类的引用变量，指向A类的对象；a1为A类，则a1.show( d )应该调用A类中的方法，在A类中有show(D obj)方法，所以 a1.show( d ) 结果为 A and D

4. a2.show( b ) —— a2为A类的引用变量，指向B类的对象，此处进行了向上转型，子类单独定义的方法会丢失（B.show(B obj)不能被调用），A.show(A obj)被B.show(A obj)重写；a2为A类，则a2.show( b )应该调用A类中的方法，然而A类中并没有show(B obj)方法，按照继承链中调用方法的优先级来确定，它会在A类中找到被重写的show(A obj) ，所以 a1.show( b ) 结果为 B and A

5. a2.show( c ) —— a2为A类的引用变量，指向B类的对象，此处进行了向上转型，子类单独定义的方法会丢失（B.show(B obj)不能被调用），A.show(A obj)被B.show(A obj)重写；a2为A类，则a2.show( c )应该调用A类中的方法，然而A类中并没有show(C obj)方法，按照继承链中调用方法的优先级来确定，它会在A类中找到被重写的show(A obj) ，所以 a1.show( c ) 结果为 B and A

6. a2.show( d ) —— a2为A类的引用变量，指向B类的对象，此处进行了向上转型，子类单独定义的方法会丢失（B.show(B obj)不能被调用），A.show(A obj)被B.show(A obj)重写；a2为A类，则a2.show( d )应该调用A类中的方法，在A类中有show(D obj)方法，所以 a1.show( d ) 结果为 A and D

7. b.show( b ) —— b为B类的引用变量，指向B类的对象；b为B类，则b.show( b )应该调用B类中的方法，在B类中有show(B obj)方法，所以 b.show( b ) 结果为 B and B

8. b.show( c ) —— b为B类的引用变量，指向B类的对象；b为B类，则b.show( c )应该调用B类中的方法，然而B类中并没有show(C obj)方法，按照继承链中调用方法的优先级来确定，它会在B类中找到show(B obj) ，所以 b.show( c ) 结果为 B and B

9. b.show( d ) —— b为B类的引用变量，指向B类的对象；b为B类，则b.show( d )应该调用B类中的方法，因为B类是A类的子类，所以B类继承了A类的show(D obj),则在B类中有show(D obj)方法，所以 b.show( d ) 结果为 A and D