java中的this随处可见，用法也多，现在整理有几点： 1. this是指当前对象自己。 当在一个类中要明确指出使用对象自己的的变量或函数时就应该加上this引用。如下面这个例子中: public class Hello { String s = "Hello"; public Hello(String s) { System.out.println("s = " + s); System.out.println("1 -> this.s = " + this.s); this.s = s; System.out.println("2 -> this.s = " + this.s); } public static void main(String[] args) { Hello x="new" Hello("HelloWorld!"); } } 运行结果： s = HelloWorld! 1 -> this.s = Hello 2 -> this.s = HelloWorld! 在这个例子中，构造函数Hello中，参数s与类Hello的变量s同名，这时如果直接对s进行操作则是对参数s进行操作。若要对类Hello的成员变量s进行操作就应该用this进行引用。运行结果的第一行就是直接对构造函数中传递过来的参数s进行打印结果； 第二行是对成员变量s的打印；第三行是先对成员变量s赋传过来的参数s值后再打印，所以结果是HelloWorld!2. 把this作为参数传递 当你要把自己作为参数传递给别的对象时，也可以用this。如： public class A { public A() { new B(this).print(); } public void print() { System.out.println("Hello from A!"); } } public class B { A a; public B(A a) { this.a = a; } public void print() { a.print(); System.out.println("Hello from B!"); } } 运行结果： Hello from A! Hello from B! 在这个例子中，对象A的构造函数中，用new B(this)把对象A自己作为参数传递给了对象B的构造函数。3. 注意匿名类和内部类中的中的this。 有时候，我们会用到一些内部类和匿名类，如事件处理。当在匿嘀杏胻his时，这个this则指的是匿名类或内部类本身。这时如果我们要使用外部类的方法和变量的话，则应该加上外部类的类名。如下面这个例子： public class A { int i = 1; public A() { Thread thread = new Thread() { public void run() { for(;;) { A.this.run(); try { sleep(1000); } catch(InterruptedException ie) { }} } }; //注意这里有; thread.start(); } public void run() { System.out.println("i = " + i); i++; } public static void main(String[] args) throws Exception { new A(); } } 在上面这个例子中, thread 是一个匿名类对象，在它的定义中，它的 run 函数里用到了外部类的 run 函数。这时由于函数同名，直接调用就不行了。这时有两种办法，一种就是把外部的 run 函数换一个名字，但这种办法对于一个开发到中途的应用来说是不可取的。那么就可以用这个例子中的办法用外部类的类名加上 this 引用来说明要调用的是外部类的方法 run。4。在构造函数中，通过this可以调用同一class中别的构造函数，如 public class Flower{ Flower (int petals){} Flower(String ss){} Flower(int petals, Sting ss){ //petals++;调用另一个构造函数的语句必须在最起始的位置 this(petals); //this(ss);会产生错误，因为在一个构造函数中只能调用一个构造函数 } } 值得注意的是： 1：在构造调用另一个构造函数，调用动作必须置于最起始的位置。 2：不能在构造函数以外的任何函数内调用构造函数。 3：在一个构造函数内只能调用一个构造函数。参考资料：http://blog.ednchina.com/Kaos_linyong/17694/message.aspx
java面试题很喜欢考this与super之间的区别，，下面顺便两者都给你说说，，this关键字 1)在类的内部代表对象本身，你应该看到过this.xxx(),this.xxx这种用法吧， this就代表这个类的对象，比如 public class A { private String name; public void setName(String name) { //this就代表A的一个对象 //当你实例一个A时,A a1 = new A();this就是那个a1，只是this在内部用，而a1在外部用 //A a2 = new A()同理，这时在a2的内部，this就代表a2 this.name = name; } }2)this的第二种用法，是用在构造函数里的 当在构造器里要调用自己的其他构造器时，就用this this必须放在第一行 public class A { private String name; public A() { this("no name"); } public A(String name) { this.name = name; //other codes } } super关键字 1)显式的调用父类的方法 当从一个类继承时，子类和父类都有一个同名方法，也就是子类覆盖了父类的方法，可是又想调用父类的方法，那么就要用super，像继承swing的类时就有个好例子 public class MyPanel extends JPanel { @Override public void paint(Graphics g) { super.paint(g);//如果不用super，那么就会调用自己的paint方法 } }2）用在构造器，和this的用法一样，super也可以用在构造器，this是调用自己的其他构造器，那么super当然就是调用父类的构造器了 -------------------------------------------------------super和this用在构造器的话，前者表示调用父类的够早器，后者表示调用本类的其他构造器，他们两个都必须是写在构造器里的第一行public class Person { private String name; private int age; public Person() { name = ""; age = 0; } public Person(String n, int a) { name = n; age = a; } }public class Student extends Person { private String id;//学号 public Student(String name, int age) { super(name, age);//必须写在第一行，子类无法直接访问父类的私有属性，所以通过调用父类的构造器类初始化属性 } public Student(String id, String name, int age) { this(name, age);//因为本类已经有个构造器初始化name和age了，所以交给他来做就行了，也必须写在第一行 this.id = id; } }
this：只当前对象，可以喝super相对来说 例如： public class Shpe{ public void draw(){ System.out.println(draw ...); } } public class Circle extends Shape{ public void draw(){ System.out.println(draw Circle....); } public void test(){ super.draw();//调用父类的draw() this.draw();//调用自己的draw(); draw();//调用自己的draw(),因为在本类调用，默认 } } 希望对你有用。。加油
1. this是指当前对象自己。
当在一个类中要明确指出使用对象自己的的变量或函数时就应该加上this引用。如下面这个例子中: public class Hello { String s = "Hello"; public Hello(String s)
{
System.out.println("s = " + s);
System.out.println("1 -> this.s = " + this.s);
this.s = s;
System.out.println("2 -> this.s = " + this.s);
} public static void main(String[] args) {
Hello x="new" Hello("HelloWorld!");
}
} 运行结果： s = HelloWorld!
1 -> this.s = Hello
2 -> this.s = HelloWorld! 在这个例子中，构造函数Hello中，参数s与类Hello的变量s同名，这时如果直接对s进行操作则是对参数s进行操作。若要对类Hello的成员变量s进行操作就应该用this进行引用。运行结果的第一行就是直接对构造函数中传递过来的参数s进行打印结果； 第二行是对成员变量s的打印；第三行是先对成员变量s赋传过来的参数s值后再打印，所以结果是HelloWorld!2. 把this作为参数传递
当你要把自己作为参数传递给别的对象时，也可以用this。如： public class A {
public A() {
new B(this).print();
} public void print() {
System.out.println("Hello from A!");
}
} public class B {
A a;
public B(A a) {
this.a = a;
} public void print() {
a.print();
System.out.println("Hello from B!");
}
} 运行结果：
Hello from A!
Hello from B! 在这个例子中，对象A的构造函数中，用new B(this)把对象A自己作为参数传递给了对象B的构造函数。3. 注意匿名类和内部类中的中的this。
有时候，我们会用到一些内部类和匿名类，如事件处理。当在匿嘀杏胻his时，这个this则指的是匿名类或内部类本身。这时如果我们要使用外部类的方法和变量的话，则应该加上外部类的类名。如下面这个例子： public class A {
int i = 1; public A() {
Thread thread = new Thread() {
public void run() {
for(;;) {
A.this.run();
try {
sleep(1000);
} catch(InterruptedException ie) { }}
}
}; //注意这里有;
thread.start();
} public void run() {
System.out.println("i = " + i);
i++;
} public static void main(String[] args) throws Exception {
new A();
} } 在上面这个例子中, thread 是一个匿名类对象，在它的定义中，它的 run 函数里用到了外部类的 run 函数。这时由于函数同名，直接调用就不行了。这时有两种办法，一种就是把外部的 run 函数换一个名字，但这种办法对于一个开发到中途的应用来说是不可取的。那么就可以用这个例子中的办法用外部类的类名加上 this 引用来说明要调用的是外部类的方法 run。4。在构造函数中，通过this可以调用同一class中别的构造函数，如
public class Flower{
Flower (int petals){}
Flower(String ss){}
Flower(int petals, Sting ss){
//petals++;调用另一个构造函数的语句必须在最起始的位置
this(petals);
//this(ss);会产生错误，因为在一个构造函数中只能调用一个构造函数
}
} 值得注意的是：
1：在构造调用另一个构造函数，调用动作必须置于最起始的位置。
2：不能在构造函数以外的任何函数内调用构造函数。
3：在一个构造函数内只能调用一个构造函数。参考资料：http://blog.ednchina.com/Kaos_linyong/17694/message.aspx
1)在类的内部代表对象本身，你应该看到过this.xxx(),this.xxx这种用法吧，
this就代表这个类的对象，比如
public class A {
private String name;
public void setName(String name) {
//this就代表A的一个对象
//当你实例一个A时,A a1 = new A();this就是那个a1，只是this在内部用，而a1在外部用
//A a2 = new A()同理，这时在a2的内部，this就代表a2
this.name = name;
}
}2)this的第二种用法，是用在构造函数里的
当在构造器里要调用自己的其他构造器时，就用this
this必须放在第一行
public class A {
private String name;
public A() {
this("no name");
} public A(String name) {
this.name = name;
//other codes
}
}
super关键字
1)显式的调用父类的方法
当从一个类继承时，子类和父类都有一个同名方法，也就是子类覆盖了父类的方法，可是又想调用父类的方法，那么就要用super，像继承swing的类时就有个好例子
public class MyPanel extends JPanel {
@Override
public void paint(Graphics g) {
super.paint(g);//如果不用super，那么就会调用自己的paint方法
}
}2）用在构造器，和this的用法一样，super也可以用在构造器，this是调用自己的其他构造器，那么super当然就是调用父类的构造器了
-------------------------------------------------------super和this用在构造器的话，前者表示调用父类的够早器，后者表示调用本类的其他构造器，他们两个都必须是写在构造器里的第一行public class Person {
private String name;
private int age;
public Person() {
name = "";
age = 0;
} public Person(String n, int a) {
name = n;
age = a;
}
}public class Student extends Person {
private String id;//学号 public Student(String name, int age) {
super(name, age);//必须写在第一行，子类无法直接访问父类的私有属性，所以通过调用父类的构造器类初始化属性
} public Student(String id, String name, int age) {
this(name, age);//因为本类已经有个构造器初始化name和age了，所以交给他来做就行了，也必须写在第一行
this.id = id;
}
}
例如：
public class Shpe{
public void draw(){
System.out.println(draw ...);
}
}
public class Circle extends Shape{
public void draw(){
System.out.println(draw Circle....);
}
public void test(){
super.draw();//调用父类的draw()
this.draw();//调用自己的draw();
draw();//调用自己的draw(),因为在本类调用，默认
}
}
希望对你有用。。加油
应用一：引用成员变量public class Student{ //定义一个类，类的名字为student。
public Student(){ //定义 一个方法，名字与类相同故为构造方法
this(“luobo”)
}
public Student(String name){ //定义一个带形式参数的构造方法
}
}
如上面这个代码中，有一个成员变量name。同时在方法中有个形式参数，名字也是name。然 后再方法中将形式参数name的值传递给成员变量name。虽然我们可以看明白这个代码的含义，但是作为 Java编译器它是怎么判断的呢?到底是将形式参数name的值传递给成员变量name，还是反过来讲成员变量 name的值传递给形式参数name呢?也就是说，两个变量名字如果相同的话，那么Java如何判断使用哪个变 量?此时this这个关键字就起到作用了。This这个关键字其代表的就是对象中的成员变量或者方法。也就 是说，如果在某个变量前面加上一个this关键字，其指的就是这个对象的成员变量或者方法，而不是指成 员方法的形式参数或者局部变量。为此在上面这个代码中，this.name代表的就是对象中的成员变量，又 叫做对象的属性。而后面的name则是方法的形式参数。代码this.name=name就是将形式参数的值传递给成 员变量。这就是上面这个代码的具体含义。一般情况下，在Java语言中引用成员变量或者成员方法都是以对象名.成员变量或者对象名.成员 方法的形式。不过有些程序员即使在没有相同变量的时候，也喜欢使用this.成员变量的形式来引用变量 。这主要是从便于代码的阅读考虑的。一看到这个this关键字就知道现在引用的变量是成员变量或者成员 方法，而不是局部变量。这无形中就提高了代码的阅读性。不过话说回来，这是this关键字在Java语言中 的最简单的应用。从这个应用中，我们可以看出this关键字其代表的就是对象的名字。掌握这个基本的原 理之后，再了解后续的一些高级应用，也就是水到渠成的事情了。其实如果是局部变量的话，也是相同的道理。如在上面的代 码中，name不是形式参数，而是一个局部变量。此时Java也会遇到相同的疑惑，即变量名name代表的到底 是局部变量还是形式参数?name=name到底代表的是什么含义?根据局部变量的作用域，在方法内部，如果 局部变量与成员变量同名的话，那么是以局部变量为准。可是在name=name这个赋值语句中，将局部变量 的值赋值给自己，显然并不是很合适。根据代码的含义，本来的意思应该是将局部变量赋值给成员变量。 为了更清晰的表达这个含义，为此最好采用如下的书写格式：this.name=name。这里的this关键字含义就 是对象名student。为此this.name就表示student.name。这就转换为正规的成员变量应用了。应用二：调用类的构造方法在一个Java类中，其方法可以分为成员方法和构造方法两种。构造方法是一个与类同名的方法， 在Java类中必须存在一个构造方法。如果在代码中没有显示的体现构造方法的话，那么编译器在编译的时 候会自动添加一个没有形式参数的构造方法。这个构造方法跟普通的成员方法还是有很多不同的地方。如 构造方法的话一律是没有返回值的。而且也不用void关键字来说明这个构造方法没有返回值。而普通的方 法可以有返回值、也可以没有返回值，程序员可以根据自己的需要来定义。不过如果普通的方法没有返回 值的话，那么一定要在方法定义的时候采用void关键字来进行说明。其次构造方法的名字有严格的要求， 即必须与类的名字相同。也就是说，Java编译器发现有个方法与类的名字相同才把其当作构造方法来对待 。而对于普通方法的话，则要求不能够与类的名字相同，而且多个成员方法不能够采用相同的名字。在一 个类中可以存在多个构造方法，这些构造方法都采用相同的名字。只是形式参数不同。Java语言就凭用户 参数的参数来判断调用那个构造方法。
this关键字除了可以调用成员变量之外，还可以调用构造方 法。如下面的代码：public class Student{ //定义一个类，类的名字为student。
public Student(){ //定义一个方法，名字与类相同故为构造方法
this(“luobo”)
}
public Student(String name){ //定义一个带形式参数的构造方法
}
}
在上面这个代码中，笔者定义了两个构造方法，一个带参数，另一个没有带参数。构 造方法都不会有返回值，不过由于构造方法的特殊性，为此不必要在构造方法定义时带上void关键字来说 明这个问题。在第一个没有带参数的构造方法中，笔者使用了this(“luobo”)这个代码。这个代码表示 什么含义呢?在构造方法中使this关键字表示调用类中的构造方法。如果一个类中有多个构造方法，因为 其名字都相同，跟类名一致，那么这个this到底是调用哪个构造方法呢?其实，这跟采用其他方法引用构 造方法一样，都是通过形式参数来嗲用构造方法的。如上例中，this关键字后面加上了一个参数，那么就 表示其引用的是带参数的构造方法。如果现在有三个构造方法，分别为不带参数、带一个参数、带两个参 数。那么Java编译器会根据所传递的参数数量的不同，来判断该调用哪个构造方法。从上面这个示例中可 以看出，this关键字不仅可以用来引用成员变量，而且还可以用来引用构造方法。不过如果要使用这种方式来调用构造方法的话，有一个语法上的限制。一般来说，利用this关键 字来调用构造方法，只有在无参数构造方法中第一句使用this调用有参数的构造方法。否则的话，翻译的 时候，就会有错误信息。这跟引用成员变量不同。如果引用成员变量的话，this关键字是没有位置上的限 制的。如果不熟悉这个限制的话，那么还是老老实实的采用传统的构造方法调用方式为好。虽然比较麻烦 ，但是至少不会出错。应用三：返回对象的值this关键字除了可以引用变量或者成员方法之外，还有一个重大的作用就是返回类的饮用。如在 代码中，可以使用return this，来返回某个类的引用。此时这个this关键字就代表类的名称。如这个代 码在上面这个student类中，那么这个代码其代表的含义就是return student。可见，这个this关键字除 了可以引用变量或者成员方法之外，还可以做为类的返回值。这才是this关键字最引人注意的地方。在使用this关键字的时候，需要注意一个细节问题。在笔者谈到的第一个案例中，利用this关键 字来引用成员变量。即this.name=name。这个语句是将局部变量或则形式参数赋值给成员变量。其实，此 时这个this关键字不加也可以起到类似的效果。即上面这个语句中，与name=name这个语句时相同的。即 Java编译器会自动将第一个name当作成员变量来对待。而将等号右边的name变量当作形式参数。虽然这么 书写代码，可以节省this这几个字符的输入。但是对于代码的阅读是不利的。为此，从代码的阅读性考虑 ，如果成员变量与形式参数或者局部变量相同的话，那么最好是使用this.成员变量(成员方法)的方式来 引用成员变量。
...
}
笔误。。总之，这些还要靠自己慢慢理解就好了