Constructor Overloading in Java: Multiple Initialization Paths

// Constructor overloading with every overload delegating to one canonical path.
public class ConstructorOverloadingDemo {
    private static final String ROLE_GUEST = "GUEST";
    private static final String ROLE_ADMIN = "ADMIN";
    private static final boolean DEFAULT_ACTIVE = true;
    private static final int ZERO_COUNT = 0;
    private static final String TITLE_REPORT = "untitled";
    // STATE: every field is final, so the class is immutable
    public static class Session {
        private final String username;
        private final String role;
        private final boolean active;
        // NO-ARGUMENT: the most convenient starting point
        public Session() {
            this("anonymous", ROLE_GUEST, DEFAULT_ACTIVE);
        } // USERNAME ONLY
        public Session(String username) {
            this(username, ROLE_GUEST, DEFAULT_ACTIVE);
        } // USERNAME AND ROLE
        public Session(String username, String role) {
            this(username, role, DEFAULT_ACTIVE);
        } // THE CANONICAL CONSTRUCTOR: the only place fields are assigned
        public Session(String username, String role, boolean active) {
            if (username == null || username.isBlank()) {
                throw new IllegalArgumentException("Username is required");
            } if (!ROLE_GUEST.equals(role) && !ROLE_ADMIN.equals(role)) {
                throw new IllegalArgumentException("Unknown role: " + role);
            } this.username = username;
            this.role = role;
            this.active = active;
        } // COPY CONSTRUCTOR: an overload taking one argument of this type
        public Session(Session source) {
            if (source == null) {
                throw new IllegalArgumentException("Source cannot be null");
            } this.username = source.username;
            this.role = source.role;
            this.active = source.active;
        } public String getUsername() {
            return username;
        } public String getRole() {
            return role;
        } public boolean isActive() {
            return active;
        } @Override public String toString() {
            return username + " [role: " + role + ", active: " + active + "]";
        }
    } // AMBIGUITY: a null second argument matches only the landscape overload
    public static class Report {
        private final String title;
        private final boolean landscape;
        public Report(String title) {
            this(title, false);
        } public Report(String title, boolean landscape) {
            if (title == null || title.isBlank()) {
                throw new IllegalArgumentException("Title is required");
            } this.title = title;
            this.landscape = landscape;
        } @Override public String toString() {
            return "Report[" + title + ", landscape: " + landscape + "]";
        }
    } // VARARGS: matches any number of arguments, including none at all
    public static class Tag {
        private final String[] values;
        public Tag(String... values) {
            // a null array arrives as null, and no arguments arrive as empty
            if (values == null || values.length == ZERO_COUNT) {
                throw new IllegalArgumentException("At least one value is required");
            } // clone, so the caller cannot mutate our state through its array
            this.values = values.clone();
        } public int size() {
            return values.length;
        } @Override public String toString() {
            return "Tag" + java.util.Arrays.toString(values);
        }
    } // A STATIC FACTORY: the tool to reach for past a few overloads
    public static class Money {
        private final long amountInCents;
        private Money(long amountInCents) {
            if (amountInCents < ZERO_COUNT) {
                throw new IllegalArgumentException("Amount cannot be negative");
            } this.amountInCents = amountInCents;
        } public static Money ofCents(long amountInCents) {
            return new Money(amountInCents);
        } public static Money zero() {
            return new Money(ZERO_COUNT);
        } @Override public String toString() {
            return "Money[" + amountInCents + " cents]";
        }
    } public static void main(String[] args) {
        // FOUR WAYS TO REACH THE SAME VALID STATE
        Session anonymous = new Session();
        Session named = new Session("john_doe");
        Session elevated = new Session("admin_user", ROLE_ADMIN);
        Session explicit = new Session("john_doe", ROLE_GUEST, true);
        System.out.println(anonymous);
        System.out.println(named);
        System.out.println(elevated);
        System.out.println(explicit);
        // EVERY OVERLOAD PASSES THE SAME VALIDATION
        try {
            new Session("", ROLE_GUEST);
        } catch (IllegalArgumentException problem) {
            System.out.println("rejected blank username: " + problem.getMessage());
        } try {
            new Session("someone", "SUPERUSER");
        } catch (IllegalArgumentException problem) {
            System.out.println("rejected unknown role: " + problem.getMessage());
        } // THE COPY CONSTRUCTOR IS AN OVERLOAD LIKE ANY OTHER
        Session duplicate = new Session(elevated);
        System.out.println("copy equals source: " + duplicate.equals(elevated));
        System.out.println("copy is same object: " +(duplicate == elevated));
        System.out.println("copy: " + duplicate);
        // AMBIGUOUS CALLS AND HOW TO AVOID THEM
        System.out.println(new Report(TITLE_REPORT));
        System.out.println(new Report(TITLE_REPORT, true));
        System.out.println("a null boolean resolves: " + new Report(TITLE_REPORT,(Boolean) null));
        // VARARGS HANDLES ANY COUNT, INCLUDING NONE
        System.out.println(new Tag("java", "oop", "constructors"));
        try {
            new Tag();
        } catch (IllegalArgumentException problem) {
            System.out.println("rejected empty varargs: " + problem.getMessage());
        } // A STATIC FACTORY IS CLEARER PAST A FEW PARAMETERS
        System.out.println(Money.zero());
        System.out.println(Money.ofCents(2_499L));
        /*
            ACTUAL OUTPUT:

                anonymous [role: GUEST, active: true]
                john_doe [role: GUEST, active: true]
                admin_user [role: ADMIN, active: true]
                john_doe [role: GUEST, active: true]
                rejected blank username: Username is required
                rejected unknown role: Unknown role: SUPERUSER
                copy equals source: false
                copy is same object: false
                copy: admin_user [role: ADMIN, active: true]
                Report[untitled, landscape: false]
                Report[untitled, landscape: true]
                a null boolean resolves: Report[untitled, landscape: false]
                Tag[java, oop, constructors]
                rejected empty varargs: At least one value is required
                Money[0 cents]
                Money[2499 cents]

            THE SEVEN THINGS TO REMEMBER
            1) OVERLOADS DIFFER IN THE PARAMETER LIST, never by return type
               or access modifier, and never by name, since every
               constructor shares the class name.
            2) DELEGATE WITH this, DO NOT REPEAT. One canonical constructor
               owns the validation and the assignments, so every object
               satisfies the same invariants however it was created.
            3) DEFAULTS BELONG IN ONE PLACE. With delegation, adding an
               optional field means editing one constructor instead of
               every one of them.
            4) AMBIGUITY IS A COMPILE ERROR, not a silent choice. Passing
               null to a parameter that appears in several overloads is the
               usual cause, and a cast or a removed overload fixes it.
            5) RESOLUTION HAPPENS AT COMPILE TIME from the static argument
               types, so a short literal picks int over long without
               regard to what you would prefer.
            6) VARARGS MATCH ZERO ARGUMENTS TOO, handing you an empty array.
               Check the length, check for null, and clone before storing,
               or a caller can mutate your state through its own array.
            7) PAST ABOUT THREE PARAMETERS, SWITCH TOOLS. A static factory,
               a builder, or a record scales better than a growing pile of
               constructors most of which nobody calls.
        */
    }
}