Java中的this关键字是对当前对象的引用。更清楚地说，当我们使用类的对象调用任何方法(或者创建对象时的构造函数)时，则此关键字是对用于调用该方法的对象的引用。

例如

public class MainClass implements MyInterface{	
  public static void main(String[] args) {
    MainClass obj = new MainClass();
    MainClass obj1 =  obj.showMessage("Hello");
    if(obj == obj1) {
      System.out.println("Both objects have the same reference");
    }
  }

  public MainClass showMessage(String msg) {		
    System.out.println("" + msg);
    return this;
  }
}

输出：

Hello
Both objects have the same reference

在使用类对象的示例中，调用了一个方法，并从该方法中返回" this"。由于" this"是对当前对象的引用，因此为什么在比较对象时引用的对象是相等的。

如何在Java中使用this关键字

Java中的this关键字可以在许多情况下使用。

• 解决实例和局部变量之间的名称空间冲突。参见示例。
• 在构造函数重载的情况下从另一个构造函数调用。参见示例。
• 调用任何方法。参见示例。
• 当必须传递对象时作为参数传递。参见示例。

使用它来访问实例变量

通常，对于构造函数，通常的做法是在构造函数中为局部变量赋予与实例变量相同的名称。在这种情况下，局部变量隐藏实例变量，并且在该构造函数的上下文中，局部变量优先于实例变量。由于这是对对象本身的引用，因此在这种情况下可以使用此关键字访问实例变量。

public class ConstructorDemo {
  int num;
  String name;
  // Parameterized constructor
  private ConstructorDemo(int num, String name){
    this.num = num;
    this.name = name;
  }
	
  // no-arg constructor
  private ConstructorDemo(){
    
  }

  public static void main(String[] args) {
    ConstructorDemo cd = new ConstructorDemo(10, "theitroad");
  }
}

在示例代码中可以看到，构造函数具有与实例变量同名的局部变量，并且此关键字用于解决冲突。

用它来调用重载的构造函数

在重载构造函数的情况下，可以使用此函数从另一个构造函数调用另一个构造函数，以便只有一个构造函数实际进行初始化。

public class ConstrChaining {
  int a;
  double b;
  String name;
  ConstrChaining(){
    this(0);
  }
  ConstrChaining(int a){
    this(a, 0.0);
  }
  ConstrChaining(int a, double b){
    this(a, b, null);
  }
  ConstrChaining(int a, double b, String name){
    this.a = a;
    this.b = b;
    this.name = name;
  }
  public static void main(String[] args) {
    ConstrChaining cc = new ConstrChaining();
    System.out.println("a- " + cc.a + " b- " + cc.b + " name- " + cc.name);
    
    ConstrChaining cc1 = new ConstrChaining(5, 7.8);
    System.out.println("a- " + cc1.a + " b- " + cc1.b + " name- " + cc1.name);
    
    ConstrChaining cc2 = new ConstrChaining(18, 13.45, "theitroad");
    System.out.println("a- " + cc2.a + " b- " + cc2.b + " name- " + cc2.name);
  }
}

在示例中，我们可以看到初始化最终是由以下构造函数完成的：

ConstrChaining(int a, double b, String name){
    this.a = a;
    this.b = b;
    this.name = name;
  }

所有其他构造函数都使用此关键字来形成一个链，以调用构造函数，最终完成初始化。

使用此关键字调用任何方法

由于这是对当前对象的引用，因此它也可以用于调用类的方法。

public class MainClass implements MyInterface{
  public static void main(String[] args) {
    MainClass obj = new MainClass();
    obj.showMessage("Hello");
  }
	
  public void showMessage(String msg) {		
    System.out.println("Message- " + msg);
    // calling method using this
    this.callThis();
  }
	
  public void callThis() {
    System.out.println("Method called using this..");
  }	
}

输出：

Message- Hello
Method called using this..

当必须传递对象时，可以将其作为参数传递

由于这是对当前对象的引用，因此我们可以将其作为需要传递对象的参数来传递。

public class MainClass implements MyInterface{
  public static void main(String[] args) {
    MainClass obj = new MainClass();
    obj.showMessage("Hello");	
  }
	
  public void showMessage(String msg) {		
    System.out.println("Message- " + msg);
    // passing this as an argument
    callThis(this);
  }
	
  public void callThis(MainClass obj) {
    System.out.println("this passed as an argument..");
  }	
}