java继承覆盖总结

骑猪看日落 2022-08-05 02:57 239阅读 0赞

java的继承与覆盖基本是java笔试中常出的题，也比较绕，我这里对java的继承覆盖做一个总结  
1.构造函数：  
        当子类继承一个父类时，构造子类时需要调用父类的构造函数，存在三种情况  
        （1），父类无构造函数或者一个无参数构造函数，子类若无构造函数或者有无参数构造函数，子类构造函数中不需要显式调用父类的构造函数，系统会自动在调用子类构造函数前调用父类的构造函数  
         （2），父类只有有参数构造函数，子类在构造方法中必须要显示调用父类的构造函数，否则编译出错  
         （3），父类既有无参数构造函数，也有有参构造函数，子类可以不在构造方法中调用父类的构造函数，这时使用的是父类的无参数构造函数  
           //以上三个结论已经过代码验证  
2.方法覆盖：  
          （1）子类覆盖父类的方法，必须有同样的参数返回类型，否则编译不能通过  
          （2）子类覆盖父类的方法，在jdk1.5后，参数返回类可以是父类方法返回类的子类  
         （3）子类覆盖父类方法，可以修改方法作用域修饰符，但只能把方法的作用域放大，而不能把public修改为private  
          (4)子类方法能够访问父类的protected作用域成员，不能够访问默认的作用域成员  
         （5）子类的静态方法不能隐藏同名的父类实例方法  
         （6）java与C++一样，继承的方法具有多态性  
         //以上6个结论已经过代码验证  
3.成员覆盖：  
         （1）当子类覆盖父类的成员变量时，父类方法使用的是父类的成员变量，子类方法使用的是子类的成员变量  
          这个听起来很容易理解的一回事，但是实际使用过程中很多人容易搞混：尤其是在多态的时候，调用一个被继承的方法，该方法访问是一个被覆盖的成员m，那么方法中到底是访问了父类的成员还是子类的成员m？结论是，若实际调用的是父类的方法，就使用了父类的该成员m,若实际调用的是子类的方法，就使用子类的成员m，记住一句，每个类使用成员都相当于在前面加了 一个this指针。  
         //以上1个结论已经过代码验证

我在论坛上看到下面例子，理解上面，你就能够很好得出答案了：

**\[c-sharp\]**  [view plain][] [copy][view plain]

1.  **class** SuperClass \{  
2.      **private** **int** number;  
3.    
4.    
5.      **public** SuperClass() \{  
6.          **this**.number = 0;  
7.      \}  
8.    
9.    
10.     **public** SuperClass(**int** number) \{  
11.         **this**.number = number;  
12.     \}  
13.   
14.   
15.     **public** **int** getNumber() \{  
16.         number++;  
17.         **return** number;  
18.     \}  
19. \}  
20.   
21. **class** SubClass1 extends SuperClass \{  
22.     **public** SubClass1(**int** number) \{  
23.         super(number);  
24.     \}  
25.   
26. \}  
27.   
28. **class** SubClass2 extends SuperClass \{  
29.     **private** **int** number;  
30.   
31.   
32.     **public** SubClass2(**int** number) \{  
33.         super(number);  
34.     \}  
35.   
36. \}  
37.   
38. **public** **class** SubClass extends SuperClass \{  
39.   
40.     **private** **int** number;  
41.   
42.   
43.     **public** SubClass(**int** number) \{  
44.         super(number);  
45.     \}  
46.   
47.   
48.     **public** **int** getNumber() \{  
49.         number++;  
50.         **return** number;  
51.     \}  
52.   
53.   
54.     **public** **static** **void** main(String\[\] args) \{  
55.         SuperClass s = **new** SubClass(20);  
56.         SuperClass s1 = **new** SubClass1(20);  
57.         SuperClass s2 = **new** SubClass2(20);  
58.         System.**out**.println(s.getNumber());  
59.         System.**out**.println(s1.getNumber());  
60.         System.**out**.println(s2.getNumber());  
61.         //结论一：多态时，当子类覆盖了父类的方法，使用子类覆盖的方法  
62.         //结论二：当子类覆盖父类的成员变量时，父类方法使用的是父类的成员变量，子类方法使用的是子类的成员变量  
63.     \}  
64.   
65. \}

执行输出：

1  
21  
21

[view plain]: http://blog.csdn.net/stonecao/article/details/6317353#