Class ke Andar
Class — Deep Revision

// Member Inner Class - Sabse basic example
class Outer {
    private String outerMessage = "Hello from Outer!";
    private int outerData = 100;

    // Inner class — Outer ke andar
    class Inner {
        private String innerMessage = "Hello from Inner!";

        void showData() {
            // Inner class outer ke private members bhi access kar sakti hai!
            System.out.println("Outer message: " + outerMessage); // ✅ Works!
            System.out.println("Outer data: " + outerData);       // ✅ Works!
            System.out.println("Inner message: " + innerMessage);
        }
    }

    void outerMethod() {
        System.out.println("Outer method called");
        // Outer class inner ka object bana sakti hai
        Inner in = new Inner();
        in.showData();
    }
}

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

        // Step 1: Outer ka object banao
        Outer outer = new Outer();

        // Step 2: Outer ke through Inner ka object banao
        Outer.Inner inner = outer.new Inner();
        inner.showData();

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

        // Ya directly outer method call karo
        outer.outerMethod();
    }
}

class BankAccount {
    private String owner;
    private double balance;

    BankAccount(String owner, double initial) {
        this.owner   = owner;
        this.balance = initial;
    }

    // Member Inner Class — private balance directly access!
    class Transaction {
        void deposit(double amount) {
            balance += amount;  // outer ka private directly!
            System.out.println("[Deposit] +" + amount
                + " | Balance: " + balance + " | Owner: " + owner);
        }

        void withdraw(double amount) {
            if (balance >= amount) {
                balance -= amount;
                System.out.println("[Withdraw] -" + amount
                    + " | Balance: " + balance);
            } else {
                System.out.println("[Withdraw] Insufficient! Balance: " + balance);
            }
        }

        void printStatement() {
            System.out.println("Account: " + owner + " | Balance: Rs." + balance);
        }
    }
}

public class BankMember {
    public static void main(String[] args) {
        BankAccount acc = new BankAccount("Rahul", 5000);
        BankAccount.Transaction txn = acc.new Transaction();

        txn.printStatement();
        txn.deposit(2000);
        txn.withdraw(1500);
        txn.withdraw(8000);  // insufficient
        txn.printStatement();
    }
}

class SimpleList {
    private String listName;

    // Node as Member Inner Class
    class Node {
        String data;
        Node   next;

        Node(String data) {
            this.data = data;
            this.next = null;
        }
    }

    private Node head = null;

    SimpleList(String name) { this.listName = name; }

    void add(String item) {
        Node newNode = new Node(item);  // Inner directly!
        if (head == null) {
            head = newNode;
        } else {
            Node curr = head;
            while (curr.next != null) curr = curr.next;
            curr.next = newNode;
        }
        System.out.println("Added: " + item + " to " + listName);
    }

    void display() {
        System.out.print(listName + ": [");
        Node curr = head;
        while (curr != null) {
            System.out.print(curr.data
                + (curr.next != null ? " -> " : ""));
            curr = curr.next;
        }
        System.out.println("]");
    }
}

public class LinkedListDemo {
    public static void main(String[] args) {
        SimpleList fruits = new SimpleList("Fruits");
        fruits.add("Apple");
        fruits.add("Mango");
        fruits.add("Banana");
        fruits.display();

        System.out.println();

        SimpleList nums = new SimpleList("Numbers");
        nums.add("One");
        nums.add("Two");
        nums.add("Three");
        nums.display();
    }
}

class NumberCollection {
    private int[] numbers;
    private int   size = 0;

    NumberCollection(int capacity) {
        numbers = new int[capacity];
    }

    void add(int n) {
        if (size < numbers.length) numbers[size++] = n;
    }

    // Iterator — Member Inner Class
    class NumberIterator {
        private int index = 0;

        boolean hasNext() {
            return index < size;  // outer ka private 'size' access!
        }

        int next() {
            return numbers[index++];  // outer ka private 'numbers' access!
        }
    }

    NumberIterator getIterator() {
        return new NumberIterator();
    }
}

public class IteratorDemo {
    public static void main(String[] args) {
        NumberCollection col = new NumberCollection(5);
        col.add(10); col.add(20);
        col.add(30); col.add(40); col.add(50);

        NumberCollection.NumberIterator it = col.getIterator();

        System.out.print("Elements: ");
        while (it.hasNext()) {
            System.out.print(it.next() + " ");
        }
        System.out.println();

        // Another iterator — sum calculate
        NumberCollection.NumberIterator it2 = col.getIterator();
        int sum = 0;
        while (it2.hasNext()) sum += it2.next();
        System.out.println("Sum: " + sum);
    }
}

class OuterClass {
    int x = 10;  // Outer ka x
    String name = "Outer";

    class InnerClass {
        int x = 20;  // Inner ka x — same naam!
        String name = "Inner";

        void display() {
            // this.x = Inner ka x
            System.out.println("Inner x (this.x):        " + this.x);

            // Outer.this.x = Outer ka x
            System.out.println("Outer x (OuterClass.this.x): "
                + OuterClass.this.x);

            System.out.println("Inner name: " + this.name);
            System.out.println("Outer name: " + OuterClass.this.name);
        }

        void callOuterMethod() {
            // Inner outer ki methods directly call kar sakta hai
            outerHello();  // Outer ka method — direct access!
        }
    }

    void outerHello() {
        System.out.println("Hello from Outer!");
    }
}

public class OuterInnerAccess {
    public static void main(String[] args) {
        OuterClass outer = new OuterClass();
        OuterClass.InnerClass inner = outer.new InnerClass();

        inner.display();
        System.out.println();
        inner.callOuterMethod();
    }
}

// Static Inner Class — Outer ka object nahi chahiye!
class University {
    private String uniName = "ABC University"; // Non-static
    static String location = "Delhi";           // Static

    // Static Inner Class
    static class Department {
        String deptName;

        Department(String name) {
            this.deptName = name;
        }

        void showInfo() {
            // Static member access kar sakte hain ✅
            System.out.println("Location: " + location);
            // Non-static access nahi hoga ❌
            // System.out.println(uniName); // Error aayega!
            System.out.println("Department: " + deptName);
        }
    }
}

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

        // Outer ka object NAHI chahiye — Direct banao!
        University.Department d1 = new University.Department("Computer Science");
        University.Department d2 = new University.Department("Mathematics");

        d1.showInfo();
        System.out.println("---");
        d2.showInfo();

        // Static location change karo
        University.location = "Mumbai";
        System.out.println("\nAfter location change:");
        d1.showInfo(); // Naya location dikhega
    }
}

class Person {
    private final String name;
    private final int    age;
    private final String email;
    private final String phone;

    // Private constructor — sirf Builder use kare
    private Person(Builder b) {
        this.name  = b.name;
        this.age   = b.age;
        this.email = b.email;
        this.phone = b.phone;
    }

    void display() {
        System.out.println("Person{ name='" + name
            + "', age="   + age
            + ", email='" + email
            + "', phone='" + phone + "' }");
    }

    // Static Inner Class — Builder
    static class Builder {
        private String name  = "Unknown";
        private int    age   = 0;
        private String email = "N/A";
        private String phone = "N/A";

        Builder name(String n)  { this.name  = n; return this; }
        Builder age(int a)      { this.age   = a; return this; }
        Builder email(String e) { this.email = e; return this; }
        Builder phone(String p) { this.phone = p; return this; }

        Person build() { return new Person(this); }
    }
}

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

        // Method chaining — step by step build
        Person p1 = new Person.Builder()
            .name("Rahul")
            .age(25)
            .email("rahul@email.com")
            .phone("9876543210")
            .build();

        // Only some fields — baaki default
        Person p2 = new Person.Builder()
            .name("Priya")
            .age(22)
            .build();

        p1.display();
        p2.display();
    }
}

class AppConfig {
    static final String APP_VERSION = "2.1.0";
    static final String APP_NAME    = "MyApp";

    // Static Inner — Database configuration
    static class DatabaseConfig {
        String host;
        int    port;
        String dbName;

        DatabaseConfig(String host, int port, String db) {
            this.host   = host;
            this.port   = port;
            this.dbName = db;
        }

        void show() {
            System.out.println("[DB] App: " + APP_NAME
                + " v" + APP_VERSION);  // static access ✅
            System.out.println("     Host: " + host
                + ":" + port + "/" + dbName);
        }
    }

    // Static Inner — Server configuration
    static class ServerConfig {
        int    httpPort;
        String environment;

        ServerConfig(int port, String env) {
            this.httpPort    = port;
            this.environment = env;
        }

        void show() {
            System.out.println("[Server] App: " + APP_NAME);
            System.out.println("         Port: " + httpPort
                + " | Env: " + environment);
        }
    }
}

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

        // No AppConfig object needed!
        AppConfig.DatabaseConfig db =
            new AppConfig.DatabaseConfig("localhost", 3306, "shop_db");

        AppConfig.ServerConfig srv =
            new AppConfig.ServerConfig(8080, "production");

        db.show();
        System.out.println();
        srv.show();

        System.out.println("\nGlobal: " + AppConfig.APP_NAME
            + " v" + AppConfig.APP_VERSION);
    }
}

class MyMap {
    static int totalEntries = 0;

    // Static Inner — Map.Entry style
    static class Entry {
        String key;
        String value;

        Entry(String k, String v) {
            this.key   = k;
            this.value = v;
            totalEntries++;  // outer static access ✅
        }

        void print() {
            System.out.println("  [" + key + "] -> " + value
                + "  (total so far: " + totalEntries + ")");
        }
    }
}

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

        System.out.println("=== Student Marks ===");
        MyMap.Entry[] marks = {
            new MyMap.Entry("Rahul",  "92"),
            new MyMap.Entry("Priya",  "87"),
            new MyMap.Entry("Arjun",  "95")
        };

        for (MyMap.Entry e : marks) e.print();

        System.out.println("\n=== Capital Cities ===");
        MyMap.Entry india = new MyMap.Entry("India", "New Delhi");
        MyMap.Entry japan = new MyMap.Entry("Japan", "Tokyo");
        india.print();
        japan.print();

        System.out.println("\nTotal entries created: "
            + MyMap.totalEntries);
    }
}

// Local Inner Class — Method ke andar class banana
class Calculator {

    void calculate(int a, int b) {

        // Local Inner Class — sirf is method mein exist karti hai
        class MathHelper {
            int    add()      { return a + b; }  // Method ke variables use kar sakti hai
            int    subtract() { return a - b; }
            int    multiply() { return a * b; }
            double divide() {
                if (b == 0) {
                    System.out.println("Cannot divide by zero!");
                    return 0;
                }
                return (double) a / b;
            }
        }

        // MathHelper ka object banao (sirf is method ke andar)
        MathHelper helper = new MathHelper();

        System.out.println("Numbers: " + a + " and " + b);
        System.out.println("Add:      " + helper.add());
        System.out.println("Subtract: " + helper.subtract());
        System.out.println("Multiply: " + helper.multiply());
        System.out.println("Divide:   " + helper.divide());
    }
}

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

        Calculator calc = new Calculator();
        calc.calculate(10, 5);

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

        calc.calculate(8, 0); // Division by zero case

        // MathHelper helper = new MathHelper(); // ❌ Error! Method ke bahar nahi milega
    }
}

class ReportEngine {
    private String companyName = "TechCorp Ltd";

    void generateReport(String title, String[] data) {
        String divider = "================================";

        // Local Inner Class — sirf generateReport mein
        class Formatter {
            void printHeader() {
                System.out.println(divider);      // method variable ✅
                System.out.println("  " + companyName);  // outer private ✅
                System.out.println("  Report: " + title); // method param ✅
                System.out.println(divider);
            }
            void printRow(int num, String item) {
                System.out.printf("  %2d. %s%n", num, item);
            }
            void printFooter(int count) {
                System.out.println(divider);
                System.out.println("  Total records: " + count);
                System.out.println(divider);
            }
        }

        Formatter fmt = new Formatter();
        fmt.printHeader();
        for (int i = 0; i < data.length; i++)
            fmt.printRow(i + 1, data[i]);
        fmt.printFooter(data.length);
    }
}

public class LocalReport {
    public static void main(String[] args) {
        ReportEngine engine = new ReportEngine();

        String[] students = {"Rahul - 92", "Priya - 87", "Arjun - 95"};
        engine.generateReport("Student Scores", students);

        System.out.println();

        String[] products = {"Laptop - Rs.55000", "Phone - Rs.25000"};
        engine.generateReport("Product Inventory", products);
    }
}

class UserAuth {
    private String systemName = "SecureApp";

    boolean validatePassword(String password) {
        int minLength = 8;  // effectively final — local class access kar sakti hai

        // Local Inner Class — password checking rules
        class PasswordChecker {
            boolean hasMinLength() {
                return password.length() >= minLength; // both ✅
            }
            boolean hasUpperCase() {
                for (char c : password.toCharArray())
                    if (Character.isUpperCase(c)) return true;
                return false;
            }
            boolean hasDigit() {
                for (char c : password.toCharArray())
                    if (Character.isDigit(c)) return true;
                return false;
            }
            void report() {
                System.out.println("[" + systemName // outer private ✅
                    + "] Checking: '" + password + "'");
                System.out.println("  Length >= "
                    + minLength + ": " + hasMinLength());
                System.out.println("  Has uppercase: " + hasUpperCase());
                System.out.println("  Has digit:     " + hasDigit());
            }
        }

        PasswordChecker pc = new PasswordChecker();
        pc.report();
        return pc.hasMinLength() && pc.hasUpperCase() && pc.hasDigit();
    }
}

public class LocalValidator {
    public static void main(String[] args) {
        UserAuth auth = new UserAuth();

        boolean r1 = auth.validatePassword("abc");
        System.out.println("  Valid: " + r1 + "\n");

        boolean r2 = auth.validatePassword("MyPass1");
        System.out.println("  Valid: " + r2);
    }
}

// Anonymous Inner Class — 3 different ways

// 1. Abstract class ke liye
abstract class Animal {
    abstract void sound();

    void breathe() {
        System.out.println("Animal breathes oxygen");
    }
}

// 2. Interface ke liye
interface Greeting {
    void greet(String name);
}

// 3. Normal class ke liye (method override)
class Vehicle {
    void start() {
        System.out.println("Vehicle starts normally");
    }
}

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

        // ── Way 1: Abstract class ka anonymous implementation ──
        System.out.println("=== Abstract Class ===");

        Animal cat = new Animal() {  // Koi naam nahi, turant implement karo
            @Override
            void sound() {
                System.out.println("Cat says: Meow!");
            }
        };

        Animal dog = new Animal() {
            @Override
            void sound() {
                System.out.println("Dog says: Woof!");
            }
        };

        cat.sound();
        cat.breathe();
        dog.sound();

        // ── Way 2: Interface ka anonymous implementation ──
        System.out.println("\n=== Interface ===");

        Greeting hindiGreet = new Greeting() {
            @Override
            public void greet(String name) {
                System.out.println("Namaste, " + name + "!");
            }
        };

        Greeting englishGreet = new Greeting() {
            @Override
            public void greet(String name) {
                System.out.println("Hello, " + name + "!");
            }
        };

        hindiGreet.greet("Ali");
        englishGreet.greet("Ali");

        // ── Way 3: Normal class ka method override ──
        System.out.println("\n=== Normal Class Override ===");

        Vehicle sportsCar = new Vehicle() {
            @Override
            void start() {
                System.out.println("Sports car starts with ROAR!");
            }
        };

        Vehicle normalCar = new Vehicle();
        normalCar.start();   // Normal
        sportsCar.start();   // Overridden
    }
}

import java.util.Arrays;
import java.util.Comparator;

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

        Integer[] nums = {5, 2, 8, 1, 9, 3};

        // Ascending — anonymous Comparator
        Arrays.sort(nums, new Comparator<Integer>() {
            @Override
            public int compare(Integer a, Integer b) {
                return a - b;  // ascending
            }
        });
        System.out.print("Ascending:  ");
        for (int n : nums) System.out.print(n + " ");
        System.out.println();

        // Descending — another anonymous Comparator
        Arrays.sort(nums, new Comparator<Integer>() {
            @Override
            public int compare(Integer a, Integer b) {
                return b - a;  // descending
            }
        });
        System.out.print("Descending: ");
        for (int n : nums) System.out.print(n + " ");
        System.out.println();

        // String sort by length
        String[] words = {"Banana", "Apple", "Fig", "Mango", "Kiwi"};
        Arrays.sort(words, new Comparator<String>() {
            @Override
            public int compare(String a, String b) {
                return a.length() - b.length(); // shortest first
            }
        });
        System.out.print("By length:  ");
        for (String w : words) System.out.print(w + " ");
        System.out.println();
    }
}

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

        // Thread 1 — anonymous Runnable
        Thread t1 = new Thread(new Runnable() {
            @Override
            public void run() {
                for (int i = 1; i <= 3; i++)
                    System.out.println("[Thread-1] Step " + i);
            }
        });

        // Thread 2 — another anonymous Runnable
        Thread t2 = new Thread(new Runnable() {
            @Override
            public void run() {
                for (int i = 1; i <= 3; i++)
                    System.out.println("[Thread-2] Processing " + i);
            }
        });

        // Thread 3 — extend Thread anonymously
        Thread t3 = new Thread() {
            @Override
            public void run() {
                System.out.println("[Thread-3] Task complete!");
            }
        };

        t1.start();
        t2.start();
        t3.start();
    }
}

// Real world scenario — School System with all inner class types

class School {
    private String schoolName = "Sunrise School";
    static String board = "CBSE";

    // ── Type 1: Member Inner Class ──
    class Teacher {
        String teacherName;

        Teacher(String name) {
            this.teacherName = name;
        }

        void introduce() {
            // School ke private member access kar sakte hain
            System.out.println("I am " + teacherName +
                    ", teaching at " + schoolName +  // private access ✅
                    " (" + board + " board)");
        }
    }

    // ── Type 2: Static Inner Class ──
    static class Rules {
        void showRules() {
            System.out.println("Board: " + board);    // Static access ✅
            // schoolName access nahi hoga — non-static hai
            System.out.println("Rule 1: Uniform is mandatory");
            System.out.println("Rule 2: No mobile phones");
        }
    }

    // ── Type 3: Local Inner Class inside a method ──
    void calculateFees(int months) {
        int feePerMonth = 2000;

        class FeeCalculator {
            void show() {
                int total = months * feePerMonth;  // Method variables use ✅
                System.out.println("Months: " + months);
                System.out.println("Total Fee: Rs." + total);
                System.out.println("School: " + schoolName); // Outer access ✅
            }
        }

        FeeCalculator fc = new FeeCalculator();
        fc.show();
    }
}

// Interface for Anonymous class demo
interface Event {
    void celebrate();
}

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

        School school = new School();

        // Member Inner Class
        System.out.println("=== Teachers ===");
        School.Teacher t1 = school.new Teacher("Mr. Ali");
        School.Teacher t2 = school.new Teacher("Ms. Zara");
        t1.introduce();
        t2.introduce();

        // Static Inner Class — no school object needed
        System.out.println("\n=== School Rules ===");
        School.Rules rules = new School.Rules();
        rules.showRules();

        // Local Inner Class
        System.out.println("\n=== Fee Calculation ===");
        school.calculateFees(6);

        // Anonymous Inner Class
        System.out.println("\n=== School Events ===");
        Event sportsDay = new Event() {
            @Override
            public void celebrate() {
                System.out.println("Sports Day: Everyone plays and wins!");
            }
        };

        Event annualDay = new Event() {
            @Override
            public void celebrate() {
                System.out.println("Annual Day: Dance, Drama, and Music!");
            }
        };

        sportsDay.celebrate();
        annualDay.celebrate();
    }
}