一个子类要调用父类的方法时,默认是使用this还是super?

索隆 2012-03-26 05:24:15
一个子类要调用父类的方法时,默认是使用this还是super?

因为子类已经继承了父类的所有方法,子类也未去重写这些方法,这些方法实际上已经属于子类,那么使用时,如果我们不写this或super，类也不报错；使用this或super也正确。那我们什么也不写的那种情况到底默认是哪个？
...全文
42455 12 打赏 收藏 转发到动态 举报
写回复
用AI写文章
12 条回复
切换为时间正序
请发表友善的回复…
发表回复
copysimles 2013-07-23
  • 打赏
  • 举报
 回复
我是这样想的.你看下对不对!!!! 1.如果子类继承了父类,比如你的例子. 你的子类身上的name 和age 是父类的. get 和set方法也是父类的. 那么你无论是调用this.setName(xxx)还是super.setName(xxx) 调用的都是父类的.所以此时,子类会改变父类的值的. 2.另外,关于哪个好.我觉得两个可能思考. 让编译器跑得更爽.让看你代码的人更爽. 如果你想明白了这两点,那么你就知道,应该用this 就用this,应用super的时候就super . 所以,你在子类setName和setAge的时候,是应该使用super的. 对编译器来说,你使用了super,编译器就能直接去父类找setage方法,它不会在子类转了一大圈,发现子类没有setage然后才去找他老爸. 这样编译器会爽一些. 另外,此处用super会更好.别人看了,容易看啊. 因为setage本来就是父类的. 你用this的话,别人看你代码的时候,他就会在你的子类找半天,操.发现根本没有找到.然后他才想明白,哦,原来是父类的.... 3.这样说,你会不会有点理解呢? 4.有空多交流. @zhhaojie
__奇奇老爹 2013-03-28
  • 打赏
  • 举报
 回复
引用 3 楼 ce2010 的回复:
super相当于一个弗雷对象的引用，this相当与当前对象的一个引用。 super的使用： 子类的构造方法中，调用父类的构造方法是，可以用super([父类构造方法中相应的参数列表])，在调用时，必须在子类构造方法的第一行。 子类方法中，子类复写了父类的方法，当调用该方法时，不想使用父类的方法，那么就用super.method(),调用父类的方法。 t……
子类方法中，子类复写了父类的方法，当调用该方法时，不想使用子类的方法，那么就用super.method(),调用父类的方法。
snowboy8886 2012-03-27
  • 打赏
  • 举报
 回复
[Quote=引用 2 楼 ncist_jianeng 的回复:]

既然没有重写，调用supper和this都一样。重写了后supper调用父类的方法，this调用子类重写的方法。属性也是一样。很好理解的。
[/Quote]
++
安特矮油 2012-03-27
  • 打赏
  • 举报
 回复
在没有覆写父类方法和属性的情况下this跟super都是一样的。因为他在当前对象中都找不到对应的方法和属性，所以会去该对象的父类中查找。说穿了其实调用的都是父类中的属性和方法。根据方法的调用顺序的话，不写this或super的情况下，默认为this
老9 2012-03-26
  • 打赏
  • 举报
 回复 


public void setInfoToSonWithoutNeither(String name,int age){

 name=name;

 age=age;

}

应为name和age就是这个传进来的参数name和age，相当于这个方法中的局部变量，而不是son的成员变量,它们自己赋值给自己，所以Son成员变量name和age的值不变。。
索隆 2012-03-26
  • 打赏
  • 举报
 回复
这是我的实验：
看看下面的代码

[html] view plaincopyprint?
01.package com.java.three;
02.
03.public class Father {
04.
05. public void printTheInfomationOfThisMan(){
06. System.out.println(this.toString());
07. }
08.
09. public String name="父亲name";
10. public int age=55;
11. public String sex="男";
12.
13. public String getName() {
14. return name;
15. }
16. public void setName(String name) {
17. this.name = name;
18. }
19. public int getAge() {
20. return age;
21. }
22. public void setAge(int age) {
23. this.age = age;
24. }
25. public String getSex() {
26. return sex;
27. }
28. public void setSex(String sex) {
29. this.sex = sex;
30. }
31. @Override
32. public String toString() {
33. return "Father [name=" + name + ", age=" + age + ", sex=" + sex + "]";
34. }
35.
36.}
package com.java.three;

public class Father {

public void printTheInfomationOfThisMan(){
System.out.println(this.toString());
}

public String name="父亲name";
public int age=55;
public String sex="男";

public String getName() {
return name;
}
public void setName(String name) {
this.name = name;
}
public int getAge() {
return age;
}
public void setAge(int age) {
this.age = age;
}
public String getSex() {
return sex;
}
public void setSex(String sex) {
this.sex = sex;
}
@Override
public String toString() {
return "Father [name=" + name + ", age=" + age + ", sex=" + sex + "]";
}

}




[html] view plaincopyprint?
01.package com.java.three;
02.
03.public class Son extends Father{
04.
05.
06. public String ambution;
07.
08. public String getAmbution() {
09. return ambution;
10. }
11. //使用this给变量赋值
12. public void setAmbution(String ambution) {
13. this.ambution = ambution;
14. }
15.
16.
17.
18. //使用super给变量赋值
19. public void superSetInfoToSon(String name,int age){
20. super.setName(name);
21. super.setAge(age);
22. }
23.
24. //使用this给变量赋值
25. public void thisSetInfoToSon(String name,int age){
26. this.setName(name);
27. this.setAge(age);
28. }
29.
30. //这是我们要研究的重点，看看这种方式到底改变的是this的变量还是super的变量
31. //不适用this,也不使用super，给变量赋值
32. public void setInfoToSonWithoutNeither(String name,int age){
33. namename=name;
34. ageage=age;
35. }
36.
37.
38.
39.
40. public void printTheInfomationOfSon(){
41. System.out.println(this.toStringOfSon());
42. }
43. public void printTheInfomationOfFather(){
44. System.out.println(this.toStringOfFather());
45. }
46.
47. //注意下面关键字this的使用
48. public String toStringOfSon() {
49. return "Son [ambution=" + this.ambution + ", name=" + this.name + ", age=" + this.age
50. + ", sex=" + this.sex + "]";
51. }
52. //注意下面关键字super的使用
53. public String toStringOfFather() {
54. return "Son [ambution=" + ambution + ", name=" + super.name + ", age=" + super.age
55. + ", sex=" + super.sex + "]";
56. }
57.
58.}
package com.java.three;

public class Son extends Father{


public String ambution;

public String getAmbution() {
return ambution;
}
//使用this给变量赋值
public void setAmbution(String ambution) {
this.ambution = ambution;
}



//使用super给变量赋值
public void superSetInfoToSon(String name,int age){
super.setName(name);
super.setAge(age);
}

//使用this给变量赋值
public void thisSetInfoToSon(String name,int age){
this.setName(name);
this.setAge(age);
}

//这是我们要研究的重点，看看这种方式到底改变的是this的变量还是super的变量
//不适用this,也不使用super，给变量赋值
public void setInfoToSonWithoutNeither(String name,int age){
name=name;
age=age;
}




public void printTheInfomationOfSon(){
System.out.println(this.toStringOfSon());
}
public void printTheInfomationOfFather(){
System.out.println(this.toStringOfFather());
}

//注意下面关键字this的使用
public String toStringOfSon() {
return "Son [ambution=" + this.ambution + ", name=" + this.name + ", age=" + this.age
+ ", sex=" + this.sex + "]";
}
//注意下面关键字super的使用
public String toStringOfFather() {
return "Son [ambution=" + ambution + ", name=" + super.name + ", age=" + super.age
+ ", sex=" + super.sex + "]";
}

}




[html] view plaincopyprint?
01.package com.java.three;
02.
03.public class Testmain {
04.
05. public static void main(String ssd[]){
06.// Father ff=new Father();
07.// ff.setName("父亲");
08.// ff.setAge(55);
09.// ff.printTheInfomationOfThisMan();
10.
11. Son ss=new Son();
12.
13. System.out.println("----------------this--start-----------------------");
14. ss.thisSetInfoToSon("给儿子命名this", 26);////使用this给变量赋值
15. ss.setAmbution("亿万富翁");//子类自己的方法
16. //ss.printTheInfomationOfThisMan();//继承父类的方法
17.
18. ss.printTheInfomationOfSon();//子类自己的方法，打印自己的变量this
19. ss.printTheInfomationOfFather();//子类自己的方法，打印父类的变量super
20. System.out.println("----------------this--end-----------------------");
21.
22.
23. System.out.println("----------------super--start-----------------------");
24. ss.superSetInfoToSon("给儿子命名super", 25);//使用super给变量赋值
25. ss.printTheInfomationOfSon();//子类自己的方法，打印自己的变量this
26. ss.printTheInfomationOfFather();//子类自己的方法，打印父类的变量super
27.
28. System.out.println("----------------super--end-----------------------");
29. System.out.println("");
30. System.out.println("----------------注意！！！-----------------------");
31. System.out.println("----------------neither--start-----------------------");
32.
33. //注意下面我们设置的信息是("给儿子命名neither", 18)
34. ss.setInfoToSonWithoutNeither("给儿子命名neither", 18);//不适用this,也不使用super，给变量赋值
35. ss.printTheInfomationOfSon();//子类自己的方法，打印自己的变量this
36. ss.printTheInfomationOfFather();//子类自己的方法，打印父类的变量super
37. System.out.println("----------------neither--end-----------------------");
38. }
39.
40.}
package com.java.three;

public class Testmain {

public static void main(String ssd[]){
// Father ff=new Father();
// ff.setName("父亲");
// ff.setAge(55);
// ff.printTheInfomationOfThisMan();

Son ss=new Son();

System.out.println("----------------this--start-----------------------");
ss.thisSetInfoToSon("给儿子命名this", 26);////使用this给变量赋值
ss.setAmbution("亿万富翁");//子类自己的方法
//ss.printTheInfomationOfThisMan();//继承父类的方法

ss.printTheInfomationOfSon();//子类自己的方法，打印自己的变量this
ss.printTheInfomationOfFather();//子类自己的方法，打印父类的变量super
System.out.println("----------------this--end-----------------------");


System.out.println("----------------super--start-----------------------");
ss.superSetInfoToSon("给儿子命名super", 25);//使用super给变量赋值
ss.printTheInfomationOfSon();//子类自己的方法，打印自己的变量this
ss.printTheInfomationOfFather();//子类自己的方法，打印父类的变量super

System.out.println("----------------super--end-----------------------");
System.out.println("");
System.out.println("----------------注意！！！-----------------------");
System.out.println("----------------neither--start-----------------------");

//注意下面我们设置的信息是("给儿子命名neither", 18)
ss.setInfoToSonWithoutNeither("给儿子命名neither", 18);//不适用this,也不使用super，给变量赋值
ss.printTheInfomationOfSon();//子类自己的方法，打印自己的变量this
ss.printTheInfomationOfFather();//子类自己的方法，打印父类的变量super
System.out.println("----------------neither--end-----------------------");
}

}


控制台打印：

[html] view plaincopyprint?
01.----------------this--start-----------------------
02.Son [ambution=亿万富翁, name=给儿子命名this, age=26, sex=男]
03.Son [ambution=亿万富翁, name=给儿子命名this, age=26, sex=男]
04.----------------this--end-----------------------
05.----------------super--start-----------------------
06.Son [ambution=亿万富翁, name=给儿子命名super, age=25, sex=男]
07.Son [ambution=亿万富翁, name=给儿子命名super, age=25, sex=男]
08.----------------super--end-----------------------
09.
10.----------------注意！！！-----------------------
11.----------------neither--start-----------------------
12.Son [ambution=亿万富翁, name=给儿子命名super, age=25, sex=男]
13.Son [ambution=亿万富翁, name=给儿子命名super, age=25, sex=男]
14.----------------neither--end-----------------------
----------------this--start-----------------------
Son [ambution=亿万富翁, name=给儿子命名this, age=26, sex=男]
Son [ambution=亿万富翁, name=给儿子命名this, age=26, sex=男]
----------------this--end-----------------------
----------------super--start-----------------------
Son [ambution=亿万富翁, name=给儿子命名super, age=25, sex=男]
Son [ambution=亿万富翁, name=给儿子命名super, age=25, sex=男]
----------------super--end-----------------------

----------------注意！！！-----------------------
----------------neither--start-----------------------
Son [ambution=亿万富翁, name=给儿子命名super, age=25, sex=男]
Son [ambution=亿万富翁, name=给儿子命名super, age=25, sex=男]
----------------neither--end-----------------------



结论：子类继承的变量就是自己的，无论用this，或是用super都一样。

还有一个问题我没看明白，希望高手解答：
我们预想应该输出的("给儿子命名neither", 18)这个信息无论用this取，还是用super取，都取不出来！

不知为什么，欢迎技术大牛给我留言。

xieshengjun2009 2012-03-26
  • 打赏
  • 举报
 回复
[Quote=引用 4 楼 sdojqy1122 的回复:]
什么也不写的话，如果子类重写了，就调用子类方法啊，如果方法没有重写，在子类找不到方法就会去父类里面找，父类找不到，再去父类的父类那里找，这样才符合常理嘛。。不然我这有方法你不用，跑别人那里去拿，万一别人还有父类，岂不是做了很多无用功。
[/Quote]

+1,补充：多态的表现形式！
Acesidonu 2012-03-26
  • 打赏
  • 举报
 回复
[Quote=引用 3 楼 ce2010 的回复:]

super相当于一个弗雷对象的引用，this相当与当前对象的一个引用。
super的使用：
子类的构造方法中，调用父类的构造方法是，可以用super([父类构造方法中相应的参数列表])，在调用时，必须在子类构造方法的第一行。
子类方法中，子类复写了父类的方法，当调用该方法时，不想使用父类的方法，那么就用super.method(),调用父类的方法。
this的使用：
……
[/Quote]
++
sdojqy1122 2012-03-26
  • 打赏
  • 举报
 回复

什么也不写的话，如果子类重写了，就调用子类方法啊，如果方法没有重写，在子类找不到方法就会去父类里面找，父类找不到，再去父类的父类那里找，这样才符合常理嘛。。不然我这有方法你不用，跑别人那里去拿，万一别人还有父类，岂不是做了很多无用功。
老9 2012-03-26
  • 打赏
  • 举报
 回复
super相当于一个弗雷对象的引用，this相当与当前对象的一个引用。
super的使用：
子类的构造方法中，调用父类的构造方法是，可以用super([父类构造方法中相应的参数列表])，在调用时，必须在子类构造方法的第一行。
子类方法中，子类复写了父类的方法，当调用该方法时，不想使用父类的方法，那么就用super.method(),调用父类的方法。
this的使用：
在同一个类中，非静态方法可以用this.method()来掉用非静态的方法，this不能调用static修饰的成员方法和成员变量。
ncist_jianeng 2012-03-26
  • 打赏
  • 举报
 回复
既然没有重写，调用supper和this都一样。重写了后supper调用父类的方法，this调用子类重写的方法。属性也是一样。很好理解的。
成一粒 2012-03-26
  • 打赏
  • 举报
 回复
super是调用父类的构造函数。this.什么是调用父类中的方法
微服务系列第七季-Java面向对象中的继承
微服务应用是分布式开发的主要手段，它很好的...包括：继承的概念、为什么要继承、继承的类型及特性、extends关键字、final关键字、implements关键字、super和this关键字、子类中如何调用父类中的有参、无参构造方法。
子类调用父类方法时用super和this的区别所在
基础不扎实的朋友应该会有一个疑问，当super和this都可以用的时候，到底我们是用super调用父类方法还是用this呢？这里其实是分两种情况的：当子类重写了父类的方法时，如果需要用到父类的方法时，才要用super，表明这个方法时父类的方法不是子类的方法。上代码：Father类[java] view plain copypublic class Father {            publi...
子类继承父类后，可以直接调用父类的变量和方法，那为什么还用super调用呢？为什么在static方法中不能使用super与this？
1.子类继承父类后，可以直接调用父类的变量和方法，那为什么还用super调用呢？ 原因：如果子类对父类的变量和方法进行了重写，你又想再使用父类的方法，这是就需要super来调用，否则默认调用你在子类中重写的变量和方法。 this()：调用本类中其他重载的构造函数（必须写在函数中的第一行） super()：调用父类中的构造函数（必须写在函数中的第一行） this.XXX()：调用在本类中重写的父类方法 super.XXX()：调用父类中的方法 class Father { String str = "父类变
第十三题:子类要调用继承自父类的方法，必须使用super关键字。
第十三题 子类要调用继承自父类的方法，必须使用super关键字。 A正确 B错误 懵逼树上懵逼果，懵逼树下你和我，首先来一段代码 如果子类没有重写父类的方法，调用父类的方法用不用super关键字结果都一样。 如果子类重写父类的方法，调用父类的方法必须用super关键字。 class TestA{ public void a(){ System.out.pri...
Java EE

67,513

社区成员

225,879

社区内容

发帖
与我相关
我的任务
社区描述
J2EE只是Java企业应用。我们需要一个跨J2SE/WEB/EJB的微容器，保护我们的业务核心组件（中间件），以延续它的生命力，而不是依赖J2SE/J2EE版本。
社区管理员
  • Java EE
加入社区
  • 近7日
  • 近30日
  • 至今

加载中

查看更多榜单
社区公告
暂无公告

试试用AI创作助手写篇文章吧

+ 用AI写文章