Java基础—super和this关键字

一、this

  Java关键字this只能用于方法体内，表示对“调用方法的那个对象”的引用。当一个对象创建后，Java虚拟机（JVM）就会给这个对象分配一个引用自身的指针，这个指针的名字就是this。因此，this只能在类中的非静态方法中使用，静态方法和静态的代码块中绝对不能出现this，并且this只和特定的对象关联，而不和类关联，同一个类的不同对象有不同的this。

在什么情况下需要用到this：
        第一、通过this调用另一个构造方法，用法是this(参数列表)，这个仅仅在类的构造方法中，别的地方不能这么用。尽管可用this 调用一个构造器，但不可调用两个。除构造器之外，编译器禁止在其它任何方法中调用构造器。
        第二、函数参数或者函数中的局部变量和成员变量同名的情况下，成员变量被屏蔽，此时要访问成员变量则需要用“this.成员变量名”的方式来引用成员变量。当然，在没有同名的情况下，可以直接用成员变量的名字，而不用this，用了也不为错。

        第三、在函数中，需要引用该函所属类的当前对象时候，直接用this。

下面给出一个使用this的综合实例，以便说明问题：

[java]  view plain copy

1. public class test {  
2.   
3.     private int number;  
4.     private String username;  
5.     private String password;  
6.     private int x = 100;  
7.   
8.     public test(int n) {  
9.         number = n; // 这个还可以写为: this.number=n;  
10.     }  
11.   
12.     public test(int i, String username, String password) {  
13.         // 成员变量和参数同名,成员变量被屏蔽,用"this.成员变量"的方式访问成员变量.  
14.         this.username = username;  
15.         this.password = password;  
16.     }  
17.   
18.     // 默认不带参数的构造方法  
19.     public test() {  
20.         this(0, "未知", "空"); // 通过this调用另一个构造方法  
21.         //this(1);    //尽管可用this调用一个构造器，但不可调用两个  
22.     }  
23.   
24.     public test(String name) {  
25.         this(1, name, "空"); // 通过this调用另一个构造方法  
26.     }  
27.   
28.     private void f() {  
29.         // 局部变量与成员变量同名,成员变量被屏蔽,用"this.成员变量"的方式访问成员变量.  
30.         int x;  
31.         x = this.x++;  
32.         System.out.println(x);  
33.         System.out.println(this.x);  
34.     }  
35.   
36.     // 返回当前实例的引用  
37.     private test getSelf() {  
38.         return this;  
39.     }  
40.       
41.     private void outinfo(test t) {  
42.         System.out.println("-----------");  
43.         System.out.println(t.number);  
44.         System.out.println(t.username);  
45.         System.out.println(t.password);  
46.         f(); // 这个可以写为: this.f();  
47.     }  
48.       
49.     public static void main(String args[]) {  
50.         test t1 = new test();  
51.         test t2 = new test("游客");  
52.         t1.outinfo(t1);  
53.         t2.outinfo(t2);  
54.     }  
55. }  

[java]  view plain copy

1. -----------  
2. 0  
3. 未知  
4. 空  
5. 100  
6. 101  
7. -----------  
8. 0  
9. 游客  
10. 空  
11. 100  
12. 101  

二、spuer

  super关键字和this作用类似，使被屏蔽的成员变量或者成员方法变为可见，或者说用来引用被屏蔽的成员变量和成员成员方法。不过super是用在子类中，目的是访问直接父类中被屏蔽的成员，注意是直接父类（就是类之上最近的超类）。

在什么情况下需要用到spuer：
        第一、在子类构造方法中要调用父类的构造方法，用“super(参数列表)”的方式调用，参数不是必须的。同时还要注意的一点是：“super(参数列表)”这条语句只能用在子类构造方法体中的第一行。
        第二、当子类方法中的局部变量或者子类的成员变量与父类成员变量同名时，也就是子类局部变量覆盖父类成员变量时，用“super.成员变量名”来引用父类成员变量。当然，如果父类的成员变量没有被覆盖，也可以用“super.成员变量名”来引用父类成员变量，不过这是不必要的。
        第三、当子类的成员方法覆盖（重写）了父类的成员方法时，也就是子类和父类有完全相同的方法定义（但方法体可以不同），此时，用“super.方法名(参数列表)”的方式访问父类的方法。

下面是一个综合运用super的例子，有两个类：一个Father类，一个Father类的子类Son，通过这两个类完全演示了super的用法：

[html]  view plain copy

1. public class Father {  
2.       
3.      public String v="Father";  
4.      public String x="输出了Father类的public成员变量x!!!";  
5.        
6.      public Father() {  
7.       System.out.println("Father构造方法被调用!");  
8.      }  
9.        
10.      public Father(String v){  
11.       this.v="Father类的带参数构造方法运行了.";  
12.      }  
13.        
14.      public void outinfo(){  
15.       System.out.println("Father的outinfo方法被调用");  
16.      }   
17.        
18. }  

[java]  view plain copy

1. public class Son extends Father{  
2.       
3.     public String v="Son";  
4.        
5.      public Son() {  
6.       super();      //调用超类的构造方法,只能放到第一行.  
7.       System.out.println("Son无参数构造方法被调用!");  
8.       //super();      //错误的,必须放到构造方法体的最前面.  
9.      }   
10.        
11.      public Son(String str){  
12.       super(str);  
13.       System.out.println("Son带参数构造方法被调用!");  
14.      }  
15.        
16.      //覆盖了超类成员方法outinfo()  
17.      public void outinfo(){   
18.       System.out.println("Son的outinfo()方法被调用");  
19.      }   
20.        
21.      public void test(){  
22.         
23.       String v="哈哈哈哈!";   //局部变量v覆盖了成员变量v和超类变量v  
24.         
25.       System.out.println("------1-----");  
26.       System.out.println(v);   //输出局部变量v  
27.       System.out.println(this.v);  //输出(子类)成员变量v  
28.       System.out.println(super.v); //输出超类成员变量v   
29.         
30.       System.out.println("------2-----");  
31.       System.out.println(x);   //输出超类成员变量v,子类继承而来  
32.       System.out.println(super.x); //输出超类成员变量v  
33.         
34.       System.out.println("------3-----");  
35.       outinfo();   //调用子类的outinfo()方法  
36.       this.outinfo();  //调用子类的outinfo()方法  
37.       super.outinfo(); //调用父类的outinfo()方法  
38.      }   
39.        
40.      public static void main(String[] args) {  
41.       new Son().test();  
42.      }  
43.   
44. }  

[java]  view plain copy

1. Father构造方法被调用!  
2. Son无参数构造方法被调用!  
3. ------1-----  
4. 哈哈哈哈!  
5. Son  
6. Father  
7. ------2-----  
8. 输出了Father类的public成员变量x!!!  
9. 输出了Father类的public成员变量x!!!  
10. ------3-----  
11. Son的outinfo()方法被调用  
12. Son的outinfo()方法被调用  
13. Father的outinfo方法被调用  

使用super&this应该注意些什么？
1）调用super()必须写在子类构造方法的第一行，否则编译不通过。每个子类构造方法的第一条语句，都是隐含地调用super()，如果父类没有这种形式的构造函数，那么在编译的时候就会报错。
2）super()和this()类似,区别是，super从子类中调用父类的构造方法，this()在同一类内调用其它方法。
3）super()和this()均需放在构造方法内第一行。
4）尽管可以用this调用一个构造器，但却不能调用两个。
5）this和super不能同时出现在一个构造函数里面，因为this必然会调用其它的构造函数，其它的构造函数必然也会有super语句的存在，所以在同一个构造函数里面有相同的语句，就失去了语句的意义，编译器也不会通过。
6）this()和super()都指的是对象，所以，均不可以在static环境中使用。包括：static变量,static方法，static语句块。
7）从本质上讲，this是一个指向本对象的指针, 然而super是一个Java关键字。