Java中的“this”是指当前对象本身的引用。

（我知道我迟到了，但是嘘，我正在偷偷摸摸地做事，你从未见过我）

在大多数面向对象编程语言中，如果不是全部，this关键字表示对该类当前对象实例的引用。这本质上与通过名称从方法外部调用该对象相同。也许这没有什么意义，所以我将详细说明：

在类的外部，为了调用该对象实例中的某些内容，例如说你有一个名为object的对象，你想获取一个字段，你需要使用：

object.field

举个例子，假设你想在类的构造函数中从内部访问object.field，你可以使用以下代码：

this.field

this关键字在类内部被调用时基本上替代了对象名称关键字。通常情况下，除非你有两个同名的变量，其中一个是类的字段，另一个只是方法内的变量，否则没有太多理由这样做，它有助于区分这两个变量。例如，如果你有这个：
（哈哈，明白了吗？this？嘿嘿...只有我吗？好吧:(我现在走了）

public String Name;
//Constructor for {object} class
public object(String Name){
    Name = Name;
}

这会导致一些问题，编译器无法区分在构造函数参数中定义的Name变量和类字段声明内部的Name变量，因此它会将Name参数分配给...... Name参数的值，这没有任何好处，也没有任何目的。这是大多数新程序普遍存在的问题，我也曾受其影响。无论如何，正确定义此参数的方法应该是使用：

public String Name;
//Constructor for {object} class
public object(String Name){
    this.Name = Name;
}

这样，编译器就知道你试图赋值的 Name 变量是类的一部分而不是方法的一部分，并正确地进行赋值，也就是将 Name 字段赋值为你在构造函数中输入的任何内容。

总之，它基本上引用了你正在处理的类的对象实例的字段，因此它是关键字 "this"，意味着它是这个对象或这个实例。使用这个关键字来调用你的类的字段是一个好习惯，而不仅仅使用名称，以避免可能难以找到的错误，因为编译器会直接跳过它们。

实例变量是您创建的每个对象都共有的。例如，有两个实例变量。

class ExpThisKeyWord{
int x;
int y;

public void setMyInstanceValues(int a, int b) {
    x= a;
    y=b;

    System.out.println("x is ="+x);
    System.out.println("y is ="+y);
}

}




class Demo{
public static void main(String[] args){

ExpThisKeyWord obj1 = new ExpThisKeyWord();
ExpThisKeyWord obj2 = new ExpThisKeyWord();
ExpThisKeyWord obj3 = new ExpThisKeyWord();

obj1.setMyInstanceValues(1, 2);
obj2.setMyInstanceValues(11, 22);
obj3.setMyInstanceValues(111, 222);



}
}

如果你注意到了上面的代码，我们初始化了三个对象，并且这三个对象都调用了SetMyInstanceValues方法。你认为JVM如何正确地为每个对象分配值呢？ 这里有一个技巧，JVM不会像上面展示的那样看待这段代码。相反，它会看作下面的代码：

public void setMyInstanceValues(int a, int b) {
    this.x= a; //Answer: this keyword denotes the current object that is handled by JVM.
    this.y=b;

    System.out.println("x is ="+x);
    System.out.println("y is ="+y);
}

一次快速的谷歌搜索带来了这个结果: 链接 基本上，“this”关键字是指当前对象(它本身)的引用。

this是对当前对象的引用：http://download.oracle.com/javase/tutorial/java/javaOO/thiskey.html

这可以在某些方法或构造函数内使用。

它返回当前对象的引用。

这指的是你当前所在的对象。换句话说，这指的是接收对象。你使用它来澄清你所指的变量。Java白皮书第37页

class Point extends Object
{
    public double x;
    public double y;

    Point()
    {
        x = 0.0;
        y = 0.0;
    }

    Point(double x, double y)
    {
        this.x = x;
        this.y = y;
    }
}

在上面的示例代码中，this.x/this.y 指的是当前类，即 Point 类的 x 和 y 变量，其中 (double x,double y) 是从不同的类传递的 double 值，用于为当前类赋值。

如果实例变量与构造函数中声明的变量相同，则使用“this”来分配数据。

class Example{
     int assign;// instance variable

     Example(int assign){ // variable inside constructor
          this.assign=assign;
     }
}

希望这能有所帮助。

我也在寻找同样的答案，但是一直无法清楚地理解这个概念。但最终我从这个link中理解了它。

this是Java中的一个关键字。它可以在类的方法或构造函数内部使用。它(this)作为对正在调用其方法或构造函数的当前对象的引用起作用。此关键字可用于从实例方法或构造函数中引用当前对象的任何成员。

请查看link中的示例，以便更清楚地理解。

在Java中，“this”是一个预定义变量。如果我们在方法中使用“this”，那么意味着我们正在获取当前运行对象的引用（地址）。例如：
this.age ---> 当前运行对象的年龄。

我想分享我从这个关键字中理解到的内容。在Java中，这个关键字有以下6种用法：
1. 它可以用来引用当前类变量。 让我们通过下面的代码来理解。
如果我们不使用这个关键字，让我们通过下面的例子来理解问题：

class Employee{  
int id_no;  
String name;  
float salary;  
Student(int id_no,String name,float salary){  
id_no = id_no;  
name=name;  
salary = salary;  
}  
void display(){System.out.println(id_no +" "+name+" "+ salary);}  
}  
class TestThis1{  
public static void main(String args[]){  
Employee s1=new Employee(111,"ankit",5000f);  
Employee s2=new Employee(112,"sumit",6000f);  
s1.display();  
s2.display();  
}}  

输出：-

0 null 0.0
0 null 0.0

在上面的例子中，参数（形式参数）和实例变量是相同的。因此，我们使用this关键字来区分局部变量和实例变量。

class Employee{  
int id_no;  
String name;  
float salary;  
Student(int id_no,String name,float salary){  
this.id_no = id_no;  
this.name=name;  
this.salary = salary;  
}  
void display(){System.out.println(id_no +" "+name+" "+ salary);}  
}  
class TestThis1{  
public static void main(String args[]){  
Employee s1=new Employee(111,"ankit",5000f);  
Employee s2=new Employee(112,"sumit",6000f);  
s1.display();  
s2.display();  
}} 

输出：

111 ankit 5000
112 sumit 6000

2. 调用当前类的方法。

class A{  
void m(){System.out.println("hello Mandy");}  
void n(){  
System.out.println("hello Natasha");  
//m();//same as this.m()  
this.m();  
}  
}  
class TestThis4{  
public static void main(String args[]){  
A a=new A();  
a.n();  
}}  

输出：

hello Natasha
hello Mandy

3. 调用当前类构造函数。它用于构造函数链。

class A{  
A(){System.out.println("hello ABCD");}  
A(int x){  
this();  
System.out.println(x);  
}  
}  
class TestThis5{  
public static void main(String args[]){  
A a=new A(10);  
}}

输出：

hello ABCD
10

4. 作为方法参数传递。

class S2{  
  void m(S2 obj){  
  System.out.println("The method is invoked");  
  }  
  void p(){  
  m(this);  
  }  
  public static void main(String args[]){  
  S2 s1 = new S2();  
  s1.p();  
  }  
}  

输出：

The method is invoked

5. 作为构造函数调用中的参数传递

class B{  
  A4 obj;  
  B(A4 obj){  
    this.obj=obj;  
  }  
  void display(){  
    System.out.println(obj.data);//using data member of A4 class  
  }  
}  

class A4{  
  int data=10;  
  A4(){  
   B b=new B(this);  
   b.display();  
  }  
  public static void main(String args[]){  
   A4 a=new A4();  
  }  
} 

输出：-

10

6. 返回当前类实例

class A{  
A getA(){  
return this;  
}  
void msg(){System.out.println("Hello");}  
}  
class Test1{  
public static void main(String args[]){  
new A().getA().msg();  
}  
}  

输出：

Hello

此外，如果没有使用.(点)符号，该关键字将无法使用，因为其语法无效。