Constructor Chaining in Java: Using this() and super

// Shows same-class chaining with this(), parent chaining with super(),
// and the fixed order in which every level actually executes.
public class ConstructorChainingDemo {
    private static final String DEFAULT_ROLE = "guest";
    private static final boolean DEFAULT_ACTIVE = true;
    private static final String SQUARE_NAME = "square";
    private static final double DEFAULT_SIDE = 10.0;
    private static final String REPORT_TITLE = "report";
    private static final int DOOR_COUNT = 4;
    // LEVEL ONE, the base of the hierarchy
    public static class Shape {
        private final String name;
        public Shape(String name) {
            this.name = name;
            System.out.println("  Shape built: " + name);
        } public String getName() {
            return name;
        }
    } // LEVEL TWO, chains upward with super(), then chains sideways with this()
    public static class Square extends Shape {
        private final double side;
        // THE CANONICAL CONSTRUCTOR
        public Square(String name, double side) {
            super(name);
            // runs before anything below
            this.side = side;
            System.out.println("  Square built: side " + side);
        } public Square(String name) {
            this(name, DEFAULT_SIDE);
            // same-class delegation
        } public double getSide() {
            return side;
        }
    } // A PARENT WHOSE CONSTRUCTOR CALLS AN OVERRIDDEN METHOD,
    // which is legal and is exactly the trap this example demonstrates
    public static class Vehicle {
        private final String label;
        public Vehicle(String label) {
            this.label = label;
            describe();
            // dispatches to Car before Car is ready
        } protected void describe() {
            System.out.println("  Vehicle describes " + label);
        } public String getLabel() {
            return label;
        }
    } public static class Car extends Vehicle {
        // This initialiser has NOT run when the parent calls describe()
        private final int doors = DOOR_COUNT;
        private final boolean assembled;
        public Car(String label) {
            super(label);
            this.assembled = true;
        } @Override protected void describe() {
            // assembled is still false and doors reads as 0 at this point
            System.out.println("  Car describes " + getLabel() + " doors=" + doors + " assembled=" + assembled);
        }
    } // THIS() AND SUPER() CANNOT SHARE A CONSTRUCTOR,
    // so the sibling target supplies the super() call for us
    public static class Document {
        private String title;
        public Document(String title) {
            this.title = title;
            System.out.println("  Document built: " + title);
        } public String getTitle() {
            return title;
        }
    } public static class Report extends Document {
        private String author;
        public Report(String title, String author) {
            this(author);
            // first, so super is delegated
            System.out.println("  Report author set: " + this.author);
        } public Report(String author) {
            super(REPORT_TITLE);
            // the parent call happens here
            setAuthor(author);
        } public void setAuthor(String author) {
            this.author = author;
        } public String getAuthor() {
            return author;
        }
    } public static void main(String[] args) {
        // EXECUTION ORDER, printed by each constructor as it runs
        System.out.println("1) three level chain");
        Square square = new Square(SQUARE_NAME);
        System.out.println("   name: " + square.getName() + "  side: " + square.getSide());
        System.out.println();
        System.out.println("2) an override called from the parent constructor");
        Car car = new Car("minibus");
        System.out.println("   the same override, now that Car is ready:");
        car.describe();
        System.out.println();
        System.out.println("3) this() in one constructor, super() in another");
        Report report = new Report("Q3", "Ada");
        System.out.println("   title:  " + report.getTitle());
        System.out.println("   author: " + report.getAuthor());
        System.out.println();
        System.out.println("4) defaults live in the canonical constructor only");
        System.out.println("   role:   " + DEFAULT_ROLE);
        System.out.println("   active: " + DEFAULT_ACTIVE);
        /*
            ACTUAL OUTPUT:

                1) three level chain
                  Shape built: square
                  Square built: side 10.0
                   name: square  side: 10.0

                2) an override called from the parent constructor
                  Car describes minibus doors=0 assembled=false
                  Vehicle built: minibus
                   the same override, now that Car is ready:
                  Car describes minibus doors=4 assembled=true

                3) this() in one constructor, super() in another
                  Document built: report
                  Report author set: Ada
                   title:  report
                   author: Ada

                4) defaults live in the canonical constructor only
                   role:   guest
                   active: true

            THE FIVE RULES THAT MATTER MOST
            1) this(...) AND super(...) MUST EACH BE THE FIRST STATEMENT,
               so a single constructor may contain only one of them. Use a
               helper method when the work does not fit before the call.
            2) THE PARENT ALWAYS COMPLETES FIRST. No arrangement of the
               source can make a subclass body run before the parent
               constructor body has finished.
            3) super(...) RUNS A WHOLE CONSTRUCTOR, not just an
               assignment, so an entire chain of ancestors may execute
               before your first statement.
            4) OMITTING BOTH IS FINE, since the compiler inserts an
               implicit super(). It fails at compile time only if the
               parent has no no-argument constructor.
            5) A METHOD CALLED FROM A CONSTRUCTOR DISPATCHES TO THE
               OVERRIDE, which is why step 2 prints doors=0. Initialise
               from a factory method when that early call is needed.

            THE FIVE PHASES, IN ORDER
            MEMORY IS ALLOCATED AND FIELDS TAKE TYPE DEFAULTS.
            THE SUPER CALL IS SATISFIED, ENTERING THE PARENT.
            PARENT FIELD INITIALISERS RUN, THEN THE PARENT BODY.
            SUBCLASS FIELD INITIALISERS RUN.
            THE SUBCLASS CONSTRUCTOR BODY RUNS.
        */
    }
}