在编程中this和super的使用有时候爱混淆，怎么区别它们

this关键字：在类的内部代表对象本身，
super关键字：调用父类的方法

用法：http://blog.csdn.net/anmei2010/article/details/4093118

this代表的是本类对象的引用。
super代表的是父类对象的引用。

如果子类中出现非私有的同名成员变量时，

子类要访问本类中的变量，用this

子类要访问父类中的同名变量，用super。

super的使用和this的使用几乎一致。

this代表的是本类对象的引用。

super代表的是父类对象的引用。

     在Java中，this通常指当前对象，super则指父类的。当你想要引用当前对象的某种东西，比如当前对象的某个方法，或当前对象的某个成员，你便可以利用this来实现这个目的，当然，this的另一个用途是调用当前对象的另一个构造函数；     this只能在类中的非静态方法中使用，静态方法和静态的代码块中绝对不能出现this      super关键和this作用类似，是被屏蔽的成员变量或者成员方法或变为可见，或者说用来引用被屏蔽的成员变量和成员方法。 不过super是用在子类中，目的是访问直接父类中被屏蔽的成员，注意是直接父类（就是类之上最近的超类）。  如果你想引用父类的某种东西，则非super莫属。

1. this关键字代表的是本类对象。如
   
2. class A {
   
3. int a;
   
4. void show(int a){
   
5.    this.a=a; //你可以把这个this看成是a；
   
6. }
   
7. }
   
8. class B{
   
9.   public static void main(String[] args){
   
10.      A a = new A();  
    
11.   }
    
12. }
    
13. 
    
14. 
    
15. super关键字是调用父类的方法。如
    
16. 
    
17. class A{
    
18.     int a;
    
19.     A(int a){
    
20.          this.a=a;你可以把这个this看成是a；
    
21.     }
    
22. }
    
23. class B extends  A {
    
24.   B(int b){
    
25.    super(a); //这里你可以认为是他在调用父类中的方法和变量 ，因为父类中的变量a。因为父类中已经存在变量a。所以在这里         
    
26.                     //可以通过super关键字直接调用父类中的变量a，而不用在自己定义变量a了
    
27.    }
    
28. }
    
29. class C{
    
30.   public static void main(String[] args){
    
31.      B b = new B();  
    
32.   }
    
33. }

复制代码

（1）

1. public class DemoThis{
   
2. private String name;
   
3. private int age;
   
4. DemoThis(String name,int age){  
   
5. setName(name); //你可以加上this来调用方法，像这样：this.setName(name);但这并不是必须的  
   
6. setAge(age);  
   
7. this.print(); }   
   
8. public void setName(String name){  
   
9. this.name=name;//此处必须指明你要引用成员变量
   
10. }
    
11. public void etAge(int age){  
    
12. this.age=age;
    
13. }
    
14. public void print(){  
    
15. System.out.println("Name="+name+" ge="+age);//在此行中并不需要用this，因为没有会导致混淆的东西
    
16. }
    
17. public static void main(String[] args){  
    
18. DemoThis dt=new DemoThis("Kevin","22");｝

复制代码

在一般方法中最普遍的情况就是，在你的方法中的某个形参名与当前对象的某个成员有相同的名字，这时为了不至于混淆，你便需要明确使用this关键字来指明你要使用某个成员，使用方法是“this.成员名”，而不带this的那个便是形参。另外，还可以用“this.方法名”来引用当前对象的某个方法，但这时this就不是必须的了，你可以直接用方法名来访问那个方法，编译器会知道你要调用的是那一个。

（2）

1. class Person{
   
2. public int c;
   
3. private String name;
   
4. private int age;
   
5. protected void setName(String name){  
   
6. this.name=name;
   
7. }
   
8. protected void setAge(int age){  
   
9. this.age=age;
   
10. }
    
11. protected void print(){  
    
12. System.out.println("Name="+name+" Age="+age);
    
13. }
    
14. }
    
15. public class DemoSuper extends Person{
    
16. public void print(){  
    
17. System.out.println("DemoSuper:");  
    
18. super.print();
    
19. }
    
20. public static void main(String[] args){  
    
21. DemoSuper ds=new DemoSuper();  
    
22. ds.setName("kevin");  
    
23. ds.setAge(22);  
    
24. ds.print();
    
25. }
    
26. }

复制代码

在DemoSuper中，重新定义的print方法覆写了父类的print方法，它首先做一些自己的事情，然后调用父类的那个被覆写了的方法。输出结果说明了这一点：
  DemoSuper:
Name=kevin Age=22

在构造函数中，this和super也有上面说的种种使用方式，并且它还有特殊的地方，请看下面的例子：

1. class Person{
   
2. 
   
3. public static void prt(String s){  
   
4. System.out.println(s);
   
5. }
   
6. Person(){  
   
7. prt("A Person.");
   
8. }
   
9. Person(String name){
   
10. prt("A person name is:"+name);
    
11. 
    
12. }
    
13. }
    
14. public class Chinese extends Person{
    
15. Chinese(){  
    
16. super(); //调用父类构造函数（1）  
    
17. prt("A chinese.");//(4)
    
18. }
    
19. Chinese(String name){  
    
20. super(name);//调用父类具有相同形参的构造函数（2）  
    
21. prt("his name is:"+name);
    
22. }
    
23. Chinese(String name,int age){  
    
24. this(name);//调用当前具有相同形参的构造函数（3）  
    
25. prt("his age is:"+age);
    
26. }
    
27. public static void main(String[] args){  
    
28. Chinese cn=new Chinese();  
    
29. cn=new Chinese("kevin");  
    
30. cn=new Chinese("kevin",22);
    
31. }
    
32. }

复制代码

在这段程序中，this和super不再是像以前那样用“.”连接一个方法或成员，而是直接在其后跟上适当的参数，因此它的意义也就有了变化。super后加参数的是用来调用父类中具有相同形式的构造函数，如1和2处。this后加参数则调用的是当前具有相同参数的构造函数，如3处。当然，在Chinese的各个重载构造函数中，this和super在一般方法中的各种用法也仍可使用，比如4处，你可以将它替换为“this.prt”(因为它继承了父类中的那个方法）或者是“super.prt”（因为它是父类中的方法且可被子类访问），它照样可以正确运行。

this和super的区别
操作属性： this.属性：表示调用本类中的属性，如果本类中的属性不存在，则从父类查找。
                  super.属性：表示调用父类中的属性。
操作方法：        this.方法()：表示调用本类中的方法，如果本类中的方法不存在，则从父类查找
                  super.方法()：表示调用父类中的方法。
调用构造：this()调用本类中的其他构造方法
                 super.方法()：表示调用父类中的方法
查找范围：this先从子类中查找，如果没有从父类中查找
                super直接查找父类