代码如下，为什么通过super(name, age);方式为子类初始化之后，调用子类get方法name为null，age为0；不是已经初始化了吗？糊涂了！

1. package com.heisejiuhuche.OOP;
   
2. 
   
3. 
   
4. public class OOPTest {
   
5.         public static void main(String[] args) {
   
6.                 Father f = new Father("lisi", 12);
   
7.                 System.out.println(f.getName());
   
8.                 Sub s = new Sub("zhangsan", 19);
   
9.                 System.out.println(s.getAge());
   
10.         }
    
11. }
    
12. 
    
13. class Father {
    
14.         private String name;
    
15.         private int age;
    
16. 
    
17.         Father(String name, int age) {
    
18.                 this.name = name;
    
19.                 this.age = age;
    
20.         }
    
21. 
    
22.         public String getName() {
    
23.                 return name;
    
24.         }
    
25. 
    
26.         public void setName(String name) {
    
27.                 this.name = name;
    
28.         }
    
29. 
    
30.         public int getAge() {
    
31.                 return age;
    
32.         }
    
33. 
    
34.         public void setAge(int age) {
    
35.                 this.age = age;
    
36.         }
    
37. 
    
38. }
    
39. 
    
40. class Sub extends Father {
    
41.         private String name;
    
42.         private int age;
    
43. 
    
44.         Sub(String name, int age) {
    
45.                 super(name, age);
    
46.         }
    
47. 
    
48.         public String getName() {
    
49.                 return name;
    
50.         }
    
51. 
    
52.         public void setName(String name) {
    
53.                 this.name = name;
    
54.         }
    
55. 
    
56.         public int getAge() {
    
57.                 return age;
    
58.         }
    
59. 
    
60.         public void setAge(int age) {
    
61.                 this.age = age;
    
62.         }
    
63. 
    
64.         public String toString() {
    
65.                 return this.name + ":" + this.age;
    
66.         }
    
67. }

复制代码

求大神回复。。。搞不懂。。。要崩溃了。。。

你父类 成员变量 私有了啊 那你子类的 GET方法 也用SUPER调用父类GET

或者 你父类 写个空参构造函数 子类直接this赋值实参

1. public class OOPTest {
   
2.         public static void main(String[] args) {
   
3.                 Father f = new Father("lisi", 12);
   
4.                 System.out.println(f.getName());
   
5.                 Sub s = new Sub("zhangsan", 19);
   
6.                 System.out.println(s.getAge());
   
7.         }
   
8. }
   
9. 
   
10. class Father {
    
11.         private String name;
    
12.         private int age;
    
13.         
    
14.         Father(){}
    
15.         Father(String name, int age) {
    
16.                 this.name = name;
    
17.                 this.age = age;
    
18.         }
    
19. 
    
20.         public String getName() {
    
21.                 return name;
    
22.         }
    
23. 
    
24.         public void setName(String name) {
    
25.                 this.name = name;
    
26.         }
    
27. 
    
28.         public int getAge() {
    
29.                 return age;
    
30.         }
    
31. 
    
32.         public void setAge(int age) {
    
33.                 this.age = age;
    
34.         }
    
35. 
    
36. }
    
37. 
    
38. class Sub extends Father {
    
39.         private String name;
    
40.         private int age;
    
41. 
    
42.         Sub(String name, int age) {
    
43.                  this.name = name;
    
44.              this.age = age;
    
45.         }
    
46. 
    
47.         public String getName() {
    
48.                 return name;
    
49.         }
    
50. 
    
51.         public void setName(String name) {
    
52.                 this.name = name;
    
53.         }
    
54. 
    
55.         public int getAge() {
    
56.                 return age;
    
57.         }
    
58. 
    
59.         public void setAge(int age) {
    
60.                 this.age = age;
    
61.         }
    
62. 
    
63.         public String toString() {
    
64.                 return this.name + ":" + this.age;
    
65.         }
    
66. }

复制代码

如果一定要父类SUPER 父类初始化 那就 子类别覆盖父类GET方法

子类的super(name,age) 相当于更改了父类对象里面的值,那子类的成员变量还是默认值
                Father f = new Father("lisi", 12);
                System.out.println(f.getName());
                Sub s = new Sub("zhangsan", 19);
                System.out.println(f.getName());//加上这就就看到了
                System.out.println(s.getAge());

我感觉你的继承写的没有意义的，对于父类有的功能，子类就没有必要再去定义了，可以直接利用父类的。
下面是我实现了你的要求的一种，附注释

1. 
   
2. <p> </p>

复制代码

1. package com.heisejiuhuche.OOP;
   
2. class Father {
   
3.         private String name;
   
4.         private int age;
   
5. 
   
6.         Father(String name, int age) {
   
7.                 this.name = name;
   
8.                 this.age = age;
   
9.         }
   
10. 
    
11.         public String getName() {
    
12.                 return name;
    
13.         }
    
14. 
    
15.         public void setName(String name) {
    
16.                 this.name = name;
    
17.         }
    
18. 
    
19.         public int getAge() {
    
20.                 return age;
    
21.         }
    
22. 
    
23.         public void setAge(int age) {
    
24.                 this.age = age;
    
25.         }
    
26. }
    
27. 
    
28. class Sub extends Father {
    
29.         private String name;
    
30.         private int age;
    
31. 
    
32.         Sub(String name, int age) {
    
33.                 super(name,age);//调用父类的构造方法，因为这两个属性的权限是private，对name,age做的初始化对子类不管用
    
34.                 //下面这样是对子类属性赋值
    
35.                 this.name = name;
    
36.                 this.age = age;
    
37.         }
    
38. 
    
39.         public String getName() {
    
40.                 return name;
    
41.         }
    
42. 
    
43.         public void setName(String name) {
    
44.                 this.name = name;
    
45.         }
    
46. 
    
47.         public int getAge() {
    
48.                 return age;
    
49.         }
    
50. 
    
51.         public void setAge(int age) {
    
52.                 this.age = age;
    
53.         }
    
54. 
    
55.         public String toString() {
    
56.                 return this.name + ":" + this.age;
    
57.         }
    
58. }
    
59. 
    
60. public class OOPTest {
    
61.         public static void main(String[] args) {
    
62.                 Father f = new Father("lisi", 12);
    
63.                 System.out.println(f.getName());
    
64.                 Sub s = new Sub("zhangsan", 19);
    
65.                 System.out.println(s.getAge());//打印出19
    
66.                 System.out.println(s.getName());//打印出张三
    
67.         }
    
68. }

复制代码

father类中private改为projected，超类中私有化了，不能被子类调用。

你初始化只是初始化了父类，子类还是默认初始值，而子类覆盖了父类的方法，则子类对象肯定调用的是子类覆盖后的方法，也就只能打印出默认初始值。8楼正解！

不错的贴，太喜欢了，大家都顶啊

谢谢楼主~~

学习了 楼主

静心明德 发表于 2015-4-20 18:37
我感觉你的继承写的没有意义的，对于父类有的功能，子类就没有必要再去定义了，可以直接利用父类的。
下面 ...

谢谢！还在摸索~ 东西太多脑子搅乱了~ 慢慢理一下！ 再次感谢！

静心明德 发表于 2015-4-20 18:37
我感觉你的继承写的没有意义的，对于父类有的功能，子类就没有必要再去定义了，可以直接利用父类的。
下面 ...

多谢！ 我再继续想想~

多谢大家解答！统一感谢了~:handshake

在sub类的只写Sub(String name, int age) {             super(name, age);         }就ok了，子类中已经继承了father中的age和name就不用再写方法了，刚刚没注意看。

来学习了

class sub  里面不用定义name和age 了

一般写构造方法，应该直接加上无参构造

顶起来   赞