1. class day06{
   
2.         public static void main(String[] args)
   
3.         {
   
4.                 A a1 = new A();  
   
5.                 A a2 = new B();  
   
6.                 B b = new B();  
   
7.                 C c = new C();   
   
8.                 D d = new D();
   
9.                
   
10.                 System.out.println(a1.show(b));  //1
    
11.                 //a1为父类中的对象，所以在调用的时候，指调用父类中的内容，b为B类中的对象，B继承了A那么，在a1调用show(),实际上就是调用他们共性的内容，因为父类是由事物的共性内容不断抽取出来的，其实父类也是可以接受子类对象
    
12.                 System.out.println(a1.show(c)); //2
    
13.                 //同上，a1为父类对象，c为C类对象，而C继承了B，B继承了A，所以就成了一个继承体系，那么C也就有A中的方法，在a1调用show(),实际上就是调用他们共性的内容，因为父类是由事物的共性内容不断抽取出来的
    
14.                 System.out.println(a1.show(d));    //3
    
15.                 //同上，a1为父类对象，d为D类对象，而D继承了B，B继承了A，所以就成了一个继承体系，那么D也就有A中的方法，D obj也就是指把D的对象传进来(有疑惑）
    
16.                 System.out.println(a2.show(b));   //4
    
17.                 //a2也就是父类引用子类的对象，那么他在调用的时候实际上就是在调用子类重写父类中的那一部分，
    
18.                 System.out.println(a2.show(c));   //5
    
19.                 //a2也就是父类引用子类的对象，那么他在调用的时候实际上就是在调用子类重写父类中的那一部分，C继承了B也就是C.B之间有一个共性的方法
    
20.                 System.out.println(a2.show(d));    //6
    
21.                 //a2也就是父类引用子类的对象，那么a2只能使用父类中的内容，不可以使用子类中的功能，d继承了B也就是继承了A，所以会调用A中的show(D obj)(有疑惑）
    
22.                 System.out.println(b.show(b));   //7  
    
23.                 //b是B中的对象，所以调用的是B中的方法
    
24.                 System.out.println(b.show(c));   //8
    
25.                 //b是B中的对象，C继承B那么就是他就会嗲用调用show(B obj)
    
26.                 System.out.println(b.show(d));  //9
    
27.                 //b是B中的对象，B继承了A，D继承了B，那么也就是D继承了A，所以最后就是show(D obj)        System.out.println(a2.show(a1));
    
28.                 System.out.println(b.show(a2));
    
29.                 System.out.println(b.show(a1));
    
30.                 System.out.println(b.show(a1));
    
31.                
    
32.         }
    
33.        //Java还支持多层继承。A-->B--->C  原来可以形成继承体系.其实D.C。B.A就是多层继承，本类对象只使用本类方法，父类对象引用子类对象，那么还是使用的是父类方法
    
34.         //其实第8和第3个就是多态的体现
    
35. 
    
36.         }
    
37. class A{  
    
38.          public String show(D obj){  
    
39.                 return ("A and D");  
    
40.          }   
    
41.          public String show(A obj){  
    
42.                 return ("A and A");  
    
43.          }   
    
44. }   
    
45. class B extends A{  
    
46.          public String show(B obj){  
    
47.                 return ("B and B");  
    
48.          }  
    
49.          public String show(A obj){  
    
50.                 return ("B and A");  
    
51.          }   
    
52. }  
    
53. class C extends B{}   
    
54. class D extends B{}
    
55. 
    
56. /*A and A  1
    
57. A and A  2         
    
58. A and D  3
    
59. B and A  4
    
60. B and A  5
    
61. A and D  6
    
62. B and B  7
    
63. B and B  8
    
64. A and D  9
    
65. B and A
    
66. B and A
    
67. B and A
    
68. */
    
69. 
    
70. /*
    

复制代码

这是一个困扰我好久的问题，由于是自学，没有人解答，只能是靠平时查询相关内容以及百度一些类似的例子作为参考，结合下自己的理解，写出的一些思路，题目中的 1,2,3,4.。。。。表示的就是对应的输出语句后面的注释标号~如果有什么疑问可以提出来共同学习的~~

多态中，在调用方法时，编译时参照父类，运行时参照子类（如果方法有覆写），这里父类中有show(D obj)方法，子类继承了父类中的show(D obj)方法，所以运行结果是子类中继承的show(D obj)方法。如果子类中覆写了show(D obj)方法，运行得到的应该是子类覆写后的结果。

同求，大神解答一下