Java Inheritance — Parent Method Change Broke 30 Classes

// A realistic banking example showing why inheritance saves us from duplication

// PARENT CLASS — defines everything ALL bank accounts share
class BankAccount {
    private String accountHolder;  // private: only accessible within this class
    protected double balance;      // protected: accessible to subclasses

    public BankAccount(String accountHolder, double initialBalance) {
        this.accountHolder = accountHolder;
        this.balance = initialBalance;
    }

    // Every account type can deposit money — logic lives here ONCE
    public void deposit(double amount) {
        if (amount <= 0) {
            System.out.println("Deposit amount must be positive.");
            return;
        }
        balance += amount;
        System.out.println(accountHolder + " deposited $" + amount + ". New balance: $" + balance);
    }

    public double getBalance() {
        return balance;
    }

    public String getAccountHolder() {
        return accountHolder;
    }

    public void printSummary() {
        System.out.println("Account: " + accountHolder + " | Balance: $" + balance);
    }
}

// CHILD CLASS — inherits everything from BankAccount, adds its own rules
class SavingsAccount extends BankAccount {
    private double interestRate;  // unique to SavingsAccount

    public SavingsAccount(String accountHolder, double initialBalance, double interestRate) {
        // super() calls the PARENT constructor — must be the first line
        super(accountHolder, initialBalance);
        this.interestRate = interestRate;
    }

    // Behaviour unique to savings accounts — the parent has no concept of this
    public void applyMonthlyInterest() {
        double interest = balance * interestRate;
        balance += interest;  // 'balance' is accessible because it's protected in parent
        System.out.println("Interest of $" + String.format("%.2f", interest) + " applied. New balance: $" + String.format("%.2f", balance));
    }
}

// ANOTHER CHILD CLASS — same parent, different specialisation
class CheckingAccount extends BankAccount {
    private double overdraftLimit;

    public CheckingAccount(String accountHolder, double initialBalance, double overdraftLimit) {
        super(accountHolder, initialBalance);
        this.overdraftLimit = overdraftLimit;
    }

    // Checking accounts allow withdrawal up to the overdraft limit
    public void withdraw(double amount) {
        if (amount > balance + overdraftLimit) {
            System.out.println("Withdrawal denied: exceeds overdraft limit.");
        } else {
            balance -= amount;
            System.out.println(getAccountHolder() + " withdrew $" + amount + ". Balance: $" + String.format("%.2f", balance));
        }
    }
}

public class BankAccountDemo {
    public static void main(String[] args) {
        SavingsAccount savings = new SavingsAccount("Alice", 1000.00, 0.03);
        savings.deposit(500.00);         // inherited from BankAccount — no duplication
        savings.applyMonthlyInterest();  // unique to SavingsAccount
        savings.printSummary();          // inherited from BankAccount

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

        CheckingAccount checking = new CheckingAccount("Bob", 200.00, 150.00);
        checking.deposit(100.00);        // same deposit() method, reused via inheritance
        checking.withdraw(400.00);       // unique to CheckingAccount
        checking.printSummary();         // inherited from BankAccount
    }
}

// Single inheritance
class Animal {
    void breathe() { System.out.println("Breathing..."); }
}
class Dog extends Animal {
    void bark() { System.out.println("Woof!"); }
}

// Multilevel inheritance
class Mammal extends Animal {
    void feedMilk() { System.out.println("Feeding milk"); }
}
class Human extends Mammal {
    void speak() { System.out.println("Hello"); }
}

// Hierarchical inheritance
class Vehicle {
    void move() { System.out.println("Moving..."); }
}
class Car extends Vehicle {
    void honk() { System.out.println("Beep!"); }
}
class Bike extends Vehicle {
    void ringBell() { System.out.println("Ring!"); }
}

// Sealed interface — only Circle, Rectangle, Triangle can implement it
sealed interface Shape permits Circle, Rectangle, Triangle {}

final class Circle implements Shape {
    double radius;
    Circle(double radius) { this.radius = radius; }
}

final class Rectangle implements Shape {
    double width, height;
    Rectangle(double width, double height) { this.width = width; this.height = height; }
}

final class Triangle implements Shape {
    double base, height;
    Triangle(double base, double height) { this.base = base; this.height = height; }
}

public class ShapeProcessor {
    public double calculateArea(Shape shape) {
        // Pattern matching switch — compiler warns if any permitted type is missing
        return switch (shape) {
            case Circle c -> Math.PI * c.radius * c.radius;
            case Rectangle r -> r.width * r.height;
            case Triangle t -> 0.5 * t.base * t.height;
        };
    }

    public static void main(String[] args) {
        ShapeProcessor sp = new ShapeProcessor();
        Shape circle = new Circle(5);
        System.out.println("Circle area: " + sp.calculateArea(circle));

        Shape rect = new Rectangle(4, 6);
        System.out.println("Rectangle area: " + sp.calculateArea(rect));
    }
}

// Real-world example: a shipping system where each carrier calculates cost differently

class ShippingCarrier {
    protected String carrierName;
    protected double baseRatePerKg;

    public ShippingCarrier(String carrierName, double baseRatePerKg) {
        this.carrierName = carrierName;
        this.baseRatePerKg = baseRatePerKg;
    }

    // Default shipping cost — child classes will override this
    public double calculateShippingCost(double weightKg, double distanceKm) {
        return baseRatePerKg * weightKg;
    }

    public void printQuote(double weightKg, double distanceKm) {
        // Calls calculateShippingCost() — at runtime, Java runs the CHILD's version
        // if this object is actually a child instance (dynamic dispatch in action)
        double cost = calculateShippingCost(weightKg, distanceKm);
        System.out.println(carrierName + " quote: $" + String.format("%.2f", cost));
    }
}

class ExpressCarrier extends ShippingCarrier {
    private double expressMultiplier;

    public ExpressCarrier(String carrierName, double baseRatePerKg, double expressMultiplier) {
        super(carrierName, baseRatePerKg);
        this.expressMultiplier = expressMultiplier;
    }

    @Override  // Always use this — protects you from typo bugs
    public double calculateShippingCost(double weightKg, double distanceKm) {
        // Call the parent's calculation first, then add the express premium
        double baseCost = super.calculateShippingCost(weightKg, distanceKm);
        return baseCost * expressMultiplier;
    }
}

class FreightCarrier extends ShippingCarrier {
    private double costPerKm;

    public FreightCarrier(String carrierName, double baseRatePerKg, double costPerKm) {
        super(carrierName, baseRatePerKg);
        this.costPerKm = costPerKm;
    }

    @Override
    public double calculateShippingCost(double weightKg, double distanceKm) {
        // Freight pricing is completely different — weight AND distance matter
        double weightCost = baseRatePerKg * weightKg;
        double distanceCost = costPerKm * distanceKm;
        return weightCost + distanceCost;
    }
}

public class ShippingCalculatorDemo {
    public static void main(String[] args) {
        double packageWeight = 5.0;   // kg
        double shippingDistance = 200; // km

        // Declared as ShippingCarrier, but each object is a different subtype
        // printQuote() calls the CORRECT calculateShippingCost() for each — that's polymorphism
        ShippingCarrier standardCarrier = new ShippingCarrier("PostCo Standard", 2.50);
        ShippingCarrier expressCarrier  = new ExpressCarrier("QuickShip Express", 2.50, 2.0);
        ShippingCarrier freightCarrier  = new FreightCarrier("HeavyHaul Freight", 1.80, 0.05);

        standardCarrier.printQuote(packageWeight, shippingDistance);
        expressCarrier.printQuote(packageWeight, shippingDistance);  // runs ExpressCarrier's override
        freightCarrier.printQuote(packageWeight, shippingDistance);  // runs FreightCarrier's override
    }
}

// Demonstrates constructor chaining and super method calls in a real HR system

class Employee {
    private String fullName;
    private String employeeId;
    private double annualSalary;

    public Employee(String fullName, String employeeId, double annualSalary) {
        this.fullName = fullName;
        this.employeeId = employeeId;
        this.annualSalary = annualSalary;
        System.out.println("[Employee constructor] Creating employee: " + fullName);
    }

    public double calculateAnnualBonus() {
        // Base employees get 5% of salary as bonus
        return annualSalary * 0.05;
    }

    public void printCompensationReport() {
        System.out.println("--- Compensation Report ---");
        System.out.println("Name:       " + fullName);
        System.out.println("ID:         " + employeeId);
        System.out.println("Salary:     $" + String.format("%.2f", annualSalary));
        System.out.println("Bonus:      $" + String.format("%.2f", calculateAnnualBonus()));
    }

    public double getAnnualSalary() {
        return annualSalary;
    }
}

class SeniorEngineer extends Employee {
    private int yearsOfExperience;
    private String specialisation;

    public SeniorEngineer(String fullName, String employeeId, double annualSalary,
                          int yearsOfExperience, String specialisation) {
        // super() MUST be first — sets up the Employee part of this object
        super(fullName, employeeId, annualSalary);
        this.yearsOfExperience = yearsOfExperience;
        this.specialisation = specialisation;
        System.out.println("[SeniorEngineer constructor] Adding specialisation: " + specialisation);
    }

    @Override
    public double calculateAnnualBonus() {
        // Start with what the parent would give, then add extra for experience
        double baseBonus = super.calculateAnnualBonus();  // calls Employee's 5% logic
        double experienceBonus = yearsOfExperience * 500.0; // $500 per year of experience
        return baseBonus + experienceBonus;
    }

    @Override
    public void printCompensationReport() {
        super.printCompensationReport();  // Print everything the parent prints first
        // Then append child-specific information
        System.out.println("Specialisation: " + specialisation);
        System.out.println("Experience: " + yearsOfExperience + " years");
    }
}

public class EmployeeHierarchyDemo {
    public static void main(String[] args) {
        System.out.println("=== Creating a SeniorEngineer ===");
        // Watch the order of constructor calls in the output
        SeniorEngineer lead = new SeniorEngineer(
            "Maya Chen", "ENG-0042", 120000.00, 8, "Distributed Systems"
        );

        System.out.println();
        lead.printCompensationReport();
    }
}

// Demonstrates the right and wrong way to model a 'NotificationService'

// ============================================================
// WRONG APPROACH: Extending EmailSender just to reuse its methods
// A NotificationService IS-NOT-A EmailSender — it just USES one
// ============================================================
class EmailSender {
    public void sendEmail(String recipient, String subject, String body) {
        System.out.println("Sending email to " + recipient + " | Subject: " + subject);
    }
}

// BAD: This locks NotificationService into always being an EmailSender
// You can never easily swap in a different sender, and the public API
// of NotificationService now leaks all of EmailSender's methods
class NotificationServiceBad extends EmailSender {
    public void notifyUser(String userEmail, String message) {
        // Calling the inherited method — but this is NOT an IS-A relationship
        sendEmail(userEmail, "Notification", message);
    }
}

// ============================================================
// RIGHT APPROACH: Composition — NotificationService HAS-A sender
// ============================================================
interface MessageSender {
    // An interface means we can swap the implementation at any time
    void send(String recipient, String message);
}

class EmailMessageSender implements MessageSender {
    @Override
    public void send(String recipient, String message) {
        System.out.println("[Email] To: " + recipient + " | " + message);
    }
}

class SmsMessageSender implements MessageSender {
    @Override
    public void send(String recipient, String message) {
        System.out.println("[SMS] To: " + recipient + " | " + message);
    }
}

// GOOD: NotificationService holds a reference to any MessageSender
// Swapping from Email to SMS requires zero changes to this class
class NotificationServiceGood {
    private MessageSender messageSender;  // HAS-A relationship

    // Inject the sender — this is the Dependency Injection pattern
    public NotificationServiceGood(MessageSender messageSender) {
        this.messageSender = messageSender;
    }

    public void notifyUser(String recipient, String alertMessage) {
        messageSender.send(recipient, alertMessage);
    }
}

public class CompositionVsInheritanceDemo {
    public static void main(String[] args) {
        // BAD approach — tightly coupled to EmailSender
        NotificationServiceBad badService = new NotificationServiceBad();
        badService.notifyUser("alice@example.com", "Your order has shipped.");

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

        // GOOD approach — swap the sender without touching NotificationServiceGood
        NotificationServiceGood emailNotifier = new NotificationServiceGood(new EmailMessageSender());
        NotificationServiceGood smsNotifier   = new NotificationServiceGood(new SmsMessageSender());

        emailNotifier.notifyUser("alice@example.com", "Your order has shipped.");
        smsNotifier.notifyUser("+1-555-0199",         "Your order has shipped.");
    }
}

// Instead of extending a heavy base class, compose with an interface

interface MessageSender {
    void send(String recipient, String message);
}

class EmailSender implements MessageSender {
    @Override
    public void send(String recipient, String message) {
        System.out.println("[Email] " + recipient + ": " + message);
    }
}

class SmsSender implements MessageSender {
    @Override
    public void send(String recipient, String message) {
        System.out.println("[SMS] " + recipient + ": " + message);
    }
}

class SlackSender implements MessageSender {
    @Override
    public void send(String channel, String message) {
        System.out.println("[Slack] #" + channel + ": " + message);
    }
}

class NotificationService {
    private MessageSender sender;  // composition

    public NotificationService(MessageSender sender) {
        this.sender = sender;
    }

    public void notify(String recipient, String msg) {
        sender.send(recipient, msg);
    }
}

// Template Method Pattern — parent controls the algorithm, child fills in details

abstract class DataExporter {
    // Template method — defines the skeleton
    public final void export(String data) {
        validate(data);            // step 1: always validate
        transform(data);           // step 2: transform (abstract)
        write(data);               // step 3: write (abstract)
        cleanup();                 // step 4: cleanup (optional hook)
    }

    protected abstract String transform(String data);
    protected abstract void write(String data);

    private void validate(String data) {
        if (data == null || data.isEmpty()) {
            throw new IllegalArgumentException("Data cannot be empty");
        }
        System.out.println("Data validated.");
    }

    // Hook method — optional override
    protected void cleanup() {
        // default: do nothing
    }
}

class CsvExporter extends DataExporter {
    @Override
    protected String transform(String data) {
        return data.replace(",", ";");
    }

    @Override
    protected void write(String data) {
        System.out.println("Writing CSV: " + data);
    }
}

class JsonExporter extends DataExporter {
    @Override
    protected String transform(String data) {
        return "{\"data\":\"" + data + "\"}";
    }

    @Override
    protected void write(String data) {
        System.out.println("Writing JSON: " + data);
    }

    @Override
    protected void cleanup() {
        System.out.println("Closing JSON writer.");
    }
}

// io.thecodeforge — java tutorial

class PaymentGateway {
    private String apiKey = "sk_live_secret";
    protected String endpoint = "https://api.stripe.com/v1";

    private void logKey() {
        System.out.println("Logging key (private method)");
    }

    protected void charge(int amount) {
        System.out.println("Charging $" + amount);
        logKey();
    }
}

class StripeGateway extends PaymentGateway {
    // Cannot access apiKey or logKey() — they're private
    // This override is fine: same or wider visibility
    @Override
    public void charge(int amount) {
        System.out.println("Stripe charging $" + amount + " via " + endpoint);
        // super.charge(amount); // would call private logKey internally
    }

    // Compiler error: attempting to reduce visibility
    // @Override
    // private void charge(int amount) { }
}

public class Main {
    public static void main(String[] args) {
        StripeGateway gw = new StripeGateway();
        gw.charge(2999);
    }
}

// io.thecodeforge — java tutorial

interface Exportable {
    default String export() {
        return "CSV export";
    }
}

interface Auditable {
    default String export() {
        return "Audit log export";
    }
}

class InvoiceService implements Exportable, Auditable {
    // Must resolve conflict — no silent ambiguity
    @Override
    public String export() {
        // Pick one, or combine both
        return Exportable.super.export() + " + " + Auditable.super.export();
    }

    public void process() {
        System.out.println("Processing invoice...");
        System.out.println("Exported: " + export());
    }
}

public class Main {
    public static void main(String[] args) {
        new InvoiceService().process();
    }
}