this作为关键字我是知道，但是作为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。
有时候，我们会用到一些内部类和匿名类，如事件处理。这个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：在一个构造函数内只能调用一个构造函数。

一个类中有多个构造函数，如果一个构造函数想调用另外一个构造函数，此时可以使用this语句，例如：
class Test{

   private String name;
   private  int age;

    Test() {
        System.out.println("空参构造函数！");
    }

    Test(String name, int age) {
        this();
        System.out.println("有参构造函数！");
    }
}

　　举个例子：
　　public class persion{
　　private String name=null;
　　private int age;
　　public void setName(String name){
　　this.name=name;
　　}
　　public String getName(){
　　return name;
　　}
　　}
　　在这个类中setName方法中第一个变量用this是为了和本方法的参数this做区别，表示这个name指的是Person这个类的name属性，而不是name参数，如果去掉这个this，执行完这个方法后，Person类的name属性仍然为null。
　　getName方法返回的Person类的name，之所以不用this是因为没有必要，因为编译器会知道这个name就指的是Person的name而不是其他的name（因为找个方法没有name变量和它混淆）。当然，这个方法你也可以显示的使用return this.name，没错。
　　下面是必须详细说明this的三种使用方法：
　　package test;
　　public class ThisTest {
　　private int i=0;
　　//第一个构造器：有一个int型形参
　　ThisTest(int i){
　　this.i=i+1;//此时this表示引用成员变量ｉ，而非函数参数ｉ
　　System.out.println("Int constructor i——this.i:  "+i+"——"+this.i);
　　System.out.println("i-1:"+(i-1)+"this.i+1:"+(this.i+1));
　　//从两个输出结果充分证明了i和this.i是不一样的！
　　}
　　//  第二个构造器：有一个String型形参
　　ThisTest(String s){
　　System.out.println("String constructor:  "+s);
　　}
　　//  第三个构造器：有一个int型形参和一个String型形参
　　ThisTest(int i,String s){
　　this(s);//this调用第二个构造器
　　//this(i);
　　/*此处不能用，因为其他任何方法都不能调用构造器，只有构造方法能调用他。
　　但是必须注意：就算是构造方法调用构造器，也必须为于其第一行，构造方法也只能调
　　用一个且仅一次构造器！*/
　　this.i=i++;//this以引用该类的成员变量
　　System.out.println("Int constructor:  "+i+"\n"+"String constructor:  "+s);
　　}
　　public ThisTest increment(){
　　this.i++;
　　return this;//返回的是当前的对象，该对象属于（ThisTest）
　　}
　　public static void main(String[] args){
　　ThisTest tt0=new ThisTest(10);
　　ThisTest tt1=new ThisTest("ok");
　　ThisTest tt2=new ThisTest(20,"ok again!");
　　System.out.println(tt0.increment().increment().increment().i);
　　//tt0.increment()返回一个在tt0基础上ｉ++的ThisTest对象，
　　//接着又返回在上面返回的对象基础上i++的ThisTest对象！
　　}
　　}
　　运行结果：
　　Int constructor i——this.i:  10——11
　　String constructor:  ok
　　String constructor:  ok again!
　　Int constructor:  21
　　String constructor:  ok again!
　　14
　　细节问题注释已经写的比较清楚了，这里不在赘述，只是总结一下，其实this主要要三种用法：
　　１、表示对当前对象的引用！
　　２、表示用类的成员变量，而非函数参数，注意在函数参数和成员变量同名是进行区分！其实这是第一种用法的特例，比较常用，所以那出来强调一下。
　　３、用于在构造方法中引用满足指定参数类型的构造器（其实也就是构造方法）。但是这里必须非常注意：只能引用一个构造方法且必须位于开始！
　　还有就是注意：this不能用在static方法中！所以甚至有人给static方法的定义就是：没有this的方法！虽然夸张，但是却充分说明this不能在static方法中使用！
特别说明：由于各方面情况的不断调整与变化，爱孔子教育点评网所提供的所有教育行业相关信息仅供参考，敬请网友以权威部门公布的正式信息为准。

public class Test {
public static void main(String[] args) {
        Student p=new Student("小明");
        p.study();
}
}
class Student{
        private String name;
        public Student(String name) {
            this.name=name;     //this就是指的当前对象，你用谁，谁就是当前对象，比方说main方法中的p
        }                    //this.name中的name是上面声明的变量，而右边的name是传进来的参数，如：小明
        public void study(){
                System.out.println(name+"在学习");
        }
}
希望对你有帮助

this代表本类对象，代表所在函数所属对象的引用。
例如this.name=name等价于 p.name=name
另外，构造函数间的互相调用，只用this语句，且只能放在第一行。
如: Person(String name)
{
     this(name)
this.age=age;
}

this的用法汇总：
1.指代对象本身


this用于指代调用成员方法的当前对象自身。语法格式为  this


2.访问本类的成员变量很成员方法


使用this引用当前对象的成员变量，调用当前对象的成员方法
语法格式： this.成员变量    this.成员方法（【参数列表】）

例如MyDate类的equals()方法
  class MyDate{
。。。。。。。
。。。。。。。

            public   boolean equals(MyDate d){
                   return this==d||d!=null&&this.year==d.year&&this.month=d.month&&this.day=d.day;
              }
}
d比较调用当前方法的对象（由this应用）与参数的对象d引用的实例值是否相等，给出了this的前两种用法
一个成员方法中如果没有和成员变量同名的局部变量或是形式参数，则this可以省略。上边例子中的this.year等类似的可以简写为year;

3.调用本类重载的构造方法
this引用还可以用在重载的构造方法中，调用本类已经定义的构造方法，语法格式为   this（【参数列表】）

类如以MyDate 的构造方法为例：
     public  MyDate(int year,int month,int day)
{
         this.year=year;
        this. month=month;
         this.day=day;
}

                  public MyDate()
{
        this(1970,1,1);
}


注意在构造方法中。this（）必须是第一行，且不能用this调用当前的构造方法。

this代表本类对象，代表所在函数所属对象的引用。
this.name=name
就是将参数name赋值给成员变量，能够在类内使用
而this(参数)语句形式访问本类中的构造函数.必须放在构造函数内的第一句

韩军博 发表于 2011-12-6 13:21
this的用法汇总：
1.指代对象本身

理解了。。谢谢:P