黑马程序员技术交流社区

标题: 求教this和super的使用范围和区别,有点乱 [打印本页]

作者: 王晓斌    时间: 2013-1-4 10:37
标题: 求教this和super的使用范围和区别,有点乱
本帖最后由 hi_wxb 于 2013-1-4 11:07 编辑

求教this和super的使用范围和区别
作者: yangfengxiao    时间: 2013-1-4 10:49
1.this

是用于区分局部变量和成员变量同名的情况。
this:代表本类的对象,到底代表哪一个对象呢?代表this所在函数所属对象的引用。简单说:哪个对象在调用this所在的函数,this就代表哪个对象。
this的应用:
当定义类中功能时,该函数内部要用到调用该函数的对象时,这时用this来表示这个对象。
在构造函数间调用
this语句,不能用于普通函数中,只能用于构造函数之间互相调用。
this语句只能定义在构造函数的第一行,因为初始化要先执行。意思是构造方法中this(age)要放在第一行,this.age放在第一行会导致 this(age)不能初始化。
例如person p = new person("lisi",30)
person的构造函数
[java] view plaincopyprint?person(String name,int age)//初始化name,age   
{  
this(name);//初始化name,这时候会调用本对象的person(String name)构造方法   
this.age=age;//   
}  
person(String name)  
{  
this.name=name;  
}  
person(int age)  
{  

person(String name,int age)//初始化name,age
{
this(name);//初始化name,这时候会调用本对象的person(String name)构造方法
this.age=age;//
}
person(String name)
{
this.name=name;
}
person(int age)
{[java] view plaincopyprint?this.int=int;  
}<SPAN> </SPAN>  

this.int=int;
}     2.super

对于super,《The Java Programming Language》上这样说:In field access and method invocation, super acts as a reference to the current object as an instance of its superclass.可以理解为在需要访问the hidden field和进行父类方法调用的时候,super表现为指向作为父类的一个实例的当前对象的一个引用
java是解释性的语言,因此this和super不应该是地址。理解为引用可能更自然些
this 表示当前类的对象,super 表示对父类的某个构造器的调用


this是一个对象的引用,而super仅仅是一个指示编译器调用超类方法的特有的关键字,这里一定要记住!super不是一个引用,只是一个关键字!很多人犯的错误。



super只是编译时期的关键字。super是编译才有用的,是用来指导编译器的。
你可以:
Object ojb = this;
但无法:
Object ojb = super;




作者: 刘文超    时间: 2013-1-4 10:49
本帖最后由 刘文超 于 2013-1-4 11:21 编辑

我只是自己这么认为的,不知道正确与否,希望大家指正:
this=当前对象、
super=当前对象中的包含的父类对象
都是“对象”,可以使用本类的方法和属性,但在子类中即使用super也无法访问到父类private属性。

此外this可以用来调用本类的其他构造方法,
然后super可以用来调用父类的构造方法、
但值得注意的是这两个不能一起用,因为this()和super()都要写在子类构造方法的第一行代码:
public Constr(int i){
      this();
      super();
}//这样式错误的、、、

写个小程序,在其中有注释,对子类继承父类属性及子类覆盖掉父类的属性做了测试及分析:
  1. package org.qyx.online;

  2. class Father{
  3.         int money;
  4.         String name;
  5.         public Father(){}
  6.         
  7.         public Father(int money){
  8.                 this.money=money;
  9.         }
  10.         
  11.         public void setName(String name){
  12.                 this.name=name;
  13.         }
  14. }

  15. class Son extends Father{
  16.         //子类重新定义了money,访问父类内部的money还是父类原来的没有变、但再访问子类的money将不是父类继承的了,而是自己定义的那个了、
  17.         int money;
  18.         public Son(){}
  19.         
  20.         public void setMoney(int money){
  21.                 this.money=money;
  22.         }
  23.         
  24.         public void setFatherMoney(int money){
  25.                 super.money=money;
  26.         }
  27.         
  28.         public int getMoney(){
  29.                 return money;
  30.         }
  31.         
  32.         public int getFatherMoney(){
  33.                 return super.money;
  34.         }
  35.         
  36.         public void setName(String name){
  37.                 this.name=name;
  38.         }
  39.         public void setFatherName(String name){
  40.                 super.name=name;
  41.         }
  42.         public String getName(){
  43.                 return this.name;
  44.         }
  45.         
  46.         public String getFatherName(){
  47.                 return super.name;
  48.         }
  49. }

  50. public class TestSuper {
  51.         
  52.         public static void main(String[] args) {
  53.                 Son s=new Son();
  54.                 s.setFatherName("father");
  55.                 System.out.println(s.getFatherName());//打印father
  56.                 System.out.println(s.getName());//打印father
  57.                
  58.                 s.setFatherMoney(10);
  59.                 s.setMoney(1);//注意,子类中重新定义过money,看看这个有没有覆盖掉父类的?
  60.                 System.out.println(s.getMoney());//打印1
  61.                 System.out.println(s.getFatherMoney());//打印10
  62.                

  63.         }

  64. }

复制代码

作者: 而今从头越2012    时间: 2013-1-4 10:51
关于这个问题,你先在头脑里形成这个概念:this通常指当前对象,super则指父类的,也有两外的用途,this调用当前对象的另一个构造函数。
光有这个概念还是不行的,接下来就要知道它们的具体用处了。举例说明吧:
(1)最普遍的情况就是,在你的方法中的某个形参名与当前对象的某个成员有相同的名字,这时为了不至于混淆,你便需要明确使用this关键字来指明你要使用某个成员,使用方法是“this.成员名”,而不带this的那个便是形参。另外,还可以用“this.方法名”来引用当前对象的某个方法,但这时this就不是必须的了,你可以直接用方法名来访问那个方法,编译器会知道你要调用的是哪一个。
public class DemoThis{ 
private String name; 
private int age; 
DemoThis(String name,int age){  
setName(name);
//你可以加上this来调用方法,像这样:this.setName(name);但这并不是必须的  
setAge(age);  
this.print();  }  
public void setName(String name){  
this.name=name;//此处必须指明你要引用成员变量 
}
public void etAge(int age){ 
this.age=age; 
} 
public void print(){  
System.out.println("Name="+name+" ge="+age);
//在此行中并不需要用this,因为没有会导致混淆的东西 
} 
public static void main(String[] args){  
DemoThis dt=new DemoThis("Kevin","22");
}
上面的代码很简单,你应该能够看得懂的。
(2)接下来再看看super的用法吧:
class Person{ 
public int c; 
private String name; 
private int age;
protected void setName(String name){  
this.name=name; 
} 
protected void setAge(int age){ 
this.age=age;
 }
protected void print(){  
System.out.println("Name="+name+" Age="+age);
}
}
public class DemoSuper extends Person{ 
public void print(){  
System.out.println("DemoSuper:"); 
super.print();
} 
public static void main(String[] args){ 
DemoSuper ds=new DemoSuper(); 
ds.setName("heima"); 
ds.setAge(22); 
ds.print();
}
}
(3)在构造函数中,this和super也有上面说的种种使用方式,并且它还有特殊的地方,请看下面的例子:
class Person{ 

public static void prt(String s){  
System.out.println(s); 
} 
Person(){ 
prt("A Person."); 
}
Person(String name){ 
 prt("A person name is:"+name); 

}
}
public class Chinese extends Person{
 Chinese(){  
super(); //调用父类构造函数(1) 
prt("A chinese.");//(4)
} 
Chinese(String name){  
super(name);//调用父类具有相同形参的构造函数(2)  
prt("his name is:"+name);
}
Chinese(String name,int age){  
this(name);//调用当前具有相同形参的构造函数(3) 
prt("his age is:"+age);
}
public static void main(String[] args){ 
Chinese cn=new Chinese();  
cn=new Chinese("heima"); 
cn=new Chinese("heima",2);
}
}
作者: 冉世友    时间: 2013-1-4 11:04
这是我记的笔记哈:

关键字: super  父类对象的引用
             this    本类对象的引用
如果子类中出现非私有的同名成员变量时,
子类要访问本类中的变量,用this,子类要访问父类中的变量,用super。
super()可以访问父类的构造函数,this()可以访问本类的其他构造函数。
this()和super()都要求放在第一行,所以不能同时出现在同一构造函数中。

刚看了楼上说的“super仅仅是一个指示编译器调用超类方法的特有的关键字,这里一定要记住!super不是一个引用,只是一个关键字!很多人犯的错误”,学习了。

作者: 唐长智    时间: 2013-1-4 14:48
this 的应用
       只能定义在构造函数的第一行。
       当定义类中的函数时,该函数内部要用到调用该函数的对象时,用this来表示这个对象。
       但凡本类功能内部使用本类对象,都用this表示。
       构造函数中相互调用时,必须用this语句。
       可以用于区分局部变量和成员变量重名的现象,那个对象调用this所在的函数,this就代表哪个变量。
super
       必须写在构造函数的第一行。
       super用于调用父类中的方法,通过覆写的方法,用super();,super(参数);来调用父类中无参数或者有参数的构造函数。

作者: 刘圣繁    时间: 2013-1-4 15:19
Java中this与super的区别
This与super在使用的很相似,都可以调用其他的方法,其他属性,构造方法不缺放在首页

this与super调用的操作不能在同一个构造方法中出现的,this调用构造肯定要留出口.

this
使用范围: 调用本类的方法或者属性
super
使用范围:从子类中调用父类的方法或者属性
this
调用属性:this.本类属性,从本类中查找
super
super。父类属性,从父类中查找
this
调用方法
this.本类方法()从本类中查找,
super
调用方法:
super
.父类方法,从父类查找
this
调用构造
放在本类的构造方法的首行,构造方法需要一个出口
{至少有一个构造方法没有用this调用}

super
放在子类构造方法之中默认的子类中藏着一个super(),去调用父类中的默认关照方法。

特殊点:
this表示当前对象

super没有这个观念





欢迎光临 黑马程序员技术交流社区 (http://bbs.itheima.com/) 黑马程序员IT技术论坛 X3.2