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();
  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));
}
}

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{

}
这段代码运行的步骤是怎么样的？为什么涉及到方法调用的优先级

乱码了

1. public static void main(String[] args) {
   
2.                    A a1 = new A();
   
3.                    A a2 = new B();
   
4.                    B b = new B();
   
5.                    C c = new C();
   
6.                    D d = new D();
   
7.                    System.out.println("1"+a1.show(b));//多态   子类当父类用，
   
8.                    System.out.println("2"+a1.show(c));//多态   子类当父类用，
   
9.                    System.out.println("3"+a1.show(d));//有相同参数的方法直接使用；
   
10.                    System.out.println("4"+a2.show(b));//a2没有参数为B的方法show所以就用show（A）重载，而B有show（A）所以覆写了。
    
11.                    System.out.println("5"+a2.show(c));//和上一致
    
12.                    System.out.println("6"+a2.show(d));
    
13.                    System.out.println("7"+b.show(b));
    
14.                    System.out.println("8"+b.show(c));
    
15.                    System.out.println("9"+b.show(d));//B没有show（D）的方法，调用父类的show（D）方法
    
16.                  }
    
17.          }
    
18.                  
    
19.                 class A{
    
20.                  public String show(D obj){
    
21.                    return "A and D";
    
22.                  }
    
23.                  public String show(A obj){
    
24.                    return "A and A";
    
25.                  }
    
26.                  }
    
27.                  
    
28.                 class B extends A{
    
29.                  public String show(B obj){
    
30.                    return "B and B";
    
31.                  }
    
32.                  public String show(A obj){
    
33.                    return "B and A";
    
34.                  }
    
35.                
    
36.                  
    
37.                  }
    
38.                  
    
39.                 class C extends B{
    
40. 
    
41.                  }
    
42.                  
    
43.                 class D extends B{
    
44. 
    
45.                  }

复制代码

所以顺序应该是这样的，子类没当父类使用的话，先看子类函数是否有有参数类型一致的函数，有直接使用，没有的话就找父类中是否有函数参数类型一致的函数，
                   有使用，没有的话再往上找，都没找到情况下找父类与本类的重载方法参数与要找的参数继承性最强的一个，而相同参数函数的子类优先级较高，
                   子类当父类使用时，1、找父类里的函数，一致的情况下看子类有没有覆写本函数，有使用子类覆写的，没有使用父类的；
                           2、父类里没找到参数列表一致的函数，重载函数（即便子类中有何要找函数一致的函数也调用不了），重载后再看子类是否覆写了父类的重载函数，
                           有则调用子类的，没有调用父类的；