一、this关键字

Java关键字this只能用于成员方法体内，它是一个系统隐含的指针且被自动附加在非静态的成员方法参数列表中。当一个对象被创建后，Java虚拟机（JVM）就会给这个对象分配一个引用自身的指针，这个指针的名字就是this。

当前时刻，哪个对象调用该函数，那么this就指向当前调用该函数的对象（this也可以理解为当前（上下文）对象），系统会自动在该函数的参数列表中添加一个隐藏的this指针，并且把调用该函数的对象的地址值赋给this指针，这样一来，在函数的内部通过this就可以访问当前正在调用该函数的对象的成员（包括成员变量、成员方法）。

因此，this只能在类中的非静态方法中使用，静态方法和静态的代码块中绝对不能出现this（指针），这在“Java关键字static、final使用总结” 一文中给出了明确解释。
并且this只和特定的对象关联，而不和类关联，同一个类的不同对象有不同的this。下面给出一个使用this的综合实例，以便说明问题：

package org.leizhimin;public class Test6 {private intnumber;private String username;private Stringpassword;private intx = 100;public Test6(int n) {number =n;//这个还可以写为：this.number=n;//this代表当前时刻正在创建的对象}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;}
}

运行结果如下：
-----------
0
未知
空
100
101
-----------
0
游客
空
100
101

看着上面的例子，总结在如下三个地方会用到this：
①通过this调用另一个构造方法，用法是this(参数列表)，这个仅仅在类的构造方法中，别的地方不能这么用。
②函数参数或者函数中的局部变量和成员变量同名的情况下，成员变量被屏蔽，此时要访问成员变量则需要用“this.成员变量名”的方式来引用成员变量。当然，在没有同名的情况下，可以直接用成员变量的名字，而不用this，用了也不为错，呵呵。
③在函数中，需要引用该函所属类的当前对象时候，直接用this。

以上3点可以再简化为2点，就是①是一个用法，即：this代表当前时刻正在创建的对象；②③是一个用法，即：this代表当前时刻正在调用该成员方法的对象。

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

二、super关键字

super关键和this关键字的作用类似，是使被屏蔽的成员变量或者成员方法变为可见，或者说用来引用被屏蔽的成员变量或者成员方法。
不过super是用在子类中，目的是访问直接父类中被屏蔽的成员，注意是直接父类（就是类之上最近的超类）。下面是一个综合运用super的例子，有两个类：一个Father类，一个Father类的子类Son，通过这两个类完全演示了super的用法，一下是代码：

package org.leizhimin; 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 自动生成方法存根     }
}
package org.leizhimin;
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运行结果：

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.方法名(参数列表)”的方式调用父类的方法。“super.成员方法(参数列表)”一般也写在子类成员方法中的第一行。

this、super的用法也不过这些，只有理解了其中的原理，才不会跌入陷阱！