Java Inheritance — extends, super, Overriding & Best Practices

// ── PARENT CLASS ──────────────────────────────────────
public class Vehicle {

    // protected — accessible in subclasses across packages
    protected String brand;
    protected String model;
    protected int    year;
    protected double fuelLevel; // 0.0 to 1.0

    // private — NOT inherited by subclasses
    private String vehicleIdentificationNumber;

    public Vehicle(String brand, String model, int year) {
        this.brand  = brand;
        this.model  = model;
        this.year   = year;
        this.fuelLevel = 1.0;
        this.vehicleIdentificationNumber = generateVIN();
    }

    // public — inherited and can be overridden
    public void startEngine() {
        System.out.println(brand + " " + model + " engine started.");
    }

    public void refuel(double amount) {
        fuelLevel = Math.min(1.0, fuelLevel + amount);
        System.out.printf("Refuelled. Fuel level: %.0f%%%n", fuelLevel * 100);
    }

    public String getDetails() {
        return String.format("%s %s (%d) | Fuel: %.0f%%",
               brand, model, year, fuelLevel * 100);
    }

    // private — NOT accessible in subclasses
    private String generateVIN() {
        return "VIN-" + System.currentTimeMillis();
    }
}

// ── SUBCLASS — inherits Vehicle ───────────────────────
public class Car extends Vehicle {

    private int   numberOfDoors;
    private String transmissionType; // "Manual" or "Automatic"

    public Car(String brand, String model, int year,
               int doors, String transmission) {
        super(brand, model, year); // ✅ Must call parent constructor
        this.numberOfDoors    = doors;
        this.transmissionType = transmission;
    }

    // NEW method — only in Car
    public void openTrunk() {
        System.out.println(model + " trunk opened.");
    }

    // OVERRIDING parent method — custom behaviour for Car
    @Override
    public String getDetails() {
        return super.getDetails() +  // Reuse parent's version
               String.format(" | Doors: %d | %s",
                             numberOfDoors, transmissionType);
    }
}

// ── ANOTHER SUBCLASS ──────────────────────────────────
public class Truck extends Vehicle {

    private double payloadCapacityTons;

    public Truck(String brand, String model, int year, double payload) {
        super(brand, model, year);
        this.payloadCapacityTons = payload;
    }

    @Override
    public void startEngine() {
        System.out.println(brand + " " + model +
                           " heavy engine roaring to life!");
    }

    public double getPayload() { return payloadCapacityTons; }
}

// ── USAGE ─────────────────────────────────────────────
// Car    car   = new Car("Toyota", "Camry", 2024, 4, "Automatic");
// Truck  truck = new Truck("Tata", "Prima", 2023, 25.0);
// car.startEngine();  // Toyota Camry engine started.
// truck.startEngine(); // Tata Prima heavy engine roaring to life!
// car.openTrunk();    // Camry trunk opened.
// System.out.println(car.getDetails());
// → Toyota Camry (2024) | Fuel: 100% | Doors: 4 | Automatic

// ── SINGLE INHERITANCE ────────────────────────────────
class Animal {
    String name;
    void breathe() { System.out.println(name + " breathes."); }
}
class Dog extends Animal {         // Single — Dog extends Animal
    void bark() { System.out.println(name + " barks!"); }
}

// ── MULTILEVEL INHERITANCE ────────────────────────────
class LivingBeing {
    void eat() { System.out.println("Eating..."); }
}
class Animal2 extends LivingBeing {  // Level 1
    void breathe() { System.out.println("Breathing..."); }
}
class Dog2 extends Animal2 {          // Level 2 — inherits from both
    void bark() { System.out.println("Barking!"); }
}
// Dog2 object can call: eat(), breathe(), bark()

// ── HIERARCHICAL INHERITANCE ──────────────────────────
class Shape {
    String colour;
    double getArea() { return 0; }
}
class Circle    extends Shape {  // Child 1
    double radius;
    @Override double getArea() { return Math.PI * radius * radius; }
}
class Rectangle extends Shape {  // Child 2
    double width, height;
    @Override double getArea() { return width * height; }
}
class Triangle  extends Shape {  // Child 3
    double base, height;
    @Override double getArea() { return 0.5 * base * height; }
}

// ── MULTIPLE INHERITANCE via INTERFACES ───────────────
interface Flyable  { void fly(); }
interface Swimmable { void swim(); }

class Duck extends Animal implements Flyable, Swimmable {
    @Override public void fly()  { System.out.println(name + " flies."); }
    @Override public void swim() { System.out.println(name + " swims."); }
}
// Duck IS-A Animal, IS-A Flyable, IS-A Swimmable — all valid!

// ❌ NOT ALLOWED — multiple class inheritance
// class Mule extends Horse, Donkey { } // Compile error

public class Employee {

    protected String name;
    protected String department;
    protected double baseSalary;

    public Employee(String name, String department, double baseSalary) {
        this.name       = name;
        this.department = department;
        this.baseSalary = baseSalary;
    }

    public double calculateMonthlyPay() {
        return baseSalary;
    }

    public String getPaySlip() {
        return String.format("Employee: %s | Dept: %s | Base: ₹%.2f",
                            name, department, baseSalary);
    }
}

// ── Manager EXTENDS Employee ──────────────────────────
public class Manager extends Employee {

    private double teamBonus;
    private int    teamSize;

    public Manager(String name, String department,
                   double baseSalary, double teamBonus, int teamSize) {
        super(name, department, baseSalary); // ✅ Use 1: calls Employee constructor
        this.teamBonus = teamBonus;
        this.teamSize  = teamSize;
    }

    // ✅ Use 2: call overridden method to extend (not replace) logic
    @Override
    public double calculateMonthlyPay() {
        double base      = super.calculateMonthlyPay(); // Parent's version
        double bonusShare = teamBonus / teamSize;       // Manager's extra
        return base + bonusShare;
    }

    @Override
    public String getPaySlip() {
        return super.getPaySlip() +  // ✅ Reuse parent's formatted string
               String.format(" | Bonus Share: ₹%.2f | Team: %d",
                             teamBonus / teamSize, teamSize);
    }
}

// ── SeniorManager EXTENDS Manager (Multilevel) ────────
public class SeniorManager extends Manager {

    private double performanceBonus;

    public SeniorManager(String name, String department,
                         double baseSalary, double teamBonus,
                         int teamSize, double perfBonus) {
        super(name, department, baseSalary, teamBonus, teamSize);
        this.performanceBonus = perfBonus;
    }

    @Override
    public double calculateMonthlyPay() {
        return super.calculateMonthlyPay() + performanceBonus;
    }

    @Override
    public String getPaySlip() {
        return super.getPaySlip() +
               String.format(" | Perf Bonus: ₹%.2f", performanceBonus);
    }
}

// Usage:
// Employee   e = new Employee("Ravi",   "Dev",    60000);
// Manager    m = new Manager("Priya",   "Dev",    90000, 50000, 5);
// SeniorManager s = new SeniorManager("Arjun", "Dev", 130000, 80000, 8, 20000);
// System.out.println(e.getPaySlip());
// System.out.println(m.getPaySlip());
// System.out.println(s.getPaySlip());

class A {
    A() {
        System.out.println("A constructor");
    }
}

class B extends A {
    B() {
        // Java auto-inserts: super(); here if not written
        System.out.println("B constructor");
    }
}

class C extends B {
    C() {
        // Java auto-inserts: super(); here if not written
        System.out.println("C constructor");
    }
}

// new C() output:
// A constructor   ← runs first (top of chain)
// B constructor
// C constructor   ← runs last (most derived)

// ── PRACTICAL EXAMPLE ─────────────────────────────────
class Account {
    protected String accountId;
    protected String ownerName;
    protected double balance;

    Account(String accountId, String ownerName, double initialDeposit) {
        if (initialDeposit < 0)
            throw new IllegalArgumentException("Initial deposit cannot be negative");
        this.accountId  = accountId;
        this.ownerName  = ownerName;
        this.balance    = initialDeposit;
        System.out.println("Account created: " + accountId);
    }
}

class SavingsAccount extends Account {
    private double interestRate;
    private double minimumBalance;

    SavingsAccount(String id, String owner,
                   double deposit, double interestRate) {
        super(id, owner, deposit);          // ✅ Initialise Account part first
        this.interestRate   = interestRate;
        this.minimumBalance = 1000.0;
        System.out.println("SavingsAccount configured. Rate: " + interestRate);
    }

    double calculateYearlyInterest() {
        return balance * interestRate / 100;
    }
}

class FixedDepositAccount extends SavingsAccount {
    private int    tenureMonths;
    private double lockinPenaltyPercent;

    FixedDepositAccount(String id, String owner, double deposit,
                        double rate, int tenure) {
        super(id, owner, deposit, rate);     // ✅ Initialise SavingsAccount part
        this.tenureMonths          = tenure;
        this.lockinPenaltyPercent  = 1.5;
        System.out.println("FD Account. Tenure: " + tenure + " months");
    }
}

// new FixedDepositAccount("FD001","Ravi",100000,7.5,24) prints:
// Account created: FD001
// SavingsAccount configured. Rate: 7.5
// FD Account. Tenure: 24 months

// ── PARENT ────────────────────────────────────────────
public abstract class PaymentProcessor {

    protected String processorName;
    protected double transactionFeePercent;

    public PaymentProcessor(String name, double fee) {
        this.processorName        = name;
        this.transactionFeePercent = fee;
    }

    // Template method — calls overridable processTransaction()
    public final PaymentResult pay(double amount, String currency) {
        if (amount <= 0)
            return PaymentResult.failure("Amount must be positive");
        double fee    = amount * transactionFeePercent / 100;
        double netAmt = amount - fee;
        System.out.printf("[%s] Processing %.2f %s (fee: %.2f)%n",
                          processorName, amount, currency, fee);
        return processTransaction(netAmt, currency); // Calls overridden version
    }

    // ← Subclasses MUST override this to provide gateway-specific logic
    protected abstract PaymentResult processTransaction(double amount, String currency);

    // Can be overridden if needed
    public String getProcessorInfo() {
        return processorName + " (Fee: " + transactionFeePercent + "%)";
    }
}

// ── SUBCLASS 1: UPI ───────────────────────────────────
public class UPIProcessor extends PaymentProcessor {

    private String upiId;

    public UPIProcessor(String upiId) {
        super("UPI", 0.0); // UPI has zero transaction fee
        this.upiId = upiId;
    }

    @Override
    protected PaymentResult processTransaction(double amount, String currency) {
        System.out.println("  → UPI transfer to " + upiId);
        return PaymentResult.success("UPI-" + System.currentTimeMillis());
    }

    @Override
    public String getProcessorInfo() {
        return super.getProcessorInfo() + " | UPI ID: " + upiId;
    }
}

// ── SUBCLASS 2: Credit Card ───────────────────────────
public class CreditCardProcessor extends PaymentProcessor {

    private String maskedCardNumber;

    public CreditCardProcessor(String maskedCard) {
        super("CreditCard", 1.8); // 1.8% fee
        this.maskedCardNumber = maskedCard;
    }

    @Override
    protected PaymentResult processTransaction(double amount, String currency) {
        System.out.println("  → Credit card charge on " + maskedCardNumber);
        return PaymentResult.success("CC-" + System.currentTimeMillis());
    }
}

// ── RUNTIME POLYMORPHISM IN ACTION ────────────────────
// PaymentProcessor processor; // Parent type reference
//
// processor = new UPIProcessor("ravi@upi");
// processor.pay(1000, "INR"); // Calls UPIProcessor.processTransaction()
//
// processor = new CreditCardProcessor("**** **** 4521");
// processor.pay(5000, "INR"); // Calls CreditCardProcessor.processTransaction()
//
// SAME method call 'processor.pay()' — DIFFERENT behaviour at runtime!

// ── FINAL CLASS — cannot be extended ─────────────────
public final class SSLCertificate {
    private final String thumbprint;
    private final String issuer;

    public SSLCertificate(String thumbprint, String issuer) {
        this.thumbprint = thumbprint;
        this.issuer     = issuer;
    }
    // No subclass can tamper with certificate validation logic
}
// class FakeSSL extends SSLCertificate { } // ❌ Compile error

// ── FINAL METHOD — cannot be overridden ──────────────
public class OrderProcessor {

    // This core algorithm must never be changed by subclasses
    public final OrderResult process(Order order) {
        validate(order);          // Overridable hook
        applyDiscounts(order);    // Overridable hook
        PaymentResult p = chargePayment(order); // Overridable hook
        if (!p.isSuccess()) return OrderResult.failure(p.getReason());
        fulfil(order);            // Overridable hook
        sendConfirmation(order);  // Overridable hook
        return OrderResult.success(order);
    }

    // These CAN be overridden — customise the steps
    protected void validate(Order order)              { /* default impl */ }
    protected void applyDiscounts(Order order)        { /* default impl */ }
    protected PaymentResult chargePayment(Order order){ return PaymentResult.success(""); }
    protected void fulfil(Order order)                { /* default impl */ }
    protected void sendConfirmation(Order order)      { /* default impl */ }
}

// Subclass can customise steps but NOT the overall algorithm
public class ExpressOrderProcessor extends OrderProcessor {

    @Override
    protected void fulfil(Order order) {
        System.out.println("Priority fulfillment for order: " + order.getId());
        // Express-specific fulfilment logic
    }

    // @Override
    // public OrderResult process(Order o) { } // ❌ Compile error — process() is final
}

// ── FINAL FIELD — immutable after construction ────────
public class TransactionRecord {
    private final String transactionId;  // Set once — never changes
    private final long   timestamp;
    private       TransactionStatus status; // Mutable — status can change

    public TransactionRecord(String id) {
        this.transactionId = id;
        this.timestamp     = System.currentTimeMillis();
        this.status        = TransactionStatus.PENDING;
    }
    public String getTransactionId() { return transactionId; }
}

// ── IS-A: Correct inheritance ─────────────────────────
public class Notification {
    protected String recipientId;
    protected String message;
    protected NotificationPriority priority;

    public Notification(String recipientId, String message,
                        NotificationPriority priority) {
        this.recipientId = recipientId;
        this.message     = message;
        this.priority    = priority;
    }

    public void send() {
        System.out.println("Sending to " + recipientId + ": " + message);
    }
}

// ✅ EmailNotification IS-A Notification — inheritance makes sense
public class EmailNotification extends Notification {
    private String subject;
    private String fromAddress;

    public EmailNotification(String recipientId, String subject,
                             String body, String from) {
        super(recipientId, body, NotificationPriority.NORMAL);
        this.subject     = subject;
        this.fromAddress = from;
    }

    @Override
    public void send() {
        System.out.printf("Email → %s | Subject: %s | From: %s%n",
                          recipientId, subject, fromAddress);
    }
}

// ── HAS-A: Correct composition ────────────────────────
public class Engine {
    private int   horsePower;
    private String fuelType;

    public Engine(int hp, String fuelType) {
        this.horsePower = hp;
        this.fuelType   = fuelType;
    }
    public void start()  { System.out.println(horsePower + "hp engine started."); }
    public void stop()   { System.out.println("Engine stopped."); }
    public int  getHP()  { return horsePower; }
}

// ✅ Car HAS-A Engine — composition is correct
// ❌ Car extends Engine — WRONG: a Car is NOT a type of Engine
public class Car {
    private final Engine  engine;  // HAS-A relationship
    private       String  brand;
    private       boolean running;

    public Car(String brand, Engine engine) {
        this.brand  = brand;
        this.engine = engine; // Engine injected — can swap petrol/electric
        this.running = false;
    }

    public void start() {
        engine.start();  // DELEGATES to the Engine object
        running = true;
        System.out.println(brand + " is now running.");
    }

    // Benefit: engine can be swapped — ElectricEngine, HybridEngine, etc.
    public int getEnginePower() { return engine.getHP(); }
}

// Car car = new Car("Honda", new Engine(150, "Petrol"));
// car.start(); // 150hp engine started. → Honda is now running.

public class InstanceofDemo {

    // ── Class hierarchy ───────────────────────────────
    static class Shape        { double getArea() { return 0; } }
    static class Circle    extends Shape {
        double radius;
        Circle(double r)    { radius = r; }
        @Override double getArea() { return Math.PI * radius * radius; }
    }
    static class Rectangle extends Shape {
        double w, h;
        Rectangle(double w, double h) { this.w=w; this.h=h; }
        @Override double getArea() { return w * h; }
    }
    static class Square extends Rectangle {
        Square(double side) { super(side, side); }
    }

    public static void main(String[] args) {

        Shape[] shapes = {
            new Circle(5),
            new Rectangle(4, 6),
            new Square(3),
            null
        };

        for (Shape s : shapes) {

            // ── Classic instanceof ────────────────────
            System.out.println("--- Next shape ---");
            System.out.println("instanceof Shape:     " + (s instanceof Shape));
            System.out.println("instanceof Circle:    " + (s instanceof Circle));
            System.out.println("instanceof Rectangle: " + (s instanceof Rectangle));
            System.out.println("instanceof Square:    " + (s instanceof Square));
            // null instanceof anything → always false (no NPE!)
        }

        // ── Pattern Matching instanceof (Java 16+) ────
        Shape shape = new Circle(7.0);

        // Old way — verbose: test + separate cast
        if (shape instanceof Circle) {
            Circle c = (Circle) shape;   // Redundant cast
            System.out.println("Old way — Radius: " + c.radius);
        }

        // ✅ New way — test + bind in one step (Java 16+)
        if (shape instanceof Circle c) {
            System.out.println("New way — Radius: " + c.radius);
            System.out.println("Area: " + String.format("%.2f", c.getArea()));
        }

        // ✅ With extra condition on the bound variable
        if (shape instanceof Circle c && c.radius > 5.0) {
            System.out.println("Large circle — radius: " + c.radius);
        }

        // ── Preferred: Polymorphism over instanceof ───
        // Instead of instanceof + cast, rely on overriding:
        for (Shape s2 : new Shape[]{ new Circle(3), new Rectangle(2,4) }) {
            System.out.println("Area: " + String.format("%.2f", s2.getArea()));
            // No instanceof needed — dynamic dispatch handles it!
        }
    }
}

import java.util.Objects;

public class OrderItem {

    private final String productId;
    private final String productName;
    private final int    quantity;
    private final double unitPrice;

    public OrderItem(String productId, String name, int qty, double price) {
        this.productId   = productId;
        this.productName = name;
        this.quantity    = qty;
        this.unitPrice   = price;
    }

    // ── toString: human-readable representation ───────
    @Override
    public String toString() {
        return String.format("OrderItem{id='%s', name='%s', qty=%d, price=₹%.2f, total=₹%.2f}",
               productId, productName, quantity, unitPrice, getTotal());
    }

    // ── equals: value-based equality ──────────────────
    @Override
    public boolean equals(Object o) {
        if (this == o) return true;                    // Same object
        if (!(o instanceof OrderItem item)) return false; // Different type or null
        return quantity == item.quantity
            && Double.compare(unitPrice, item.unitPrice) == 0
            && Objects.equals(productId, item.productId);
    }

    // ── hashCode: consistent with equals ──────────────
    @Override
    public int hashCode() {
        return Objects.hash(productId, quantity, unitPrice);
    }

    // Business method
    public double getTotal() { return quantity * unitPrice; }

    // Getters
    public String getProductId()   { return productId; }
    public String getProductName() { return productName; }
    public int    getQuantity()    { return quantity; }
    public double getUnitPrice()   { return unitPrice; }
}

// Usage demonstration:
// OrderItem a = new OrderItem("P001", "Laptop", 1, 65000);
// OrderItem b = new OrderItem("P001", "Laptop", 1, 65000);
// System.out.println(a);          // OrderItem{id='P001', name='Laptop'...}
// System.out.println(a.equals(b)); // true  — value equality
// System.out.println(a == b);      // false — different objects in memory
//
// var set = new java.util.HashSet<OrderItem>();
// set.add(a);
// set.contains(b); // true — works correctly with hashCode override

// ── LSP VIOLATION: Rectangle-Square Problem ───────────
class Rectangle {
    protected double width;
    protected double height;

    public void setWidth(double w)  { this.width  = w; }
    public void setHeight(double h) { this.height = h; }
    public double getArea()         { return width * height; }
}

// ❌ VIOLATES LSP — Square breaks Rectangle's behaviour contract
class Square extends Rectangle {
    @Override
    public void setWidth(double w) {
        this.width  = w;
        this.height = w; // Forces equal sides — breaks Rectangle contract!
    }
    @Override
    public void setHeight(double h) {
        this.width  = h; // Same problem
        this.height = h;
    }
}

// Code that works for Rectangle but BREAKS for Square:
static void testRectangle(Rectangle r) {
    r.setWidth(5);
    r.setHeight(3);
    // Expects area = 15 for ANY Rectangle
    assert r.getArea() == 15 : "Expected 15 but got " + r.getArea();
}
// testRectangle(new Rectangle()); // ✅ Passes
// testRectangle(new Square());    // ❌ Fails — area is 9, not 15!

// ── LSP-COMPLIANT FIX: Use abstraction instead ────────
interface Shape {
    double getArea();
    double getPerimeter();
}

class RectangleFixed implements Shape {
    private final double width;
    private final double height;
    RectangleFixed(double w, double h) { width=w; height=h; }
    @Override public double getArea()      { return width * height; }
    @Override public double getPerimeter() { return 2*(width+height); }
}

class SquareFixed implements Shape {
    private final double side;
    SquareFixed(double s) { side = s; }
    @Override public double getArea()      { return side * side; }
    @Override public double getPerimeter() { return 4 * side; }
}
// Both implement Shape — no LSP violation.
// Square is not forced to pretend it's a mutable Rectangle.

// ── LSP-COMPLIANT Inheritance Example ─────────────────
abstract class Discount {
    // Contract: always returns a value between 0.0 and 1.0
    public abstract double getDiscountRate(double orderValue);
}

class FestivalDiscount extends Discount {
    @Override
    public double getDiscountRate(double orderValue) {
        return orderValue > 5000 ? 0.20 : 0.10; // ✅ Always 0.0–1.0
    }
}

class PremiumMemberDiscount extends Discount {
    @Override
    public double getDiscountRate(double orderValue) {
        return 0.15; // ✅ Always 0.0–1.0 — LSP honoured
    }
}

// ❌ MISTAKE 1: Forgetting super() when parent has no no-arg constructor
class Vehicle {
    String brand;
    Vehicle(String brand) { this.brand = brand; } // No default constructor!
}
class Car extends Vehicle {
    int doors;
    Car(int doors) {
        // Java auto-inserts super() — but Vehicle has no no-arg constructor!
        // ❌ Compile error: no suitable constructor found
        this.doors = doors;
    }
}
// ✅ Fix: explicitly call super(args)
class CarFixed extends Vehicle {
    int doors;
    CarFixed(String brand, int doors) {
        super(brand);  // ✅ Calls Vehicle(String brand)
        this.doors = doors;
    }
}

// ❌ MISTAKE 2: @Override typo silently creates a NEW method
class Animal {
    public void makeSound() { System.out.println("..."); }
}
class Cat extends Animal {
    // Missing @Override — 'makesound' is a NEW method, not an override
    public void makesound() { System.out.println("Meow"); } // Silent bug!
}
// Animal a = new Cat();
// a.makeSound(); // Prints "..." — Cat's method never called!
// ✅ Fix: always add @Override — compiler will catch the typo

// ❌ MISTAKE 3: Narrowing access modifier in override
class Base {
    public void display() { System.out.println("Base"); }
}
class Derived extends Base {
    // @Override
    // protected void display() { } // ❌ Compile error — narrows public to protected
    @Override
    public void display() { System.out.println("Derived"); } // ✅ Same or wider
}

// ❌ MISTAKE 4: Calling overridable method from constructor
class Parent {
    public Parent() {
        printInfo(); // ❌ Dangerous — calls overridden version before subclass is ready
    }
    public void printInfo() { System.out.println("Parent info"); }
}
class Child extends Parent {
    private String info = "Child data";
    @Override
    public void printInfo() {
        System.out.println(info.toUpperCase()); // ❌ NPE! 'info' is null here
    }
}
// new Child() → NullPointerException in printInfo() before info is set

// ❌ MISTAKE 5: instanceof misused — checking specific type when polymorphism works
// BAD: every time Animal adds a new subclass, this switch breaks
for (Animal a : animals) {
    if (a instanceof Dog)  { ((Dog)a).fetch(); }
    else if (a instanceof Cat)  { ((Cat)a).purr(); }
    else if (a instanceof Bird) { ((Bird)a).tweet(); }
}
// ✅ Better: use polymorphism — each subclass overrides 'performAction()'
for (Animal a : animals) {
    a.performAction(); // Dog.performAction() fetches, Cat.purr()s, etc.
}

package com.techsustainify.report;

import java.time.LocalDateTime;
import java.util.List;

/**
 * Abstract base class — defines the TEMPLATE for report generation.
 * The algorithm skeleton is fixed (final); steps are customisable (overridable).
 * Pattern: Template Method — GoF Behavioural Pattern
 */
public abstract class ReportGenerator {

    protected final String  reportTitle;
    protected final String  generatedBy;
    protected final LocalDateTime generatedAt;

    protected ReportGenerator(String title, String generatedBy) {
        this.reportTitle  = title;
        this.generatedBy  = generatedBy;
        this.generatedAt  = LocalDateTime.now();
    }

    // ── TEMPLATE METHOD — algorithm skeleton, cannot be overridden ──
    public final ReportOutput generate(ReportRequest request) {
        validateRequest(request);       // Hook 1
        List<?> data    = fetchData(request);   // Hook 2 — must override
        List<?> filtered = filterData(data, request); // Hook 3
        List<?> sorted   = sortData(filtered);         // Hook 4
        ReportBody body  = formatBody(sorted);         // Hook 5 — must override
        ReportHeader header = buildHeader(request);    // Hook 6
        ReportFooter footer = buildFooter();           // Hook 7
        return assembleReport(header, body, footer);
    }

    // ── ABSTRACT HOOKS — subclasses MUST implement ────
    protected abstract List<?> fetchData(ReportRequest request);
    protected abstract ReportBody formatBody(List<?> data);

    // ── OVERRIDABLE HOOKS — subclasses MAY customise ──
    protected void validateRequest(ReportRequest request) {
        if (request == null)
            throw new IllegalArgumentException("Request cannot be null");
    }

    protected List<?> filterData(List<?> data, ReportRequest request) {
        return data; // Default: no filtering
    }

    protected List<?> sortData(List<?> data) {
        return data; // Default: preserve order
    }

    protected ReportHeader buildHeader(ReportRequest request) {
        return new ReportHeader(reportTitle, generatedBy, generatedAt);
    }

    protected ReportFooter buildFooter() {
        return new ReportFooter("Page 1 of 1", "Confidential");
    }

    private ReportOutput assembleReport(ReportHeader h,
                                        ReportBody b, ReportFooter f) {
        return new ReportOutput(h, b, f);
    }
}

// ── CONCRETE SUBCLASS 1: Sales Report ─────────────────
public class SalesReportGenerator extends ReportGenerator {

    private final SalesRepository salesRepo;

    public SalesReportGenerator(SalesRepository repo, String generatedBy) {
        super("Monthly Sales Report", generatedBy);
        this.salesRepo = repo;
    }

    @Override
    protected List<SaleRecord> fetchData(ReportRequest request) {
        return salesRepo.findByDateRange(
               request.getFromDate(), request.getToDate());
    }

    @Override
    protected List<?> sortData(List<?> data) {
        // Sales reports sorted by date descending
        return ((List<SaleRecord>) data).stream()
               .sorted((a, b) -> b.getSaleDate().compareTo(a.getSaleDate()))
               .toList();
    }

    @Override
    protected ReportBody formatBody(List<?> data) {
        List<SaleRecord> sales = (List<SaleRecord>) data;
        double totalRevenue = sales.stream().mapToDouble(SaleRecord::getAmount).sum();
        return new SalesReportBody(sales, totalRevenue);
    }
}

// ── CONCRETE SUBCLASS 2: Inventory Report ─────────────
public class InventoryReportGenerator extends ReportGenerator {

    private final InventoryRepository inventoryRepo;
    private final int lowStockThreshold;

    public InventoryReportGenerator(InventoryRepository repo,
                                    int threshold, String generatedBy) {
        super("Inventory Status Report", generatedBy);
        this.inventoryRepo    = repo;
        this.lowStockThreshold = threshold;
    }

    @Override
    protected List<InventoryItem> fetchData(ReportRequest request) {
        return inventoryRepo.findAll();
    }

    @Override
    protected List<?> filterData(List<?> data, ReportRequest request) {
        // Only include low-stock items
        return ((List<InventoryItem>) data).stream()
               .filter(item -> item.getStock() < lowStockThreshold)
               .toList();
    }

    @Override
    protected ReportBody formatBody(List<?> data) {
        return new InventoryReportBody((List<InventoryItem>) data, lowStockThreshold);
    }
}

// Both generators use the SAME template (generate()) but produce
// completely different reports through method overriding.

package com.techsustainify.notification;

import java.time.LocalDateTime;

// ── ROOT: Abstract Notification ───────────────────────
public abstract class BaseNotification {

    private final String id;
    private final String recipientId;
    private final String body;
    private final NotificationPriority priority;
    private final LocalDateTime        createdAt;
    private       NotificationStatus   status;

    protected BaseNotification(String recipientId, String body,
                               NotificationPriority priority) {
        this.id          = java.util.UUID.randomUUID().toString();
        this.recipientId = recipientId;
        this.body        = body;
        this.priority    = priority;
        this.createdAt   = LocalDateTime.now();
        this.status      = NotificationStatus.PENDING;
    }

    // Template method — fixed delivery flow
    public final DeliveryResult deliver() {
        try {
            if (!isRecipientReachable()) {
                status = NotificationStatus.FAILED;
                return DeliveryResult.failure("Recipient unreachable");
            }
            DeliveryResult result = doDeliver();
            status = result.isSuccess()
                   ? NotificationStatus.DELIVERED
                   : NotificationStatus.FAILED;
            return result;
        } catch (Exception e) {
            status = NotificationStatus.FAILED;
            return DeliveryResult.failure("Delivery error: " + e.getMessage());
        }
    }

    // Each notification type implements its own delivery
    protected abstract DeliveryResult doDeliver();
    protected abstract boolean isRecipientReachable();

    // Getters
    public String                getId()          { return id; }
    public String                getRecipientId() { return recipientId; }
    public String                getBody()        { return body; }
    public NotificationPriority  getPriority()    { return priority; }
    public NotificationStatus    getStatus()      { return status; }
    public boolean               isPending()      { return status == NotificationStatus.PENDING; }
}

// ── EMAIL NOTIFICATION ────────────────────────────────
public class EmailNotification extends BaseNotification {

    private final String subject;
    private final String toEmail;
    private final EmailClient emailClient;

    public EmailNotification(String recipientId, String toEmail,
                             String subject, String body,
                             EmailClient client) {
        super(recipientId, body, NotificationPriority.NORMAL);
        this.subject     = subject;
        this.toEmail     = toEmail;
        this.emailClient = client;
    }

    @Override
    protected boolean isRecipientReachable() {
        return toEmail != null && toEmail.contains("@");
    }

    @Override
    protected DeliveryResult doDeliver() {
        return emailClient.send(toEmail, subject, getBody());
    }
}

// ── SMS NOTIFICATION ──────────────────────────────────
public class SmsNotification extends BaseNotification {

    private final String phoneNumber;
    private final SmsGateway smsGateway;

    public SmsNotification(String recipientId, String phoneNumber,
                           String body, SmsGateway gateway) {
        super(recipientId, body, NotificationPriority.HIGH);
        this.phoneNumber = phoneNumber;
        this.smsGateway  = gateway;
    }

    @Override
    protected boolean isRecipientReachable() {
        return phoneNumber != null && phoneNumber.matches("[6-9]\\d{9}");
    }

    @Override
    protected DeliveryResult doDeliver() {
        return smsGateway.sendSms(phoneNumber, getBody());
    }
}

// ── Dispatch service uses parent type — polymorphism ──
public class NotificationDispatcher {
    public void dispatch(List<BaseNotification> notifications) {
        notifications.stream()
            .filter(BaseNotification::isPending)
            .forEach(n -> {
                DeliveryResult r = n.deliver(); // Dynamic dispatch
                System.out.printf("[%s] %s → %s%n",
                    n.getClass().getSimpleName(),
                    n.getRecipientId(),
                    r.isSuccess() ? "Delivered" : "Failed: " + r.getReason());
            });
    }
}