Chaining with this() and super()¶
☕ Java 17 · Building Objects the Right Way with Constructors · 2/3
Overloaded constructors often repeat the same code. Two calls let a constructor delegate the work.
Reusing a constructor with this()¶
public Movie(String t) {
Movie(t, 90); // ❌ a constructor can't be called by name
new Movie(t, 90); // ⚠️ compiles, but builds a second, wasted object
}
public Movie(String t) {
this(t, 90); // ✅ runs Movie(String, int) on THIS object
}
Don't confuse this (the current object) with this() (a call to another constructor of the same class).
The rules of this()¶
1: public class Episode {
2: Episode(int n, String t) { }
3: Episode(int n) {
4: System.out.println("new episode");
5: this(n, "Untitled"); // ❌ not the first statement
6: }
7: Episode() { this("Pilot"); }
8: Episode(String t) { this(); } // ❌ 7 and 8 call each other forever
9: }
- First statement: nothing may run before it (a comment is fine).
- Only once: being first, it can't appear twice.
- No cycles: constructors can't end up calling each other in a loop.
Building the parent first with super()¶
Every constructor starts by calling either this(…) or a parent constructor with super(…):
public class Content {
String title;
public Content(String t) { title = t; }
}
public class Movie extends Content {
public Movie(String t) { super(t); } // the Content part is built first
}
new Movie("Dune") → Movie(String) → Content(String) → Object(). The parent part of the object is always built before the child's.
super() follows the same rules as this(): first statement, once, and a constructor can't call both.
The hidden super()¶
A constructor that doesn't start with this(…) or super(…) gets super(); added by the compiler. These three classes are identical:
public class Clip { }
public class Clip { public Clip() { } }
public class Clip { public Clip() { super(); } }
When the parent needs arguments¶
The hidden super() can fail:
class Content {
Content(String t) { }
}
class Movie extends Content { } // ❌ default constructor calls super(): no match
class Series extends Content { Series() { } } // ❌ same hidden super()
class Trailer extends Content {
Trailer() { super("Untitled"); } // ✅ passes what the parent needs
}
If the parent has no no-argument constructor, every child constructor must call super(…) with arguments, or this(…). And super(…) always targets the direct parent only.
The lab chains this() and super() and prints each step, so you can watch the order.