求教this和super的使用范围和区别

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;

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

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

写个小程序，在其中有注释，对子类继承父类属性及子类覆盖掉父类的属性做了测试及分析：

1. package org.qyx.online;
   
2. 
   
3. class Father{
   
4.         int money;
   
5.         String name;
   
6.         public Father(){}
   
7.         
   
8.         public Father(int money){
   
9.                 this.money=money;
   
10.         }
    
11.         
    
12.         public void setName(String name){
    
13.                 this.name=name;
    
14.         }
    
15. }
    
16. 
    
17. class Son extends Father{
    
18.         //子类重新定义了money，访问父类内部的money还是父类原来的没有变、但再访问子类的money将不是父类继承的了，而是自己定义的那个了、
    
19.         int money;
    
20.         public Son(){}
    
21.         
    
22.         public void setMoney(int money){
    
23.                 this.money=money;
    
24.         }
    
25.         
    
26.         public void setFatherMoney(int money){
    
27.                 super.money=money;
    
28.         }
    
29.         
    
30.         public int getMoney(){
    
31.                 return money;
    
32.         }
    
33.         
    
34.         public int getFatherMoney(){
    
35.                 return super.money;
    
36.         }
    
37.         
    
38.         public void setName(String name){
    
39.                 this.name=name;
    
40.         }
    
41.         public void setFatherName(String name){
    
42.                 super.name=name;
    
43.         }
    
44.         public String getName(){
    
45.                 return this.name;
    
46.         }
    
47.         
    
48.         public String getFatherName(){
    
49.                 return super.name;
    
50.         }
    
51. }
    
52. 
    
53. public class TestSuper {
    
54.         
    
55.         public static void main(String[] args) {
    
56.                 Son s=new Son();
    
57.                 s.setFatherName("father");
    
58.                 System.out.println(s.getFatherName());//打印father
    
59.                 System.out.println(s.getName());//打印father
    
60.                
    
61.                 s.setFatherMoney(10);
    
62.                 s.setMoney(1);//注意，子类中重新定义过money，看看这个有没有覆盖掉父类的？
    
63.                 System.out.println(s.getMoney());//打印1
    
64.                 System.out.println(s.getFatherMoney());//打印10
    
65.                
    
66. 
    
67.         }
    
68. 
    
69. }
    
70. 
    

复制代码

关于这个问题，你先在头脑里形成这个概念：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);
}
}

这是我记的笔记哈：

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

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

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

Java中this与super的区别
This与super在使用的很相似，都可以调用其他的方法,其他属性,构造方法不缺放在首页

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

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

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

特殊点:
this表示当前对象

super没有这个观念