Java Default Constructor: Automatic Creation and Behavior

// Shows when the compiler generates a default constructor and what it leaves behind.
public class DefaultConstructorDemo {
    private static final int ZERO = 0;
    private static final String NOT_SET = "NOT_SET";
    // NO CONSTRUCTOR DECLARED, so javac generates one with an empty body.
    // Because this class is public, the generated constructor is public too.
    public static class PlainSettings {
        int timeoutSeconds;
        // left at 0
        boolean enabled;
        // left at false
        String endpoint;
        // left at null
        int[] retries;
        // left at null, NOT an empty array
    } // ONE CONSTRUCTOR IS DECLARED, so nothing is generated.
    public static class SizedSettings {
        private final int size;
        public SizedSettings(int size) {
            if (size < ZERO) {
                throw new IllegalArgumentException("Size cannot be negative");
            } this.size = size;
        } public int getSize() {
            return size;
        }
    } // AN EXPLICIT NO-ARG CONSTRUCTOR KEEPS THE SIGNATURE BUT CHANGES THE BODY.
    // Nothing that already called new SecureConfig() stops compiling.
    public static class SecureConfig {
        private final String endpoint;
        public SecureConfig() {
            // A default constructor would have left endpoint as null
            this.endpoint = NOT_SET;
        } public SecureConfig(String endpoint) {
            if (endpoint == null || endpoint.isBlank()) {
                throw new IllegalArgumentException("Endpoint is required");
            } this.endpoint = endpoint;
        } public String getEndpoint() {
            return endpoint;
        }
    } // A PACKAGE-PRIVATE CLASS GETS A PACKAGE-PRIVATE DEFAULT CONSTRUCTOR
    static class PackagePrivate {
        int value;
    } // A PARENT WITH NO NO-ARG CONSTRUCTOR BREAKS A SUBCLASS THAT DECLARES NONE
    public static class Vehicle {
        private final String model;
        public Vehicle(String model) {
            this.model = model;
        } public String getModel() {
            return model;
        }
    } // So the subclass declares one and calls super explicitly
    public static class Car extends Vehicle {
        private final int doors;
        public Car(String model, int doors) {
            super(model);
            // required, since Vehicle has no no-arg one
            if (doors < ZERO) {
                throw new IllegalArgumentException("Doors cannot be negative");
            } this.doors = doors;
        } public int getDoors() {
            return doors;
        }
    } private static String describe(Object value) {
        if (value == null) {
            return "null";
        } return value.getClass().getSimpleName() + " = " + value;
    } public static void main(String[] args) {
        // GENERATED: this compiles only because no constructor is declared
        PlainSettings generated = new PlainSettings();
        System.out.println("timeoutSeconds: " + generated.timeoutSeconds);
        System.out.println("enabled:        " + generated.enabled);
        System.out.println("endpoint:       " + describe(generated.endpoint));
        System.out.println("retries array:  " + describe(generated.retries));
        // SUPPRESSED: SizedSettings declares a constructor, so new SizedSettings()
        // would not compile at all
        SizedSettings sized = new SizedSettings(64);
        System.out.println("size: " + sized.getSize());
        // THE SIGNATURE SURVIVES WHEN YOU WRITE IT YOURSELF
        SecureConfig safe = new SecureConfig();
        System.out.println("safe endpoint: " + safe.getEndpoint());
        System.out.println("real endpoint: " + new SecureConfig("https://api.example.com").getEndpoint());
        // ACCESS FOLLOWS THE CLASS MODIFIER
        PackagePrivate restricted = new PackagePrivate();
        restricted.value = 7;
        System.out.println("package-private value: " + restricted.value);
        // INHERITANCE STILL REQUIRES AN EXPLICIT super CALL
        Car car = new Car("Model S", 4);
        System.out.println(car.getModel() + " with " + car.getDoors() + " doors");
        try {
            new SecureConfig("");
        } catch (IllegalArgumentException problem) {
            System.out.println("rejected blank endpoint: " + problem.getMessage());
        } /*
            ACTUAL OUTPUT:

                timeoutSeconds: 0
                enabled:        false
                endpoint:       null
                retries array:  null
                size: 64
                safe endpoint: NOT_SET
                real endpoint: https://api.example.com
                package-private value: 7
                Model S with 4 doors
                rejected blank endpoint: Endpoint is required

            THE SEVEN THINGS TO REMEMBER
            1) GENERATION HAPPENS ONLY WHEN NO CONSTRUCTOR APPEARS in the
               source, not when no usable constructor exists. One private
               constructor is enough to suppress it.
            2) THE BODY IS A SINGLE super() CALL. It assigns nothing and
               validates nothing, so every field keeps the JVM default.
            3) DEFAULTS ARE ZERO, FALSE, AND NULL. A reference field is
               null, and an array field is null rather than empty, which
               is the most common surprise.
            4) ACCESS MATCHES THE CLASS. A package-private class gets a
               package-private constructor, so another package cannot call
               new on it until you write a public one.
            5) DECLARING ANY CONSTRUCTOR SUPPRESSES IT. That removes a
               signature other files depend on, and the resulting compile
               error points at code nobody edited.
            6) AN EXPLICIT NO-ARG CONSTRUCTOR IS SAFE TO ADD, because the
               signature survives and you gain control of the body.
            7) FINAL FIELDS REQUIRE AN EXPLICIT CONSTRUCTOR, because the
               generated empty body cannot satisfy the assignment rule.
        */
    }
}