Java 进阶—— super 和 this 的用法

一、this
Java关键字this只能用于方法方法体内。当一个对象创建后，Java虚拟机（JVM）就会给这个对象分配一个引用自身的指针，这个指针的名字就是this。因此，this只能在类中的非静态方法中使用，静态方法和静态的代码块中绝对不能出现this，这在“Java关键字static、final使用总结”一文中给出了明确解释。并且this只和特定的对象关联，而不和类关联，同一个类的不同对象有不同的this。下面给出一个使用this的综合实例，以便说明问题：

[java] view plaincopy  
 public class Test6 {  
     private int number;  
     private String username;  
     private String password;  
     private int x = 100;  
     public Test6(int n){  
         number = n;  // 这个还可以写为: this.number=n;  
     }  
 public Test6(int i, String username, String password){  
   // 成员变量和参数同名,成员变量被屏蔽,用"this.成员变量"的方式访问成员变量.  
     this.username = username;  
     this.password = password;  
 }  
  // 默认不带参数的构造方法  
 public Test6(){  
     this(0, "未知", "空"); // 通过this调用另一个构造方法  
 }  
 public Test6(String name){  
     this(1, name, "空"); // 通过this调用另一个构造方法  
 }  
 public static void main(String args[]){  
     Test6 t1 = new Test6();  
     Test6 t2 = new Test6("游客");  
     t1.outinfo(t1);  
     t2.outinfo(t2);  
 }  
 private void outinfo(Test6 t){  
     System.out.println("-----------");  
     System.out.println(t.number);  
     System.out.println(t.username);  
     System.out.println(t.password);  
     f(); // 这个可以写为: this.f();  
  }  
 private void f(){  
   // 局部变量与成员变量同名,成员变量被屏蔽,用"this.成员变量"的方式访问成员变量.  
     int x;  
     x = this.x++;  
     System.out.println(x);  
     System.out.println(this.x);  
 }  
    
  //返回当前实例的引用  
 private Test6 getSelf(){  
     return this;   
 }  
 }  

运行结果如下：

[java] view plaincopy  
 -----------  
 0  
 未知  
 空  
 100  
 101  
 -----------  
 0  
 游客  
 空  
 100  
 101  

看着上面的例子，说明在什么情况下需要用到this：

第一、通过this调用另一个构造方法，用法是this(参数列表)，这个仅仅在类的构造方法中，别的地方不能这么用。

第二、函数参数或者函数中的局部变量和成员变量同名的情况下，成员变量被屏蔽，此时要访问成员变量则需要用“this.成员变量名”的方式来引用成员变量。当然，在没有同名的情况下，可以直接用成员变量的名字，而不用this，用了也不为错，呵呵。

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

其实这些用法总结都是从对“this是指向对象本身的一个指针”这句话的更深入的理解而来的，死记不然容易忘记而且容易搞错，要理解！

二、super
super关键和this作用类似，是被屏蔽的成员变量或者成员方法或变为可见，或者说用来引用被屏蔽的成员变量和成员成员方法。

不过super是用在子类中，目的是访问直接父类中被屏蔽的成员，注意是直接父类（就是类之上最近的超类）。下面是一个综合运用super的例子，有两个类：一个Father类，一个Father类的子类Son，通过这两个类完全演示了super的用法，一下是代码：

[java] view plaincopy  
 public class Father{  
     public String v="Father";  
     public String x="输出了Father类的public成员变量x!!!";  
   
     public Father(){  
         System.out.println("Father构造方法被调用!");  
     }  
    
     public Father(String v){  
         this.v="Father类的带参数构造方法!运行了.";  
     }  
     public void outinfo(){  
         System.out.println("Father的outinfo方法被调用");  
     }   
     public static void main(String[] args){  
   // TODO 自动生成方法存根  
     }  
 }  
    
 public class Son extends Father{  
     public String v="Son";  
    
     public Son(){  
         super();      //调用超类的构造方法,只能放到第一行.  
         System.out.println("Son无参数构造方法被调用!");  
         //super();      //错误的,必须放到构造方法体的最前面.  
     }   
    
     public Son(String str){  
         super(str);  
         System.out.println("Son带参数构造方法被调用!");  
     }  
      //覆盖了超类成员方法outinfo()  
     public void outinfo(){   
         System.out.println("Son的outinfo()方法被调用");  
     }   
    
     public void test(){  
     
     String v="哈哈哈哈!";   //局部变量v覆盖了成员变量v和超类变量v  
     
     System.out.println("------1-----");  
     System.out.println(v);   //输出局部变量v  
     System.out.println(this.v);  //输出(子类)成员变量v  
     System.out.println(super.v); //输出超类成员变量v   
     
     System.out.println("------2-----");  
     System.out.println(x);   //输出超类成员变量v,子类继承而来  
     System.out.println(super.x); //输出超类成员变量v  
     
     System.out.println("------3-----");  
     outinfo();   //调用子类的outinfo()方法  
     this.outinfo();  //调用子类的outinfo()方法  
     super.outinfo(); //调用父类的outinfo()方法  
     }   
        
     public static void main(String[] args) {  
         new Son().test();  
     }  
 }  

子类Son运行结果：

[java] view plaincopy  
 Father构造方法被调用!  
 Son无参数构造方法被调用!  
 ------1-----  
 哈哈哈哈!  
 Son  
 Father  
 ------2-----  
 输出了Father类的public成员变量x!!!  
 输出了Father类的public成员变量x!!!  
 ------3-----  
 Son的outinfo()方法被调用  
 Son的outinfo()方法被调用  
 Father的outinfo方法被调用  

说明：次例子仅仅为了说明super的用法，实际在设计类的时候一般都尽可能私有(private)化。

通过上面的例子，下面总结一下super的用法：

第一、在子类构造方法中要调用父类的构造方法，用“super(参数列表)”的方式调用，参数不是必须的。同时还要注意的一点是：“super(参数列表)”这条语句只能用在子类构造方法体中的第一行。

第二、当子类方法中的局部变量或者子类的成员变量与父类成员变量同名时，也就是子类局部变量覆盖父类成员变量时，用“super.成员变量名”来引用父类成员变量。当然，如果父类的成员变量没有被覆盖，也可以用“super.成员变量名”来引用父类成员变量，不过这是不必要的。

第三、当子类的成员方法覆盖了父类的成员方法时，也就是子类和父类有完全相同的方法定义（但方法体可以不同），此时，用“super.方法名(参数列表)”的方式访问父类的方法。

三、super和this的异同：

1）、super（参数）：调用基类中的某一个构造函数（应该为构造函数中的第一条语句）
this（参数）：调用本类中另一种形成的构造函数（应该为构造函数中的第一条语句）

2）、super:　它引用当前对象的直接父类中的成员（用来访问直接父类中被隐藏的父类中成员数据或函数，基类与派生类中有相同成员定义时如：super.变量名 super.成员函数据名（实参）
this：它代表当前对象名（在程序中易产生二义性之处，应使用this来指明当前对象；如果函数的形参与类中的成员数据同名，这时需用this来指明成员变量名）

3）、调用super()必须写在子类构造方法的第一行，否则编译不通过。每个子类构造方法的第一条语句，都是隐含地调用super()，如果父类没有这种形式的构造函数，那么在编译的时候就会报错。

4）、super()和this()类似,区别是，super()从子类中调用父类的构造方法，this()在同一类内调用其它方法。

5）、super()和this()均需放在构造方法内第一行。

6）、尽管可以用this调用一个构造器，但却不能调用两个。

7）、this和super不能同时出现在一个构造函数里面，因为this必然会调用其它的构造函数，其它的构造函数必然也会有super语句的存在，所以在同一个构造函数里面有相同的语句，就失去了语句的意义，编译器也不会通过。

8）、this()和super()都指的是对象，所以，均不可以在static环境中使用。包括：static变量,static方法，static语句块。

9）、从本质上讲，this是一个指向本对象的指针, 然而super是一个Java关键字。