8.1 Inner Classes

Inner classes are classes defined within other classes. They have access to all members of the outer class, including private members.

Types of Inner Classes

1. Non-static nested classes (Inner classes)
2. Static nested classes
3. Local classes (defined within methods)
4. Anonymous classes (without name)

Non-static Inner Class

class Outer {
    private String outerField = "Outer field";

    class Inner {
        private String innerField = "Inner field";

        public void display() {
            // Inner class can access outer class private members
            System.out.println("Outer field: " + outerField);
            System.out.println("Inner field: " + innerField);
        }
    }

    public void createInner() {
        Inner inner = new Inner();
        inner.display();
    }
}

public class InnerClassDemo {
    public static void main(String[] args) {
        Outer outer = new Outer();
        outer.createInner();

        // Creating inner class from outside
        Outer.Inner inner = outer.new Inner();
        inner.display();
    }
}

Static Nested Class

class Outer {
    private static String staticField = "Static field";
    private String instanceField = "Instance field";

    static class StaticNested {
        public void display() {
            System.out.println("Static field: " + staticField);
            // Cannot access instanceField directly
            // System.out.println(instanceField);  // Error
        }
    }
}

public class StaticNestedDemo {
    public static void main(String[] args) {
        // No need for outer class instance
        Outer.StaticNested nested = new Outer.StaticNested();
        nested.display();
    }
}

Local Inner Class

class Outer {
    private String outerField = "Outer field";

    public void methodWithLocalClass() {
        final String localVar = "Local variable";

        // Local class defined inside method
        class LocalClass {
            public void display() {
                System.out.println("Outer field: " + outerField);
                System.out.println("Local variable: " + localVar);
            }
        }

        LocalClass local = new LocalClass();
        local.display();
    }
}

Anonymous Inner Class

interface Greeting {
    void sayHello();
}

class AnonymousClassDemo {
    public static void main(String[] args) {
        // Anonymous class implementing interface
        Greeting greeting = new Greeting() {
            @Override
            public void sayHello() {
                System.out.println("Hello from anonymous class!");
            }
        };

        greeting.sayHello();

        // Anonymous class extending class
        Thread thread = new Thread() {
            @Override
            public void run() {
                System.out.println("Thread running from anonymous class");
            }
        };

        thread.start();
    }
}

Practical Inner Class Example

// Data structure using inner classes
class LinkedList {
    private Node head;

    // Static nested class for Node
    private static class Node {
        private int data;
        private Node next;

        public Node(int data) {
            this.data = data;
        }
    }

    // Inner class for Iterator
    public class Iterator {
        private Node current;

        public Iterator() {
            this.current = head;
        }

        public boolean hasNext() {
            return current != null;
        }

        public int next() {
            int data = current.data;
            current = current.next;
            return data;
        }
    }

    public void add(int data) {
        Node newNode = new Node(data);
        if (head == null) {
            head = newNode;
        } else {
            Node current = head;
            while (current.next != null) {
                current = current.next;
            }
            current.next = newNode;
        }
    }

    public Iterator getIterator() {
        return new Iterator();
    }
}

public class LinkedListDemo {
    public static void main(String[] args) {
        LinkedList list = new LinkedList();
        list.add(10);
        list.add(20);
        list.add(30);

        LinkedList.Iterator iterator = list.getIterator();
        while (iterator.hasNext()) {
            System.out.println(iterator.next());
        }
    }
}