Java Constructors: Object Initialization, Types, and Rules

// Every rule about constructors, demonstrated in one compilable program.
public class ConstructorsDemo {
    private static final long ZERO = 0L;
    private static final double ZERO_DOUBLE = 0.0;
    private static final String UNSET = "UNSET";
    // THE DEFAULT CONSTRUCTOR IS COMPILER GENERATED, so it only exists
    // in the Stages class below, which declares no constructor at all.
    // A CONSTRUCTOR IS NOT A METHOD: no return type, name matches the class
    public static class Product {
        private final String code;
        private final long priceInCents;
        // NO-ARGUMENT, delegating to the parameterized constructor
        public Product() {
            this(UNSET, ZERO);
        } // PARAMETERIZED, the single place the fields are assigned
        public Product(String code, long priceInCents) {
            if (code == null || code.isBlank()) {
                throw new IllegalArgumentException("Code is required");
            } if (priceInCents < ZERO) {
                throw new IllegalArgumentException("Price cannot be negative");
            } this.code = code;
            this.priceInCents = priceInCents;
        } // COPY CONSTRUCTOR, one argument of the same type
        public Product(Product source) {
            this(source.code, source.priceInCents);
        } // THIS IS A METHOD, not a constructor, and nothing will call it
        public void Product(String ignored) {
            throw new UnsupportedOperationException("Not a constructor");
        } public String getCode() {
            return code;
        } public long getPriceInCents() {
            return priceInCents;
        } @Override public String toString() {
            return "Product[" + code + " @ " + priceInCents + "]";
        }
    } // CONSTRUCTORS ARE NOT INHERITED, so this declares its own
    public static class PhysicalProduct extends Product {
        private final double weightInKg;
        // super() would be inserted automatically here
        public PhysicalProduct() {
            this(UNSET, ZERO, ZERO_DOUBLE);
        } public PhysicalProduct(String code, long priceInCents, double weightInKg) {
            // super MUST be the first statement, and is never optional here
            super(code, priceInCents);
            if (weightInKg < ZERO) {
                throw new IllegalArgumentException("Weight cannot be negative");
            } this.weightInKg = weightInKg;
        } public double getWeightInKg() {
            return weightInKg;
        }
    } // NO CONSTRUCTOR IS DECLARED, so the compiler generates the default one.
    // That default constructor disappears the moment you declare your own.
    public static class Stages {
        private final String name;
        public String getName() {
            return name;
        } // PROVES THE DEFAULT CONSTRUCTOR EXISTS FOR THIS CLASS ONLY
        public static Stages createDefault() {
            return new Stages();
        }
    } // BLOCKS RUN BEFORE THE CONSTRUCTOR BODY, so ordering matters
    public static class Widget {
        private static int instancesCreated;
        private final int size;
        private final String log;
        static {
            instancesCreated = 0;
        } {
            // size is still 0 here, because field assignment happens after
            log = "block saw size " + size;
        } public Widget(int size) {
            if (size <= ZERO) {
                throw new IllegalArgumentException("Size must be positive");
            } this.size = size;
            instancesCreated++;
        } public int getSize() {
            return size;
        } public String getLog() {
            return log;
        } public static int getInstancesCreated() {
            return instancesCreated;
        }
    } // A FINAL FIELD MUST BE ASSIGNED IN EVERY CONSTRUCTOR THAT DOES NOT CHAIN
    public static class Session {
        private final String userId;
        private final long createdAtMillis;
        public Session(String userId) {
            if (userId == null || userId.isBlank()) {
                throw new IllegalArgumentException("User id is required");
            } this.userId = userId;
            this.createdAtMillis = System.currentTimeMillis();
        } public String getUserId() {
            return userId;
        }
    } public static void main(String[] args) {
        // THE FOUR WAYS TO CONSTRUCT
        Product viaNoArg = new Product();
        Product viaArgs = new Product("LAPTOP-01", 129_999L);
        Product viaCopy = new Product(viaArgs);
        System.out.println(viaNoArg);
        System.out.println(viaArgs);
        System.out.println("copy equals source: " + viaCopy.getCode().equals(viaArgs.getCode()));
        // SUPERCLASS CONSTRUCTION ALWAYS COMPLETES FIRST
        PhysicalProduct laptop = new PhysicalProduct("PHYS-01", 199_999L, 2.5);
        System.out.println(laptop + " weighing " + laptop.getWeightInKg() + " kg");
        // THE DEFAULT CONSTRUCTOR
        Stages defaultBuilt = Stages.createDefault();
        System.out.println("default constructed name is: " + defaultBuilt.getName());
        // BLOCKS RUN BEFORE THE CONSTRUCTOR BODY
        Widget widget = new Widget(42);
        System.out.println(widget.getLog());
        System.out.println("widget size is " + widget.getSize());
        System.out.println("instances created: " + Widget.getInstancesCreated());
        Session session = new Session("user-9001");
        System.out.println("session for " + session.getUserId());
        /*
            ACTUAL OUTPUT:

                Product[UNSET @ 0]
                Product[LAPTOP-01 @ 129999]
                copy equals source: true
                Product[PHYS-01 @ 199999] weighing 2.5 kg
                default constructed name is: null
                block saw size 0
                widget size is 42
                instances created: 1
                session for user-9001

            THE NINE RULES TO REMEMBER
            1) A CONSTRUCTOR HAS NO RETURN TYPE. Not void, not anything.
               A member named like the class with no return type is a
               constructor, so adding void turns it into a dead method and
               the class quietly loses that constructor.
            2) THE NAME MUST MATCH THE CLASS EXACTLY, and it is
               case-sensitive, because there is no keyword to mark it.
            3) STATIC, FINAL, ABSTRACT, AND SYNCHRONIZED ARE ALL ILLEGAL.
               A constructor belongs to one object being created, is never
               inherited, and has nothing to override.
            4) THERE ARE FOUR TYPES. The default constructor is generated by
               the compiler, a no-argument one is written by you, a
               parameterized one takes arguments, and a copy constructor
               takes a single argument of the same type.
            5) DECLARING ANY CONSTRUCTOR REMOVES THE DEFAULT ONE, which
               breaks new ClassName() in some other file that never
               mentioned your change.
            6) EXECUTION ORDER IS FIXED. Memory, then static init, then
               instance init in textual order, then the superclass body,
               then this constructor body.
            7) THIS AND SUPER MUST BE THE FIRST STATEMENT, and you may use
               only one of them per constructor.
            8) CONSTRUCTORS ARE NOT INHERITED. Every class declares its
               own, and if the parent has no no-argument constructor you
               must call super explicitly or fail to compile.
            9) FINAL FIELDS MUST BE ASSIGNED, and chaining through this
               means only the constructor that reaches its own body needs
               to do the assigning.
        */
    }
}