Constructor Chaining in Java — this() and super()

Constructor chaining is the rule that every Java constructor must call either this() (a sibling constructor in the same class) or super() (the parent constructor) as its very first action. Write neither, and the compiler inserts super() automatically. This means every new Dog("Rex") silently triggers a chain all the way up to Object() before a single line of Dog's body executes.

`this()` — the DRY constructor:

• The telescoping pattern uses this() to build a hierarchy of constructors — the no-arg constructor delegates to the one-arg, which delegates to the full constructor where all the validation and defaults live
• Adding a new parameter later means touching only the full constructor — the shorter delegating constructors keep working automatically without any changes
• Every this() chain must eventually terminate in a constructor that calls super(); otherwise the parent would never be initialized

`super()` — the initialization requirement:

• The parent's fields must be fully set up before the child can safely use any inherited state — this is why the parent constructor always runs before the child's body
• When you omit super(), the compiler inserts super() automatically — if the parent has no no-arg constructor, you get a compile error on a line you never wrote, pointing at the child class, not the parent
• Write super(args) explicitly when the parent requires arguments; it documents the relationship and prevents surprises

Initialization order:

• Static initializer blocks run once when the class is first loaded, before any instance is created
• Then: parent instance initializers and parent constructor body execute fully
• Then: child instance initializers and child constructor body execute
• The gotcha interviewers test: if a parent constructor calls an overridden method, the child's override runs during parent construction — but the child's fields haven't been initialized yet, so they're at their zero defaults

I recommend this() telescoping to centralize defaults and validation, and switching to the Builder pattern when the number of constructor parameters exceeds four or five.