Java super and this — Silent Failure from Missing super()

public class EmployeeConstructorChaining {

    public static void main(String[] args) {
        // Create an employee with all three fields specified
        Employee senior = new Employee("Priya Sharma", "Engineering", 95000);

        // Create an employee using the two-arg shortcut — salary defaults to 60000
        Employee junior = new Employee("Tom Okafor", "Marketing");

        // Create a bare-bones employee — only name provided
        Employee intern = new Employee("Lena Fischer");

        System.out.println(senior);
        System.out.println(junior);
        System.out.println(intern);
    }
}

class Employee {
    private String name;
    private String department;
    private double salary;

    // ── PRIMARY constructor — all three fields provided ──────────────────────
    public Employee(String name, String department, double salary) {
        // 'this.name' = the field on THIS object
        // bare 'name' = the constructor parameter
        // Without 'this.', you'd be assigning name = name (no-op) and the field stays null
        this.name = name;
        this.department = department;
        this.salary = salary;
    }

    // ── CONVENIENCE constructor — default salary ──────────────────────────────
    public Employee(String name, String department) {
        // this(...) MUST be the very first statement — delegates to the 3-arg constructor
        // This keeps all real initialization logic in ONE place
        this(name, department, 60_000.0);
    }

    // ── MINIMAL constructor — only name, rest use sensible defaults ───────────
    public Employee(String name) {
        this(name, "Unassigned"); // chains to the 2-arg constructor above
    }

    // 'this' used to pass the current object to an external method
    public void registerWithHR(HRSystem hrSystem) {
        hrSystem.register(this); // passing the current Employee instance
    }

    @Override
    public String toString() {
        return String.format("Employee{name='%s', dept='%s', salary=%.0f}",
                name, department, salary);
    }
}

class HRSystem {
    public void register(Employee employee) {
        System.out.println("Registering: " + employee);
    }
}

public class VehicleInheritanceDemo {

    public static void main(String[] args) {
        // Create a Car — watch how BOTH constructors fire in order
        Car tesla = new Car("Tesla Model 3", 2023, "Electric");
        tesla.describe();

        System.out.println("---");

        // Create an ElectricCar — three-level inheritance chain
        ElectricCar rivian = new ElectricCar("Rivian R1T", 2024, 314);
        rivian.describe();
        rivian.displayRange();
    }
}

// ── PARENT class — knows about every vehicle ─────────────────────────────────
class Vehicle {
    protected String modelName;  // 'protected' so child classes can access directly
    protected int year;

    public Vehicle(String modelName, int year) {
        this.modelName = modelName;
        this.year = year;
        System.out.println("Vehicle constructor ran for: " + modelName);
    }

    public void describe() {
        // Base-level description — child classes will extend this
        System.out.println(year + " " + modelName);
    }
}

// ── CHILD class — adds engine type on top of what Vehicle already knows ──────
class Car extends Vehicle {
    private String engineType;

    public Car(String modelName, int year, String engineType) {
        // super(...) MUST be first — initializes the Vehicle part of this object
        // If we skip this, Java tries super() with no args — Vehicle has none, compile error
        super(modelName, year);
        this.engineType = engineType; // then we initialize Car-specific state
        System.out.println("Car constructor ran, engine: " + engineType);
    }

    @Override
    public void describe() {
        super.describe();            // reuse the parent's output — don't duplicate it
        System.out.println("Engine type: " + engineType); // then add what Car knows
    }
}

// ── GRANDCHILD class — one more level deep ────────────────────────────────────
class ElectricCar extends Car {
    private int rangeInMiles;

    public ElectricCar(String modelName, int year, int rangeInMiles) {
        // Calls Car(String, int, String) — which in turn calls Vehicle(String, int)
        // The entire chain fires top-to-bottom automatically
        super(modelName, year, "Electric");
        this.rangeInMiles = rangeInMiles;
        System.out.println("ElectricCar constructor ran, range: " + rangeInMiles);
    }

    @Override
    public void describe() {
        super.describe(); // calls Car.describe(), which calls Vehicle.describe()
        System.out.println("Powered by: battery");
    }

    public void displayRange() {
        System.out.println("Range: " + rangeInMiles + " miles on a full charge");
    }
}

public class PaymentProcessorDemo {

    public static void main(String[] args) {
        System.out.println("=== Standard Payment ===");
        PaymentProcessor standard = new PaymentProcessor("Visa", 250.00);
        standard.processPayment();

        System.out.println();
        System.out.println("=== Fraud-Checked Payment ===");
        // FraudCheckedPayment EXTENDS the base process — adds a check, keeps the rest
        FraudCheckedPayment secured = new FraudCheckedPayment("Mastercard", 4500.00, "US");
        secured.processPayment();

        System.out.println();
        System.out.println("=== Crypto Payment (full override) ===");
        // CryptoPayment REPLACES the process entirely — calls super for logging only
        CryptoPayment crypto = new CryptoPayment("BTC", 0.05);
        crypto.processPayment();
    }
}

class PaymentProcessor {
    protected String paymentMethod;
    protected double amount;

    public PaymentProcessor(String paymentMethod, double amount) {
        this.paymentMethod = paymentMethod;
        this.amount = amount;
    }

    public void processPayment() {
        // Core logic every payment processor shares
        System.out.println("Processing " + paymentMethod + " payment of $" + amount);
        System.out.println("Contacting payment gateway...");
        System.out.println("Payment authorised.");
    }

    // A shared utility method child classes can call via super
    protected void logTransaction() {
        System.out.println("[LOG] " + paymentMethod + " $" + amount + " recorded.");
    }
}

// EXTENDS the base payment — adds fraud check BEFORE delegating to parent
class FraudCheckedPayment extends PaymentProcessor {
    private String originCountry;

    public FraudCheckedPayment(String paymentMethod, double amount, String originCountry) {
        super(paymentMethod, amount); // initialise the PaymentProcessor part
        this.originCountry = originCountry;
    }

    @Override
    public void processPayment() {
        // Do the extra work first, then let the parent handle the rest
        System.out.println("Running fraud check for origin: " + originCountry);
        if (amount > 3000 && !originCountry.equals("US")) {
            System.out.println("Flagged for manual review — payment held.");
            return; // short-circuit: don't proceed to parent logic
        }
        System.out.println("Fraud check passed.");
        super.processPayment(); // delegate standard processing to parent
    }
}

// REPLACES the base payment process entirely — only borrows logging
class CryptoPayment extends PaymentProcessor {
    public CryptoPayment(String cryptoCurrency, double coinAmount) {
        // We reuse the parent constructor to store values, but the process is custom
        super(cryptoCurrency, coinAmount);
    }

    @Override
    public void processPayment() {
        // Completely different logic — no call to super.processPayment()
        System.out.println("Broadcasting " + amount + " " + paymentMethod + " to blockchain...");
        System.out.println("Waiting for 3 confirmations...");
        System.out.println("Transaction confirmed on-chain.");
        super.logTransaction(); // but we DO reuse the parent's logging utility
    }
}

public class ConstructorRulesDemo {
    public static void main(String[] args) {
        // Demonstrate a correctly structured multi-level constructor chain
        Subscription basic = new Subscription("Alice");
        Subscription premium = new Subscription("Bob", "Premium");
        Subscription annual = new Subscription("Carol", "Premium", 12);

        System.out.println(basic);
        System.out.println(premium);
        System.out.println(annual);
    }
}

class Account {
    protected String ownerName;

    public Account(String ownerName) {
        this.ownerName = ownerName;
        System.out.println("Account created for: " + ownerName);
    }
}

class Subscription extends Account {
    private String tier;
    private int durationMonths;

    // ── MINIMAL constructor — chains to the 2-arg version via this() ──────────
    public Subscription(String ownerName) {
        this(ownerName, "Basic"); // this() must be first — chains downward
        // You cannot call super() here too — only one chain-start per constructor
    }

    // ── MID constructor — chains to the full 3-arg version ───────────────────
    public Subscription(String ownerName, String tier) {
        this(ownerName, tier, 1); // delegates again — still no super() here
    }

    // ── FULL constructor — this is the only one that calls super() ────────────
    public Subscription(String ownerName, String tier, int durationMonths) {
        super(ownerName); // super() is first here — Account gets initialized
        // Only NOW can we safely set Subscription-specific fields
        this.tier = tier;
        this.durationMonths = durationMonths;
    }

    @Override
    public String toString() {
        return String.format("Subscription{owner='%s', tier='%s', months=%d}",
                ownerName, tier, durationMonths);
    }

    // ── ILLUSTRATING: 'this' cannot be used in static methods ────────────────
    public static String getDefaultTier() {
        // return this.tier; // COMPILE ERROR: 'this' cannot be referenced from a static context
        return "Basic"; // correct — no 'this' in static methods
    }
}

interface Logger {
    default void log(String message) {
        System.out.println("[Default Logger]: " + message);
    }
}

interface TimestampLogger {
    default void log(String message) {
        System.out.println("[Timestamped]: " + java.time.Instant.now() + " " + message);
    }
}

// Class implements both — must override log() to resolve conflict
class ApplicationLogger implements Logger, TimestampLogger {
    @Override
    public void log(String message) {
        // We want to use the timestamped version
        TimestampLogger.super.log(message);
        // Optionally add more logic
        System.out.println("[Audit]: Logged at " + java.time.Instant.now());
    }
}

public class InterfaceSuperDemo {
    public static void main(String[] args) {
        ApplicationLogger appLog = new ApplicationLogger();
        appLog.log("System started");
    }
}

// io.thecodeforge — java tutorial

public class PaymentProcessor {
    private final String merchantId;
    private final String apiKey;

    // BAD: this escapes before constructor finishes
    public PaymentProcessor(String merchantId) {
        this.merchantId = merchantId;
        GlobalRegistry.register(this);  // other thread sees null apiKey!
        this.apiKey = loadApiKey(merchantId);
    }

    // SAFE: factory method
    public static PaymentProcessor createAndRegister(String merchantId) {
        PaymentProcessor p = new PaymentProcessor(merchantId);
        GlobalRegistry.register(p);  // object is fully built
        return p;
    }
}
// io.thecodeforge — java tutorial

// io.thecodeforge — java tutorial

class Account {
    protected String label = "Base Account";
    
    public String describe() {
        return "Label: " + label;
    }
}

class SavingsAccount extends Account {
    protected String label = "Savings";  // shadows parent! BAD.
    
    public void printLabels() {
        System.out.println(super.label);   // "Base Account"
        System.out.println(this.label);    // "Savings"
        System.out.println(describe());    // "Label: Base Account" — parent sees its own field
    }
}

public class FieldShadowing {
    public static void main(String[] args) {
        new SavingsAccount().printLabels();
    }
}

// io.thecodeforge — java tutorial

class Base {
    public String greet() { return "Hello from Base"; }
}

class Child extends Base {
    public void runAnonymous() {
        // Anonymous class — super refers to Object, not Base
        Runnable r = new Runnable() {
            public void run() {
                // System.out.println(super.greet());  // compile error! Object has no greet()
                System.out.println(Child.super.greet());  // works — "Hello from Base"
            }
        };
        r.run();
    }
    
    public void runLambda() {
        // Lambda — super refers to Base (enclosing class's super)
        Runnable r = () -> System.out.println(super.greet());
        r.run();  // "Hello from Base"
    }
}

public class AnonymousSuper {
    public static void main(String[] args) {
        new Child().runAnonymous();
        new Child().runLambda();
    }
}

// io.thecodeforge — java tutorial

public class BuilderExample {
    private String name;
    private int age;

    public BuilderExample setName(String name) {
        this.name = name; // disambiguates parameter from field
        return this;      // enables method chaining
    }

    public BuilderExample setAge(int age) {
        this.age = age;
        return this;
    }

    public void print() {
        System.out.println(name + " " + age);
    }

    public static void main(String[] args) {
        new BuilderExample().setName("Alice").setAge(30).print();
    }
}

// io.thecodeforge — java tutorial

class Parent {
    String msg = "Parent";
    Parent(String s) { System.out.println(s); }
}

class Child extends Parent {
    String msg = "Child";
    Child() {
        super("Calling parent"); // required: Parent has no no-arg
    }

    void show() {
        System.out.println(this.msg);  // Child
        System.out.println(super.msg); // Parent
    }

    public static void main(String[] args) {
        new Child().show();
    }
}