In Java, 'this' is a keyword that is used to refer to the current object within a class or instance method. It can be used to reference instance variables, methods, and constructors of the current object.

When a method is called on an object, 'this' is implicitly passed as an argument to the method. This allows the method to access the object's instance variables and methods. For example, consider the following class:

public class Person {
    private String name;

    public Person(String name) {
        this.name = name;
    }

    public String getName() {
        return this.name;
    }
}

In the constructor of the Person class, 'this' is used to refer to the instance variable 'name', to distinguish it from the parameter 'name'. In the getName() method, 'this' is used to explicitly refer to the instance variable 'name'.

In addition to referencing instance variables and methods, 'this' can also be used to call one constructor from another constructor within the same class. This is known as constructor chaining. For example:

public class Person {
    private String name;
    private int age;

    public Person(String name) {
        this(name, 0);
    }

    public Person(String name, int age) {
        this.name = name;
        this.age = age;
    }
}

In this example, the first constructor calls the second constructor using 'this', passing in a default value of 0 for the 'age' parameter.

Overall, 'this' is a useful keyword in Java that allows for easy and unambiguous reference to the current object within a class or instance method.

‘this’ may be a reference variable that refers to the present object.
Following are the ways to use the ‘this’ keyword in java :

1. Using ‘this’ keyword to refer to current class instance variables

//Java code for using 'this' keyword to
//refer current class instance variables
class Test
{
	int a;
	int b;
	
	// Parameterized constructor
	Test(int a, int b)
	{
		this.a = a;
		this.b = b;
	}

	void display()
	{
		//Displaying value of variables a and b
		System.out.println("a = " + a + " b = " + b);
	}

	public static void main(String[] args)
	{
		Test object = new Test(10, 20);
		object.display();
	}
}

Output:

a = 10  b = 20

2. Using this() to invoke the current class constructor

JAVA

// Java code for using this() to
// invoke current class constructor
class Test
{
	int a;
	int b;

	//Default constructor
	Test()
	{
		this(10, 20);
		System.out.println("Inside default constructor \n");
	}
	
	//Parameterized constructor
	Test(int a, int b)
	{
		this.a = a;
		this.b = b;
		System.out.println("Inside parameterized constructor");
	}

	public static void main(String[] args)
	{
		Test object = new Test();
	}
}

Output:

Inside parameterized constructor
Inside  default constructor

3. Using ‘this’ keyword to return the current class instance

JAVA

//Java code for using 'this' keyword
//to return the current class instance
class Test
{
	int a;
	int b;

	//Default constructor
	Test()
	{
		a = 10;
		b = 20;
	}
	
	//Method that returns current class instance
	Test get()
	{
		return this;
	}
	
	//Displaying value of variables a and b
	void display()
	{
		System.out.println("a = " + a + " b = " + b);
	}

	public static void main(String[] args)
	{
		Test object = new Test();
		object.get().display();
	}
}

Output:

a = 10  b = 20

4. Using ‘this’ keyword as a method parameter

// Java code for using 'this'
// keyword as method parameter
class Test
{
	int a;
	int b;
	
	// Default constructor
	Test()
	{
		a = 10;
		b = 20;
	}
	
	// Method that receives 'this' keyword as parameter
	void display(Test obj)
	{
		System.out.println("a = " +obj.a + " b = " + obj.b);
	}

	// Method that returns current class instance
	void get()
	{
		display(this);
	}

	public static void main(String[] args)
	{
		Test object = new Test();
		object.get();
	}
}

Output:

a = 10  b = 20

5. Using ‘this’ keyword to invoke the current class method

// Java code for using this to invoke current
// class method
class Test {

	void display()
	{
		// calling function show()
		this.show();
	
	System.out.println("Inside display function");
	}
	
	void show() {
		System.out.println("Inside show funcion");
	}
	

	public static void main(String args[]) {
		Test t1 = new Test();
		t1.display();
	}
}

Output : 

Inside show funcion
Inside display function

6. Using ‘this’ keyword as an argument in the constructor call

// Java code for using this as an argument in constructor
// call
// Class with object of Class B as its data member
class A
{
	B obj;
	
	// Parameterized constructor with object of B
	// as a parameter
	A(B obj)
	{
		this.obj = obj;
		
	// calling display method of class B
		obj.display();
	}
	
}

class B
{
	int x = 5;
	
	// Default Constructor that create a object of A
	// with passing this as an argument in the
// constructor
	B()
	{
		A obj = new A(this);
	}
	
	// method to show value of x
	void display()
	{
		System.out.println("Value of x in Class B : " + x);
	}
	
	public static void main(String[] args) {
		B obj = new B();
	}
}

Output : 

Value of x in Class B : 5