Mastering Java’s this Keyword: A Beginner’s Guide from Scratch

The keyword this refers to the current object—the instance whose method is being executed. It allows access to member variables that are hidden by method parameters and enables a constructor to call another constructor within the same class.

1. Using this with member variables

When a method parameter has the same name as a class field, the field is shadowed. Prefixing the field with this. resolves the ambiguity.

public class Point {
    public int num1 = 0;
    public int num2 = 0;
    public Point(int x, int y) {
        num1 = x;          // without this, assigns to the parameter
        num2 = y;
    }
}

The same class can be rewritten to explicitly use this:

public class Point {
    public int num1 = 0;
    public int num2 = 0;
    public Point(int num1, int num2) {
        this.num1 = num1; // this.num1 refers to the field
        this.num2 = num2;
    }
}

Thus, this.num1 and this.num2 access the class’s fields, while plain num1 and num2 refer to the constructor parameters.

2. Using this with constructors

A constructor can invoke another constructor of the same class using the syntax this([arguments]);. This promotes code reuse and ensures consistent initialization.

public class Rectangle {
    private int x1, y1;          // top‑left corner
    private int width, length;   // dimensions

    // Default constructor
    public Rectangle() {
        this(0, 0, 0, 0); // calls the 4‑argument constructor
    }

    // Two‑parameter constructor
    public Rectangle(int width, int length) {
        this(0, 0, width, length); // forwards to the 4‑argument version
    }

    // Four‑parameter constructor
    public Rectangle(int x1, int y1, int width, int length) {
        this.x1 = x1;
        this.y1 = y1;
        this.width = width;
        this.length = length;
    }
}

Each constructor ultimately delegates to the most detailed one, which assigns values to all fields. If a class lacks explicit initial values, the constructor supplies defaults (e.g., zeros for primitive types).

These examples demonstrate how this resolves naming conflicts and streamlines object initialization in Java’s object‑oriented design.