1. public class Demo111 {
   
2.         public void method(Father f)
   
3.         {
   
4.                 System.out.println("Father");
   
5.         }
   
6.         public void method(Son s)
   
7.         {
   
8.                 System.out.println("Son");
   
9.         }
   
10.         public static void main(String[] args)
    
11.         {
    
12.                 Demo111 aa=new Demo111();
    
13.                 aa.method(new Father());
    
14.                 aa.method(new Son());//去掉public void method(Son s)方法，便会输出Father，为什么？
    
15.         }
    
16. }
    
17. class Father
    
18. {
    
19. }
    
20. class Son extends Father
    
21. {
    
22. }

复制代码

类Demo111中两个方法应该是重载了，这是编译时多态还是运行时多态？

1. /*
   
2. public class Demo111 {
   
3. 
   
4.     public void method()
   
5.         {
   
6.                 System.out.println("--------");
   
7.         }
   
8.     public void method(Father f)
   
9. 
   
10.     {
    
11. 
    
12.          System.out.println("Father run.....");
    
13. 
    
14.     }
    
15.     public void method(Son s)
    
16.     {
    
17.          System.out.println("Son");
    
18.     }
    
19.     public static void main(String[] args)
    
20. 
    
21.     {
    
22. 
    
23.                Demo111 aa=new Demo111();
    
24. 
    
25.                            aa.method();
    
26. 
    
27.                aa.method(new Father());
    
28. 
    
29.                aa.method(new Son());
    
30.                            //去掉public void method(Son s)方法，便会输出Father，为什么？
    
31.                                 //对于这个问题很简单，你调用了该方法，跟调用一般方法没什么两样
    
32.                                 //如：aa.mehtod();
    
33.     }
    
34. 
    
35. }
    
36. 
    
37. class Father
    
38. 
    
39. {
    
40.         
    
41. }
    
42. 
    
43. class Son extends Father
    
44. {
    
45. 
    
46. }
    
47. */
    
48. 
    
49. /*
    
50. 下面用写一个多态示例，仅供参考
    
51. */
    
52. public class Demo111 {
    
53. 
    
54.     public void method()
    
55.         {
    
56.                 System.out.println("--------");
    
57.         }
    
58.     public void method(Father f)
    
59.     {
    
60.                 //向上转型
    
61.                  f.show();//编译的时候走的父类方法，运行的时候走的是子类的方法
    
62.          System.out.println("Father run.....");
    
63. 
    
64.     }
    
65.     public void method1(Father fa)
    
66.     {
    
67.                         //s.show();
    
68.                         Son s = (Son)fa;//向下转型
    
69.                         s.show();
    
70. 
    
71.          System.out.println("Son");
    
72. 
    
73.     }
    
74.     public static void main(String[] args)
    
75. 
    
76.     {
    
77. 
    
78.                Demo111 aa=new Demo111();
    
79. 
    
80.                            aa.method();
    
81.                                 //这个方法当然走的是父类的方法
    
82.               // aa.method(new Father());
    
83.                           aa.method(new Son());//多态的体现
    
84.                                 //同上
    
85.               aa.method(new Son());
    
86.                         
    
87.     }
    
88. 
    
89. }
    
90. class Father
    
91. 
    
92. {
    
93.         public void show()
    
94.         {
    
95.                 System.out.println("^^^^^^^^^^^^^^^^");
    
96.         }
    
97. }
    
98. 
    
99. class Son extends Father
    
100. {
     
101.         public void show()
     
102.         {
     
103.                 System.out.println("******&&&&&&");
     
104.         }
     
105. }
     
106. 希望对你有帮助！
     

复制代码

aa.method(new Son());//去掉public void method(Son s)方法，便会输出Father，为什么？

//当去掉public void method(Son s)方法时， aa.method(new Son());就相当于 Father f = new Son()   aa.method(f); 将父类的引用指向子类的对象  所以依然会打印Father

类Demo111中两个方法应该不是重载吧，多态的实现依赖于继承来的，多态类其实就是父类的引用来引用子类的对象，但是要调用的方法必须在父类中已经有了，而子类通过继承或者重写父类的方法来实现多态。

public class Demo111 {
        public void method(Father f)
        {
                System.out.println("Father");
        }
        public void method(Son s)
        {
                System.out.println("Son");
        }
        public static void main(String[] args)
        {
                Demo111 aa=new Demo111();
                aa.method(new Father());
                aa.method(new Son());//去掉public void method(Son s)方法，便会输出Father，为什么？
                                                 //你的方法又不是定义在类里的，所以只是方法的重载，而Son也是一个Father，
                                                 这是java的多态决定的，所以你去掉了method(son s)的方法，会默认的提升类型，所以也是会有结果的。
        }
}
class Father
{
}
class Son extends Father
{
}

多态的三要素：
1. 要有继承
2. 要有重载
3. 要有父类引用指向子类对象
楼主的例子中没有父类引用指向子类对象