Inheritance in Java
Complete Deep Dive

class GrandParent {
    GrandParent() {
        System.out.println("1️⃣  GrandParent() constructor called");
    }
}

class Parent extends GrandParent {
    Parent() {
        // Implicit super() — GrandParent() call hoga pehle
        System.out.println("2️⃣  Parent() constructor called");
    }
}

class Child extends Parent {
    Child() {
        // Implicit super() — Parent() call hoga pehle
        System.out.println("3️⃣  Child() constructor called");
    }
}

// ── What if parent has NO default constructor? ──
class Person {
    String name;
    int    age;

    // Sirf parameterized constructor — default (no-arg) nahi hai
    Person(String name, int age) {
        this.name = name;
        this.age  = age;
        System.out.println("Person(" + name + ", " + age + ") called");
    }

    void introduce() {
        System.out.println("Main " + name + " hoon, age " + age);
    }
}

class Student extends Person {
    String rollNo;
    double cgpa;

    Student(String name, int age, String rollNo, double cgpa) {
        super(name, age);  // MUST call — Person has no default constructor!
        this.rollNo = rollNo;
        this.cgpa   = cgpa;
        System.out.println("Student(" + rollNo + ") called");
    }

    void study() {
        System.out.println(name + " padh raha hai (CGPA: " + cgpa + ")");
    }
}

public class ConstructorChain {
    public static void main(String[] args) {
        System.out.println("=== Constructor Chain (GrandParent→Parent→Child) ===");
        Child c = new Child();  // Trace the chain!

        System.out.println("\n=== super() with parameterized constructor ===");
        Student s = new Student("Rahul", 20, "CS2024", 8.5);
        s.introduce();  // Person ka method
        s.study();      // Student ka method
    }
}

import java.util.Objects;

class Book {
    String title;
    String author;
    double price;
    int    year;

    Book(String title, String author, double price, int year) {
        this.title  = title;
        this.author = author;
        this.price  = price;
        this.year   = year;
    }

    // ── Override Object.toString() ──
    // Bina override ke: Book@1b6d3586 (useless)
    // Override karne ke baad: readable output
    @Override
    public String toString() {
        return "Book{title='" + title + "', author='" + author
             + "', price=₹" + price + ", year=" + year + "}";
    }

    // ── Override Object.equals() ──
    // Bina override ke: reference compare (== jaisa)
    // Override karne ke baad: content compare
    @Override
    public boolean equals(Object obj) {
        if (this == obj) return true;            // same reference
        if (!(obj instanceof Book)) return false; // type check
        Book other = (Book) obj;
        return Objects.equals(title, other.title)
            && Objects.equals(author, other.author)
            && price == other.price;
    }

    // ── Override hashCode() ──
    // equals() override karo to hashCode() bhi karo (contract)
    @Override
    public int hashCode() {
        return Objects.hash(title, author, price);
    }
}

public class ObjectClassDemo {
    public static void main(String[] args) {
        Book b1 = new Book("Java Programming", "James Gosling", 499.0, 2020);
        Book b2 = new Book("Java Programming", "James Gosling", 499.0, 2021);
        Book b3 = b1;  // same reference

        System.out.println("b1.toString():      " + b1);   // auto toString()
        System.out.println("b1.getClass():      " + b1.getClass().getSimpleName());
        System.out.println("b1.hashCode():      " + b1.hashCode());

        System.out.println("\nb1.equals(b2):      " + b1.equals(b2));  // content same
        System.out.println("b1.equals(b3):      " + b1.equals(b3));  // same ref
        System.out.println("b1 == b2:           " + (b1 == b2));     // ref compare
        System.out.println("b1 == b3:           " + (b1 == b3));     // same ref
    }
}

class Shape {
    String color;
    String type = "Generic Shape";  // parent field

    Shape(String color) {
        this.color = color;
        System.out.println("Shape constructor: color=" + color);
    }

    void draw() {
        System.out.println("Shape draw() — ek generic shape bana raha hai [" + color + "]");
    }

    double area() { return 0.0; }
}

class Circle extends Shape {
    double radius;
    String type = "Circle";  // child field — SAME NAME as parent (field hiding)

    Circle(String color, double radius) {
        // ── USE 1: super() — Parent constructor call ──
        // MUST be first line!
        super(color);
        this.radius = radius;
        System.out.println("Circle constructor: radius=" + radius);
    }

    @Override
    void draw() {
        // ── USE 2: super.method() — parent ki draw() bhi call karo ──
        super.draw();   // parent version
        System.out.println("Circle draw() — radius " + radius + " ka circle bana raha hai");
    }

    @Override
    double area() { return Math.PI * radius * radius; }

    void showTypes() {
        // ── USE 3: super.field — parent field access ──
        System.out.println("this.type  (Circle's own): " + this.type);
        System.out.println("super.type (Shape's):      " + super.type);
    }
}

class Rectangle extends Shape {
    double width, height;

    Rectangle(String color, double width, double height) {
        super(color);   // super() constructor
        this.width  = width;
        this.height = height;
    }

    @Override
    void draw() {
        super.draw();
        System.out.println("Rectangle draw() — " + width + "×" + height);
    }

    @Override
    double area() { return width * height; }
}

public class SuperKeyword {
    public static void main(String[] args) {
        System.out.println("=== Circle ===");
        Circle c = new Circle("Red", 7.5);
        c.draw();
        System.out.printf("Area: %.2f%n", c.area());
        c.showTypes();

        System.out.println("\n=== Rectangle ===");
        Rectangle r = new Rectangle("Blue", 5, 3);
        r.draw();
        System.out.printf("Area: %.2f%n", r.area());
    }
}

class BankAccount {
    protected String accountNo;
    protected String holderName;
    protected double balance;

    BankAccount(String accountNo, String holderName, double initialBalance) {
        this.accountNo   = accountNo;
        this.holderName  = holderName;
        this.balance     = initialBalance;
    }

    void deposit(double amount) {
        if (amount > 0) { balance += amount; System.out.println("✅ Deposit: ₹" + amount); }
        else System.out.println("❌ Invalid deposit amount");
    }

    void withdraw(double amount) {
        if (amount > 0 && amount <= balance) { balance -= amount; System.out.println("✅ Withdraw: ₹" + amount); }
        else System.out.println("❌ Insufficient balance or invalid amount");
    }

    void showBalance() {
        System.out.printf("Account: %s | Holder: %s | Balance: ₹%.2f%n",
            accountNo, holderName, balance);
    }
}

class SavingsAccount extends BankAccount {
    private double interestRate;  // annual %
    private static final double MIN_BALANCE = 1000.0;

    SavingsAccount(String accountNo, String holderName,
                   double balance, double interestRate) {
        super(accountNo, holderName, balance);  // parent constructor
        this.interestRate = interestRate;
    }

    @Override
    void withdraw(double amount) {
        if (balance - amount < MIN_BALANCE) {
            System.out.println("❌ Min balance ₹" + MIN_BALANCE + " maintain karna zaroori hai");
        } else {
            super.withdraw(amount);   // parent ki withdraw logic use karo
        }
    }

    void addInterest() {
        double interest = balance * interestRate / 100;
        balance += interest;
        System.out.printf("💰 Interest added: ₹%.2f (%.1f%%)%n", interest, interestRate);
    }

    @Override
    void showBalance() {
        super.showBalance();  // parent ka display
        System.out.println("   Interest Rate: " + interestRate + "%");
    }
}

public class BankSystem {
    public static void main(String[] args) {
        SavingsAccount acc = new SavingsAccount("SB-1001", "Priya Sharma", 15000.0, 4.5);

        acc.showBalance();
        acc.deposit(5000);
        acc.withdraw(18000);   // Min balance check
        acc.withdraw(5000);    // Valid
        acc.addInterest();
        acc.showBalance();
    }
}

class Animal {
    String name;

    Animal(String name) { this.name = name; }

    void makeSound() {
        System.out.println(name + ": .... (generic sound)");
    }

    void eat() {
        System.out.println(name + " khaana kha raha hai");
    }

    @Override
    public String toString() {
        return "Animal[" + name + "]";
    }
}

class Dog extends Animal {
    Dog(String name) { super(name); }

    @Override
    void makeSound() {
        System.out.println(name + ": Bhow Bhow! 🐕");
    }
    // eat() override nahi kiya — parent ka chalega
}

class Cat extends Animal {
    Cat(String name) { super(name); }

    @Override
    void makeSound() {
        System.out.println(name + ": Meow Meow! 🐱");
    }

    @Override
    void eat() {
        System.out.println(name + " machhli khaana pasand karta hai 🐟");
    }
}

class Cow extends Animal {
    Cow(String name) { super(name); }

    @Override
    void makeSound() {
        System.out.println(name + ": Moo Moo! 🐄");
    }
}

public class MethodOverriding {
    public static void main(String[] args) {
        // ── Direct object calls ──
        Dog dog = new Dog("Bruno");
        Cat cat = new Cat("Whiskers");
        Cow cow = new Cow("Gauri");

        dog.makeSound();
        cat.makeSound();
        cow.makeSound();

        System.out.println();
        dog.eat();  // Animal ka (not overridden)
        cat.eat();  // Cat ka (overridden)

        System.out.println("\n=== Runtime Polymorphism — Animal reference ===");
        // Animal reference mein Dog/Cat/Cow — Runtime decide hoga
        Animal[] animals = {
            new Dog("Rex"),
            new Cat("Kitty"),
            new Cow("Nandini"),
            new Animal("Unknown")
        };

        for (Animal a : animals) {
            a.makeSound();  // Kaunsa version? JVM runtime pe decide karega!
        }
    }
}

class Employee {
    protected String name;
    protected double basicSalary;
    protected String department;

    Employee(String name, double basicSalary, String dept) {
        this.name = name; this.basicSalary = basicSalary; this.department = dept;
    }

    double calculateSalary() {
        double hra  = basicSalary * 0.4;   // 40% HRA
        double da   = basicSalary * 0.1;   // 10% DA
        return basicSalary + hra + da;
    }

    void printPayslip() {
        System.out.println("┌─────────────────────────────┐");
        System.out.printf( "│ Name:    %-20s│%n", name);
        System.out.printf( "│ Dept:    %-20s│%n", department);
        System.out.printf( "│ Basic:   ₹%-19.2f│%n", basicSalary);
        System.out.printf( "│ TOTAL:   ₹%-19.2f│%n", calculateSalary());
        System.out.println("└─────────────────────────────┘");
    }
}

class Manager extends Employee {
    private double bonus;

    Manager(String name, double basicSalary, String dept, double bonus) {
        super(name, basicSalary, dept);
        this.bonus = bonus;
    }

    @Override
    double calculateSalary() {
        return super.calculateSalary() + bonus;  // parent + bonus
    }

    @Override
    void printPayslip() {
        super.printPayslip();
        System.out.printf("  [Manager Bonus: ₹%.2f]%n", bonus);
    }
}

class Director extends Manager {
    private double stockOptions;

    Director(String name, double basicSalary, String dept, double bonus, double stocks) {
        super(name, basicSalary, dept, bonus);
        this.stockOptions = stocks;
    }

    @Override
    double calculateSalary() {
        return super.calculateSalary() + stockOptions;
    }
}

public class EmployeeSystem {
    public static void main(String[] args) {
        Employee[] staff = {
            new Employee("Rahul Kumar", 40000, "Engineering"),
            new Manager("Priya Sharma", 80000, "Engineering", 20000),
            new Director("Amit Verma", 150000, "C-Suite", 50000, 100000)
        };

        for (Employee e : staff) {
            e.printPayslip();
            System.out.printf("  → Net Salary: ₹%.2f%n%n", e.calculateSalary());
        }
    }
}

// ── PARENT ──────────────────────────────────────────
class Person {
    protected String name;
    protected int    age;
    protected String email;

    Person(String name, int age, String email) {
        this.name = name; this.age = age; this.email = email;
    }

    void introduce() {
        System.out.println("Hello! Main " + name + " hoon (Age: " + age + ")");
    }

    void login() { System.out.println(name + " ne login kiya: " + email); }
}

// ── CHILD 1: Student ────────────────────────────────
class Student extends Person {
    String rollNo;
    String course;
    double cgpa;

    Student(String name, int age, String email, String rollNo, String course, double cgpa) {
        super(name, age, email);
        this.rollNo = rollNo; this.course = course; this.cgpa = cgpa;
    }

    void submitAssignment(String subject) {
        System.out.println(name + " ne " + subject + " assignment submit ki 📝");
    }

    void viewResult() {
        System.out.printf("Roll: %s | Course: %s | CGPA: %.1f%n", rollNo, course, cgpa);
    }
}

// ── CHILD 2: Teacher ────────────────────────────────
class Teacher extends Person {
    String subject;
    int    yearsExp;
    double salary;

    Teacher(String name, int age, String email, String subject, int exp, double salary) {
        super(name, age, email);
        this.subject = subject; this.yearsExp = exp; this.salary = salary;
    }

    void takeClass(String topic) {
        System.out.println("Prof. " + name + " " + subject + " class le raha hai: " + topic + " 📚");
    }

    void assignHomework(String task) {
        System.out.println(name + " ne homework diya: " + task);
    }
}

// ── CHILD 3: Admin ──────────────────────────────────
class Admin extends Person {
    String role;
    int    accessLevel;

    Admin(String name, int age, String email, String role, int level) {
        super(name, age, email);
        this.role = role; this.accessLevel = level;
    }

    void manageUsers(String action) {
        System.out.println("[ADMIN] " + name + " (" + role + "): " + action + " 🔧");
    }
}

public class SchoolSystem {
    public static void main(String[] args) {
        Student s = new Student("Riya", 20, "riya@school.com", "CS2024", "B.Tech CS", 8.9);
        Teacher t = new Teacher("Dr. Gupta", 45, "gupta@school.com", "Java", 15, 80000);
        Admin   a = new Admin("Suresh", 35, "suresh@school.com", "SuperAdmin", 10);

        // Inherited methods
        s.introduce(); s.login(); s.submitAssignment("Java Arrays"); s.viewResult();
        System.out.println();
        t.introduce(); t.login(); t.takeClass("Inheritance"); t.assignHomework("Override 5 methods");
        System.out.println();
        a.introduce(); a.login(); a.manageUsers("New student account create kiya");
    }
}

// ── final CLASS — extend nahi ho sakti ──
final class ImmutableConfig {
    final String DB_URL      = "jdbc:mysql://localhost/mydb";
    final int    PORT         = 8080;
    final String APP_NAME    = "MyJavaApp";

    void showConfig() {
        System.out.println("App:  " + APP_NAME);
        System.out.println("DB:   " + DB_URL);
        System.out.println("Port: " + PORT);
    }
}
// class ExtendedConfig extends ImmutableConfig {} // ❌ COMPILE ERROR

// ── Class with final METHODS ──
class Transaction {
    protected double amount;
    protected String txnId;

    static final double TAX_RATE = 0.18;  // static final = class-level constant

    Transaction(String txnId, double amount) {
        this.txnId = txnId; this.amount = amount;
    }

    // ── final METHOD — security critical, override nahi ho sakta ──
    final void applyGST() {
        double tax = amount * TAX_RATE;
        System.out.printf("TxnID: %s | Amount: ₹%.2f | GST(%.0f%%): ₹%.2f | Total: ₹%.2f%n",
            txnId, amount, TAX_RATE * 100, tax, amount + tax);
    }

    void process() {
        System.out.println("Processing transaction: " + txnId);
    }
}

class UPITransaction extends Transaction {
    String upiId;

    UPITransaction(String txnId, double amount, String upiId) {
        super(txnId, amount);
        this.upiId = upiId;
    }

    @Override
    void process() {
        System.out.println("UPI Payment to: " + upiId + " (₹" + amount + ")");
    }
    // applyGST() override karne ki koshish — COMPILE ERROR hoti
    // @Override void applyGST() {}  // ❌
}

public class FinalKeyword {
    public static void main(String[] args) {
        // final variable — local
        final int MAX = 100;
        // MAX = 200; // ❌ COMPILE ERROR — cannot assign to final variable
        System.out.println("MAX = " + MAX);

        ImmutableConfig cfg = new ImmutableConfig();
        cfg.showConfig();

        System.out.println("\nTAX_RATE (static final): " + Transaction.TAX_RATE);

        UPITransaction txn = new UPITransaction("TXN001", 2500.0, "user@paytm");
        txn.process();
        txn.applyGST();  // final method — parent ka hi chalega
    }
}

abstract class Shape {
    protected String color;
    private static int count = 0;

    Shape(String color) {
        this.color = color;
        count++;
    }

    // ── Abstract methods — child MUST implement ──
    abstract double area();
    abstract double perimeter();
    abstract String shapeName();

    // ── Concrete method — sab use kar sakte hain ──
    void displayInfo() {
        System.out.println("┌── " + shapeName() + " ──────────────────");
        System.out.printf( "│ Color:     %s%n", color);
        System.out.printf( "│ Area:      %.4f sq units%n", area());
        System.out.printf( "│ Perimeter: %.4f units%n", perimeter());
        System.out.println("└────────────────────────────");
    }

    static int getCount() { return count; }
}

class Circle extends Shape {
    private double radius;
    Circle(String color, double r) { super(color); this.radius = r; }

    @Override double area()      { return Math.PI * radius * radius; }
    @Override double perimeter() { return 2 * Math.PI * radius; }
    @Override String shapeName()  { return "Circle (r=" + radius + ")"; }
}

class Rectangle extends Shape {
    private double w, h;
    Rectangle(String color, double w, double h) { super(color); this.w=w; this.h=h; }

    @Override double area()      { return w * h; }
    @Override double perimeter() { return 2 * (w + h); }
    @Override String shapeName()  { return "Rectangle (" + w + "×" + h + ")"; }
}

class Triangle extends Shape {
    private double a, b, c;
    Triangle(String color, double a, double b, double c) {
        super(color); this.a=a; this.b=b; this.c=c;
    }

    @Override double perimeter() { return a + b + c; }
    @Override double area() {       // Heron's formula
        double s = perimeter() / 2;
        return Math.sqrt(s * (s-a) * (s-b) * (s-c));
    }
    @Override String shapeName() { return "Triangle ("+a+","+b+","+c+")"; }
}

public class AbstractClassDemo {
    public static void main(String[] args) {
        // Shape s = new Shape("Red"); // ❌ COMPILE ERROR — abstract class!

        Shape[] shapes = {
            new Circle("Red", 7),
            new Rectangle("Blue", 6, 4),
            new Triangle("Green", 3, 4, 5)
        };

        for (Shape s : shapes) {
            s.displayInfo();
        }

        System.out.println("Total shapes created: " + Shape.getCount());

        // Find largest area
        Shape largest = shapes[0];
        for (Shape s : shapes) if (s.area() > largest.area()) largest = s;
        System.out.println("Largest area: " + largest.shapeName());
    }
}

abstract class ReportGenerator {

    // ── TEMPLATE METHOD — FINAL! Order fixed hai ──
    final void generateReport() {
        System.out.println("\n=== " + getReportTitle() + " ===");
        fetchData();          // child implement karega
        processData();        // child implement karega
        formatOutput();       // child implement karega
        printSummary();       // concrete — sab same
        System.out.println("Report generation complete ✅");
    }

    // ── Abstract steps — child MUST define ──
    abstract String getReportTitle();
    abstract void fetchData();
    abstract void processData();
    abstract void formatOutput();

    // ── Concrete step — same for all ──
    void printSummary() {
        System.out.println("[Generated: " + java.time.LocalDate.now() + "]");
    }
}

class SalesReport extends ReportGenerator {
    @Override String getReportTitle() { return "MONTHLY SALES REPORT"; }
    @Override void fetchData()    { System.out.println("📊 Sales DB se data fetch kiya"); }
    @Override void processData()  { System.out.println("📈 Revenue calculations done"); }
    @Override void formatOutput()  { System.out.println("📋 Table format mein print kiya"); }
}

class InventoryReport extends ReportGenerator {
    @Override String getReportTitle() { return "INVENTORY STATUS REPORT"; }
    @Override void fetchData()    { System.out.println("📦 Warehouse DB se stock data"); }
    @Override void processData()  { System.out.println("🔢 Low stock items flag kiye"); }
    @Override void formatOutput()  { System.out.println("📄 CSV format mein export kiya"); }
}

public class TemplatePattern {
    public static void main(String[] args) {
        ReportGenerator[] reports = { new SalesReport(), new InventoryReport() };
        for (ReportGenerator r : reports) r.generateReport();
    }
}

// ── Interfaces — CAN-DO contracts ──
interface Flyable {
    int MAX_ALTITUDE = 10000;  // public static final (implicit)

    void fly();                // public abstract (implicit)
    void land();

    // Java 8+ default method — override optional
    default void glide() {
        System.out.println("Gliding at " + MAX_ALTITUDE/2 + " feet...");
    }
}

interface Swimmable {
    void swim();
    void dive();

    default void float_() {
        System.out.println("Floating on water surface 💧");
    }
}

interface Runnable {   // Note: different from java.lang.Runnable
    void run();
    void sprint();
}

// ── Duck: implements 2 interfaces ──
class Duck implements Flyable, Swimmable {
    String name;
    Duck(String name) { this.name = name; }

    @Override public void fly()  { System.out.println(name + " ud raha hai 🦆✈️"); }
    @Override public void land() { System.out.println(name + " utar raha hai"); }
    @Override public void swim() { System.out.println(name + " tair raha hai 🏊"); }
    @Override public void dive() { System.out.println(name + " gote laga raha hai 🤿"); }
}

// ── Eagle: implements 1 interface + Runnable ──
class Eagle implements Flyable, Runnable {
    String name;
    Eagle(String name) { this.name = name; }

    @Override public void fly()    { System.out.println(name + " bahut uuncha uda raha hai 🦅"); }
    @Override public void land()   { System.out.println(name + " shikaar pakad ke utra"); }
    @Override public void run()    { System.out.println(name + " daud raha hai 🏃"); }
    @Override public void sprint() { System.out.println(name + " bahut tez daud raha hai"); }

    @Override
    public void glide() {  // default method override kiya
        System.out.println(name + " eagle style mein glide kar raha hai 🦅");
    }
}

// ── Fish: only Swimmable ──
class Fish implements Swimmable {
    String name;
    Fish(String name) { this.name = name; }
    @Override public void swim() { System.out.println(name + " paani mein tair raha hai 🐟"); }
    @Override public void dive() { System.out.println(name + " gehraai mein gaya 🌊"); }
}

public class InterfaceDemo {
    public static void main(String[] args) {
        Duck duck   = new Duck("Donald");
        Eagle eagle = new Eagle("Sam");
        Fish fish   = new Fish("Nemo");

        System.out.println("=== Duck (Flyable + Swimmable) ===");
        duck.fly(); duck.swim(); duck.dive(); duck.glide(); // default method

        System.out.println("\n=== Eagle (Flyable + Runnable) ===");
        eagle.fly(); eagle.run(); eagle.glide(); // overridden default

        System.out.println("\n=== Fish (Swimmable only) ===");
        fish.swim(); fish.dive(); fish.float_(); // default method

        System.out.println("\n=== Interface reference use karo ===");
        Flyable[] fliers = { duck, eagle };
        for (Flyable f : fliers) f.fly();

        Swimmable[] swimmers = { duck, fish };
        for (Swimmable s : swimmers) s.swim();

        System.out.println("\nMAX_ALTITUDE constant: " + Flyable.MAX_ALTITUDE);
    }
}

// ── Interfaces ──────────────────────────────────────
interface PaymentProcessor {
    boolean processPayment(double amount, String recipient);
    boolean refund(String transactionId, double amount);
    String  getPaymentMode();

    default void printReceipt(double amount, boolean success) {
        System.out.printf("  [%s] %-10s ₹%.2f — %s%n",
            success ? "✅" : "❌", getPaymentMode(), amount,
            success ? "SUCCESS" : "FAILED");
    }
}

interface SecurePayment {
    boolean verifyOTP(String otp);
    void    generateOTP();
}

// ── UPI: implements both ─────────────────────────────
class UPIPayment implements PaymentProcessor, SecurePayment {
    private String upiId;
    UPIPayment(String upiId) { this.upiId = upiId; }

    @Override
    public boolean processPayment(double amount, String recipient) {
        System.out.println("  UPI: " + upiId + " → " + recipient);
        boolean ok = amount < 100000;
        printReceipt(amount, ok);  // default method
        return ok;
    }
    @Override
    public boolean refund(String txnId, double amount) {
        System.out.println("  UPI Refund: " + txnId + " → ₹" + amount);
        return true;
    }
    @Override public String  getPaymentMode() { return "UPI"; }
    @Override public void    generateOTP()     { System.out.println("  OTP sent to registered mobile"); }
    @Override public boolean verifyOTP(String otp) { return otp.equals("123456"); }
}

// ── Credit Card: only PaymentProcessor ──────────────
class CreditCardPayment implements PaymentProcessor {
    private String cardLast4;
    private double limit;
    CreditCardPayment(String last4, double limit) { this.cardLast4=last4; this.limit=limit; }

    @Override
    public boolean processPayment(double amount, String recipient) {
        System.out.println("  CC *" + cardLast4 + " → " + recipient);
        boolean ok = amount <= limit;
        printReceipt(amount, ok);
        if (ok) limit -= amount;
        return ok;
    }
    @Override
    public boolean refund(String txnId, double amount) {
        limit += amount; System.out.println("  CC Refund credited: ₹" + amount); return true;
    }
    @Override public String getPaymentMode() { return "CreditCard"; }
}

public class PaymentGateway {
    static void processOrder(PaymentProcessor processor, double amount, String to) {
        System.out.println("Processing ₹" + amount + " via " + processor.getPaymentMode());
        processor.processPayment(amount, to);
    }

    public static void main(String[] args) {
        UPIPayment         upi = new UPIPayment("user@okaxis");
        CreditCardPayment  cc  = new CreditCardPayment("4242", 50000);

        processOrder(upi, 2999.0, "Amazon");
        processOrder(cc,  15000.0, "Flipkart");

        System.out.println("\n--- UPI OTP Verification ---");
        upi.generateOTP();
        System.out.println("OTP Correct: " + upi.verifyOTP("123456"));

        System.out.println("\n--- Refunds ---");
        cc.refund("TXN999", 5000);
    }
}

class Animal {
    String name;
    Animal(String n) { name = n; }
    void makeSound() { System.out.println(name + ": generic sound"); }
    void eat()       { System.out.println(name + ": eating"); }
}

class Dog extends Animal {
    int tricks;
    Dog(String n, int t) { super(n); tricks = t; }
    @Override void makeSound() { System.out.println(name + ": Bhow Bhow! 🐕"); }
    void doTricks() { System.out.println(name + " jaanta hai " + tricks + " tricks!"); }
}

class Cat extends Animal {
    String breed;
    Cat(String n, String b) { super(n); breed = b; }
    @Override void makeSound() { System.out.println(name + ": Meow! 🐱"); }
    void purr() { System.out.println(name + "(" + breed + "): Purrrr..."); }
}

public class PolymorphismDemo {
    public static void main(String[] args) {

        // ── UPCASTING — automatic, always safe ──
        Animal a1 = new Dog("Bruno", 5);  // Dog → Animal reference
        Animal a2 = new Cat("Kitty", "Persian");
        Animal a3 = new Animal("Generic");

        System.out.println("=== Dynamic Dispatch ===");
        Animal[] animals = {a1, a2, a3};
        for (Animal a : animals) {
            a.makeSound();  // JVM decides at RUNTIME!
            a.eat();        // Animal ka method (not overridden)
        }

        System.out.println("\n=== DOWNCASTING with instanceof ===");
        for (Animal a : animals) {
            if (a instanceof Dog) {
                Dog d = (Dog) a;  // Safe downcasting
                d.doTricks();
            } else if (a instanceof Cat) {
                Cat c = (Cat) a;
                c.purr();
            } else {
                System.out.println(a.name + ": bas ek normal animal hai");
            }
        }

        System.out.println("\n=== Java 16+ Pattern Matching instanceof ===");
        for (Animal a : animals) {
            if (a instanceof Dog d) {        // Cast + variable ek line mein!
                System.out.println("Dog: " + d.tricks + " tricks");
            } else if (a instanceof Cat c) {
                System.out.println("Cat breed: " + c.breed);
            }
        }

        System.out.println("\n=== ClassCastException Example ===");
        try {
            Dog d = (Dog) a2;  // Cat ko Dog mein cast? RUNTIME EXCEPTION!
        } catch (ClassCastException e) {
            System.out.println("❌ ClassCastException: " + e.getMessage());
            System.out.println("✅ Hamesha instanceof check karo pehle!");
        }
    }
}

abstract class Notification {
    protected String recipient;
    protected String message;
    private static   int    sentCount = 0;

    Notification(String recipient, String message) {
        this.recipient = recipient;
        this.message   = message;
    }

    abstract void send();
    abstract String getChannel();

    final void deliver() {
        System.out.printf("[%s] Sending to %s...%n", getChannel(), recipient);
        send();
        sentCount++;
        System.out.println("  Status: DELIVERED ✅%n");
    }

    static int getSentCount() { return sentCount; }
}

class SMSNotification extends Notification {
    SMSNotification(String phone, String msg) { super(phone, msg); }
    @Override void send()          { System.out.println("  📱 SMS: " + message.substring(0, Math.min(message.length(), 50))); }
    @Override String getChannel()  { return "SMS"; }
}

class EmailNotification extends Notification {
    String subject;
    EmailNotification(String email, String subj, String body) {
        super(email, body); this.subject = subj;
    }
    @Override void send()         { System.out.println("  📧 Email Subject: " + subject + "\n     Body: " + message); }
    @Override String getChannel() { return "EMAIL"; }
}

class PushNotification extends Notification {
    String deviceToken;
    PushNotification(String token, String msg) { super(token, msg); this.deviceToken = token; }
    @Override void send()         { System.out.println("  🔔 Push: " + message + " → device " + deviceToken.substring(0,8) + "..."); }
    @Override String getChannel() { return "PUSH"; }
}

// ── Notification Service — polymorphism ka fayda ──
class NotificationService {
    static void sendAll(Notification... notifications) {
        System.out.println("=== Sending " + notifications.length + " notifications ===");
        for (Notification n : notifications) n.deliver();  // polymorphism!
        System.out.println("Total sent: " + Notification.getSentCount());
    }
}

public class NotificationDemo {
    public static void main(String[] args) {
        NotificationService.sendAll(
            new SMSNotification("+91-9876543210", "Your OTP is 123456. Valid 5 mins."),
            new EmailNotification("user@gmail.com", "Order Confirmed!", "Your order #123 has been placed."),
            new PushNotification("abc123def456xyz789", "Sale starts in 1 hour! 🛍️")
        );
    }
}