今天学习了继承，自己写了个小程序，调试的时候发现一个有趣的现象，求大神解答

1. class  Person //定义了一个Person类
   
2. {
   
3.         String name;
   
4.         int age;
   
5. 
   
6.         public void show()
   
7.         {
   
8.                 System.out.println("姓名："+name+","+"年龄："+age);
   
9.         }
   
10. }
    
11. class Student extends Person//定义一个Student类继承Person类
    
12. {
    
13. }
    
14. 
    
15. class Show
    
16. {
    
17.         public static void main(String[] args)
    
18.         {
    
19.                 Person p = new Person();
    
20.                 Student s = new Student();
    
21.                 p.show();
    
22.                 s.show();
    
23.         }
    
24. }

复制代码

如上代码运行后两个输出结果一样，随后我在Student类中添加了一个show方法
class Student extends Person
{
        public void show()
        {
                System.out.println("姓名："+name+","+"年龄："+age+",我学习很好");
        }
}

加上这段后我以为会编译失败，因为Student类继承Person类后相当于已经有一个show方法了，不可以再定义一个相同的方法，可是便已通过了，运行之后 s.show();输出的是“姓名：null,年龄：0,我学习很好”，说明此时 s 对象调用的是本类中的show方法。

那么问：为什么可以编译成功呢？ 在Student类中定义了show方法后，他从Person类中继承而来的show方法又哪里去了？

show方法被重新了

呵呵，继承的特性嘛，子类覆盖父类中的同名方法和子类可以直接使用父类中的非私有方法

恩，一般疑惑的后面都会讲到

方法覆盖。。。一直往后面看  就会觉得前面碰到的问题慢慢懂了  

在多态中成员函数的特点：

     在编译时期：参阅引用型变量所属的类中是否有调用的方法。如果有，编译通过，如果没有编译失败。

     在运行时期：参阅对象所属的类中是否有调用的方法。

     简单总结就是：成员函数在多态调用时，编译看左边，运行看右边。

在多态中，成员变量的特点：

     无论编译和运行，都参考左边(引用型变量所属的类)。

在多态中，静态成员函数的特点：

     无论编译和运行，都参考做左边。

代码示例：

1. class Fu
   
2. {
   
3.         static int num = 5;
   
4.         void method1()
   
5.         {
   
6.                 System.out.println("fu method_1");
   
7.         }
   
8.         void method2()
   
9.         {
   
10.                 System.out.println("fu method_2");
    
11.         }
    
12.         static void method4()
    
13.         {
    
14.                 System.out.println("fu method_4");
    
15.         }
    
16. }
    
17. class Zi extends Fu
    
18. {
    
19.         static int num = 8;
    
20.         void method1()
    
21.         {
    
22.                 System.out.println("zi method_1");
    
23.         }
    
24.         void method3()
    
25.         {
    
26.                 System.out.println("zi method_3");
    
27.         }
    
28. 
    
29.         static void method4()
    
30.         {
    
31.                 System.out.println("zi method_4");
    
32.         }
    
33. }
    
34. public class  DuoTaiDemo
    
35. {
    
36.         public static void main(String[] args)
    
37.         {
    
38.                 Fu f = new Zi();
    
39.                 System.out.println(f.num);
    
40.                 f.method4();
    
41.                 Zi z = new Zi();
    
42.                 z.method4();
    
43.                 //输出为5、fu method_4、zi method_4
    
44.         }
    
45. }       
    

复制代码

子类中的同名方法会“覆盖”父类中的方法

Student时Person的子类，Student类的show()方法覆盖了Person类的show()方法。自然要调用Student类的show()方法了

这不就是覆盖吗...

额额。。懂了，刚刚继承那块没全看完 - -ll  现在看完了就知道了。 函数的重写

从Person类中继承而来的show方法被自己的show方法覆盖了