Java Constructors Explained — How Objects Get Built from Scratch

// A simple BankAccount class that demonstrates the most basic constructor
public class BankAccount {

    // These are the fields — the data an account holds
    String accountHolder;
    double balance;
    String accountNumber;

    // This is the constructor — same name as the class, no return type
    // It runs automatically the moment someone writes: new BankAccount(...)
    public BankAccount(String holderName, String accNumber, double openingBalance) {
        accountHolder = holderName;       // Set the holder's name right away
        accountNumber = accNumber;        // Assign the account number
        balance = openingBalance;         // Start with the opening deposit

        System.out.println("Account created for: " + accountHolder);
        System.out.println("Account Number: " + accountNumber);
        System.out.println("Opening Balance: $" + balance);
        System.out.println("------------------------------");
    }

    public static void main(String[] args) {
        // Creating two BankAccount objects — constructor fires for each one
        BankAccount firstAccount = new BankAccount("Alice Johnson", "ACC-1001", 500.00);
        BankAccount secondAccount = new BankAccount("Bob Martinez", "ACC-1002", 1200.50);

        // Both objects are now fully initialized — no extra setup needed
        System.out.println(firstAccount.accountHolder + " has $" + firstAccount.balance);
        System.out.println(secondAccount.accountHolder + " has $" + secondAccount.balance);
    }
}

public class Laptop {

    String brand;
    String model;
    int ramGigabytes;
    double priceUSD;

    // 1. DEFAULT CONSTRUCTOR — no parameters, sensible starting state
    // Useful when you want to build up a Laptop piece by piece
    public Laptop() {
        brand = "Unknown";
        model = "Unknown";
        ramGigabytes = 8;       // A reasonable default — 8GB is standard
        priceUSD = 0.0;
        System.out.println("[Default Constructor] Generic laptop created.");
    }

    // 2. PARAMETERIZED CONSTRUCTOR — caller provides everything upfront
    // This is the most common pattern you'll write in real projects
    public Laptop(String brand, String model, int ramGigabytes, double priceUSD) {
        this.brand = brand;                   // 'this' distinguishes field from parameter
        this.model = model;
        this.ramGigabytes = ramGigabytes;
        this.priceUSD = priceUSD;
        System.out.println("[Parameterized Constructor] " + brand + " " + model + " created.");
    }

    // 3. COPY CONSTRUCTOR — creates an independent clone of an existing Laptop
    // Changing the copy won't affect the original — they're separate objects
    public Laptop(Laptop existingLaptop) {
        this.brand = existingLaptop.brand;
        this.model = existingLaptop.model;
        this.ramGigabytes = existingLaptop.ramGigabytes;
        this.priceUSD = existingLaptop.priceUSD;
        System.out.println("[Copy Constructor] Copied " + this.brand + " " + this.model + ".");
    }

    // Helper to display laptop info cleanly
    public void printDetails() {
        System.out.println("  Brand: " + brand + " | Model: " + model +
                           " | RAM: " + ramGigabytes + "GB | Price: $" + priceUSD);
    }

    public static void main(String[] args) {
        System.out.println("--- Using Default Constructor ---");
        Laptop genericLaptop = new Laptop();
        genericLaptop.printDetails();

        System.out.println();
        System.out.println("--- Using Parameterized Constructor ---");
        Laptop devLaptop = new Laptop("Dell", "XPS 15", 32, 1899.99);
        devLaptop.printDetails();

        System.out.println();
        System.out.println("--- Using Copy Constructor ---");
        Laptop backupLaptop = new Laptop(devLaptop);  // A brand new independent object
        backupLaptop.priceUSD = 1799.99;              // Modify the copy — original untouched
        System.out.println("  Original:");
        devLaptop.printDetails();
        System.out.println("  Copy (with different price):");
        backupLaptop.printDetails();
    }
}

public class Pizza {

    String size;         // "Small", "Medium", "Large"
    String crustType;    // "Thin", "Thick", "Stuffed"
    String topping;      // Main topping
    boolean isVegetarian;

    // MASTER CONSTRUCTOR — all the real initialization happens here
    // All other constructors will eventually call this one
    public Pizza(String size, String crustType, String topping, boolean isVegetarian) {
        this.size = size;
        this.crustType = crustType;
        this.topping = topping;
        this.isVegetarian = isVegetarian;
        System.out.println("Pizza initialized: " + size + " | " + crustType +
                           " crust | " + topping + " | Veg: " + isVegetarian);
    }

    // CONVENIENCE CONSTRUCTOR — caller just picks size and topping
    // Chains to the master constructor with sensible defaults
    public Pizza(String size, String topping) {
        this(size, "Thin", topping, false); // Calls the 4-arg constructor above
        System.out.println("(Used size+topping shortcut — defaulted to Thin crust, non-veg)");
    }

    // MINIMAL CONSTRUCTOR — caller just wants a plain default pizza
    // Chains to the 2-arg constructor, which chains to the master
    public Pizza() {
        this("Medium", "Margherita"); // Calls the 2-arg constructor above
        System.out.println("(Used no-arg shortcut — got a default Medium Margherita)");
    }

    public void describe() {
        System.out.println("Your pizza: " + size + " | " + crustType +
                           " crust | " + topping + " | Vegetarian: " + isVegetarian);
    }

    public static void main(String[] args) {
        System.out.println("=== Full custom pizza ===");
        Pizza customPizza = new Pizza("Large", "Stuffed", "BBQ Chicken", false);
        customPizza.describe();

        System.out.println();
        System.out.println("=== Size and topping only ===");
        Pizza quickPizza = new Pizza("Large", "Pepperoni");
        quickPizza.describe();

        System.out.println();
        System.out.println("=== Default pizza ===");
        Pizza defaultPizza = new Pizza();
        defaultPizza.describe();
    }
}

// Demonstrates the three most important constructor traps and their fixes
public class ConstructorGotchas {

    // ============================================================
    // GOTCHA 1: Adding a parameterized constructor kills the default one
    // ============================================================
    static class Vehicle {
        String type;
        int year;

        // As soon as we write this, Java's free no-arg constructor disappears
        public Vehicle(String type, int year) {
            this.type = type;
            this.year = year;
        }

        // FIX: explicitly provide the no-arg constructor if you still need it
        public Vehicle() {
            this("Unknown", 2024); // Chain to the parameterized one — DRY principle
        }
    }

    // ============================================================
    // GOTCHA 2: Constructors are NOT inherited by subclasses
    // ============================================================
    static class Animal {
        String name;

        public Animal(String name) {
            this.name = name;
            System.out.println("Animal constructor: name set to " + name);
        }
    }

    static class Dog extends Animal {
        String breed;

        // FIX: Dog must define its OWN constructor and explicitly call super()
        // Without this, Java would complain there's no no-arg Animal constructor
        public Dog(String name, String breed) {
            super(name);           // Must be first line — calls Animal's constructor
            this.breed = breed;
            System.out.println("Dog constructor: breed set to " + breed);
        }
    }

    // ============================================================
    // GOTCHA 3: Naming the constructor wrong (typo = it becomes a method)
    // ============================================================
    static class Counter {
        int count;

        // This looks like a constructor but the name is wrong — it's a method!
        // Java won't error. It just silently becomes a regular void method.
        // 'count' never gets initialized from here.
        // public counter() { this.count = 0; }  <-- WRONG — lowercase 'c'

        // CORRECT: constructor name must exactly match the class name, including case
        public Counter() {
            this.count = 0;
            System.out.println("Counter initialized to " + count);
        }
    }

    public static void main(String[] args) {
        System.out.println("--- Gotcha 1: Default constructor after adding parameterized ---");
        Vehicle car = new Vehicle("Sedan", 2022);   // Parameterized — works
        Vehicle emptyVehicle = new Vehicle();        // No-arg — also works because we fixed it
        System.out.println("Car type: " + car.type + ", Empty type: " + emptyVehicle.type);

        System.out.println();
        System.out.println("--- Gotcha 2: Inheritance and constructors ---");
        Dog myDog = new Dog("Rex", "German Shepherd"); // Both constructors fire in order
        System.out.println("Dog's name from Animal: " + myDog.name);

        System.out.println();
        System.out.println("--- Gotcha 3: Correct constructor naming ---");
        Counter visitCounter = new Counter();
        System.out.println("Visit count starts at: " + visitCounter.count);
    }
}