this vs super Keyword in Java

In Java, this and super are both references to the same object in memory — they just give you access to different layers of it. this is the current class's view of the object; super reaches through to what the parent class defined. Knowing both their roles as references and their special constructor forms is essential because the constructor rules cause some of Java's most confusing compile errors.

`this` — current class reference:

• this.name is the classic use: disambiguating an instance field from a constructor or method parameter that has the same name — without it, name = name assigns the parameter to itself and the instance field stays at its default value
• this.method() explicitly invokes a method on the current object — occasionally used when calling interface default methods to pick between multiple defaults
• this(args) inside a constructor delegates to a sibling constructor in the same class — the telescoping pattern that avoids duplicating validation and default-value logic across multiple constructors

`super` — parent layer reference:

• super.method() calls the parent's version of a method the child has overridden — typically used when the child wants to extend rather than replace the parent's behavior, such as super.draw() followed by adding a highlight
• super.field accesses a parent field being hidden by a child field of the same name — note that field resolution uses reference type, unlike method dispatch
• super(args) initializes the parent from a child constructor and must be the first statement; if you omit it entirely, the compiler invisibly inserts super() — this causes a compile error on a line you never wrote when the parent has no no-arg constructor

The mutual exclusion rule:

• this() and super() cannot both appear in the same constructor — each constructor calls exactly one; the compiler inserts super() if you call neither
• A this() chain must eventually reach a constructor that calls super() — otherwise the parent would never be initialized

I recommend always writing super(args) explicitly when the parent requires constructor arguments — the invisible no-arg insertion is the source of one of Java's most misleading error messages.