Java Inner Classes - Complete Tutorial

// Outer Class
public class InnerClassesDemo {
    
    // Instance variable of outer class
    private String outerMessage = "Hello from Outer Class";
    private static String staticOuterMessage = "Static message from Outer Class";
    
    // === 1. INNER CLASS (Non-static nested class) ===
    class InnerClass {
        private String innerMessage = "Hello from Inner Class";
        
        // Inner class can access outer class members (including private)
        public void display() {
            System.out.println("Inner Class accessing:");
            System.out.println("  - Outer instance variable: " + outerMessage);
            System.out.println("  - Outer static variable: " + staticOuterMessage);
            System.out.println("  - Inner instance variable: " + innerMessage);
        }
        
        // Inner class can have its own methods
        public void innerMethod() {
            System.out.println("Inner class method called");
        }
    }
    
    // === 2. STATIC NESTED CLASS ===
    static class StaticNestedClass {
        private String nestedMessage = "Hello from Static Nested Class";
        
        public void display() {
            System.out.println("Static Nested Class accessing:");
            System.out.println("  - Outer static variable: " + staticOuterMessage);
            System.out.println("  - Nested instance variable: " + nestedMessage);
            // Cannot access non-static outer members directly
            // System.out.println("  - Outer instance variable: " + outerMessage); // ERROR
        }
    }
    
    // === 3. LOCAL CLASS (defined inside a method) ===
    public void demonstrateLocalClass() {
        // Local variable (must be effectively final to be accessed by local class)
        final String localVar = "Local variable in method";
        String effectivelyFinalVar = "Effectively final variable";
        
        // Local class definition inside method
        class LocalClass {
            private String localClassMessage = "Hello from Local Class";
            
            public void display() {
                System.out.println("Local Class accessing:");
                System.out.println("  - Outer instance variable: " + outerMessage);
                System.out.println("  - Outer static variable: " + staticOuterMessage);
                System.out.println("  - Local variable: " + localVar);
                System.out.println("  - Effectively final variable: " + effectivelyFinalVar);
                System.out.println("  - Local class variable: " + localClassMessage);
            }
        }
        
        // Create instance of local class and use it
        LocalClass local = new LocalClass();
        local.display();
    }
    
    // === 4. ANONYMOUS CLASS ===
    interface Greeting {
        void sayHello();
        void sayGoodbye();
    }
    
    public void demonstrateAnonymousClass() {
        // Anonymous class implementing Greeting interface
        Greeting anonymousGreeting = new Greeting() {
            private String greeting = "Hello from Anonymous Class";
            
            @Override
            public void sayHello() {
                System.out.println(greeting);
                System.out.println("Accessing outer variable: " + outerMessage);
            }
            
            @Override
            public void sayGoodbye() {
                System.out.println("Goodbye from Anonymous Class");
            }
            
            // Anonymous class can have additional methods (but can't call them from outside)
            public void extraMethod() {
                System.out.println("Extra method in anonymous class");
            }
        };
        
        anonymousGreeting.sayHello();
        anonymousGreeting.sayGoodbye();
        // anonymousGreeting.extraMethod(); // ERROR: Not part of Greeting interface
    }
    
    // === 5. LAMBDA EXPRESSION (Java 8+) ===
    @FunctionalInterface
    interface Calculator {
        int calculate(int a, int b);
    }
    
    public void demonstrateLambda() {
        // Lambda expression implementing Calculator interface
        Calculator adder = (a, b) -> a + b;
        Calculator multiplier = (a, b) -> a * b;
        
        System.out.println("Lambda Examples:");
        System.out.println("5 + 3 = " + adder.calculate(5, 3));
        System.out.println("5 * 3 = " + multiplier.calculate(5, 3));
        
        // Lambda with multiple statements
        Calculator complexCalculator = (a, b) -> {
            int result = a + b;
            result *= 2;
            return result;
        };
        System.out.println("(5 + 3) * 2 = " + complexCalculator.calculate(5, 3));
    }
    
    // Method to demonstrate all types
    public void demonstrateAll() {
        System.out.println("=== 1. INNER CLASS ===");
        InnerClass inner = new InnerClass();
        inner.display();
        inner.innerMethod();
        
        System.out.println("\n=== 2. STATIC NESTED CLASS ===");
        StaticNestedClass staticNested = new StaticNestedClass();
        staticNested.display();
        
        System.out.println("\n=== 3. LOCAL CLASS ===");
        demonstrateLocalClass();
        
        System.out.println("\n=== 4. ANONYMOUS CLASS ===");
        demonstrateAnonymousClass();
        
        System.out.println("\n=== 5. LAMBDA EXPRESSION ===");
        demonstrateLambda();
    }
    
    public static void main(String[] args) {
        InnerClassesDemo demo = new InnerClassesDemo();
        demo.demonstrateAll();
        
        System.out.println("\n=== Creating Inner Class Instance ===");
        // To create inner class instance, need outer class instance
        InnerClassesDemo.InnerClass inner = demo.new InnerClass();
        inner.display();
        
        System.out.println("\n=== Creating Static Nested Class Instance ===");
        // Static nested class can be created without outer class instance
        InnerClassesDemo.StaticNestedClass staticNested = new InnerClassesDemo.StaticNestedClass();
        staticNested.display();
        
        System.out.println("\n=== Key Differences ===");
        System.out.println("Inner Class:");
        System.out.println("- Associated with outer class instance");
        System.out.println("- Can access outer instance members");
        System.out.println("- Created with: outerInstance.new InnerClass()");
        
        System.out.println("\nStatic Nested Class:");
        System.out.println("- Not associated with outer instance");
        System.out.println("- Can only access outer static members");
        System.out.println("- Created with: new OuterClass.StaticNestedClass()");
    }
}

public class InnerVsStaticComparison {
    
    // Outer class with both instance and static members
    private String outerInstanceField = "Instance Field";
    private static String outerStaticField = "Static Field";
    private int outerCounter = 0;
    private static int staticCounter = 0;
    
    // === INNER CLASS (Non-static) ===
    class InnerClass {
        // Cannot have static declarations (except constants)
        // private static int x = 10; // COMPILE ERROR
        private static final int CONSTANT = 100; // Allowed (constant)
        
        private String innerField = "Inner Field";
        
        public InnerClass() {
            outerCounter++; // Can modify outer instance field
            staticCounter++; // Can modify outer static field
        }
        
        public void display() {
            System.out.println("=== Inner Class ===");
            System.out.println("Accessing outer instance field: " + outerInstanceField);
            System.out.println("Accessing outer static field: " + outerStaticField);
            System.out.println("Outer counter: " + outerCounter);
            System.out.println("Static counter: " + staticCounter);
            System.out.println("Inner field: " + innerField);
            System.out.println("Constant: " + CONSTANT);
            
            // Can call outer instance methods
            outerMethod();
            // Can call outer static methods
            staticOuterMethod();
        }
        
        // Inner class method accessing outer's private method
        public void accessOuterPrivate() {
            privateOuterMethod(); // Can access private outer method
        }
    }
    
    // === STATIC NESTED CLASS ===
    static class StaticNestedClass {
        // Can have static members
        private static int staticNestedCounter = 0;
        private String nestedField = "Nested Field";
        
        public StaticNestedClass() {
            staticNestedCounter++;
            staticCounter++; // Can modify outer static field
            // outerCounter++; // COMPILE ERROR: Cannot access instance field
        }
        
        public void display() {
            System.out.println("\n=== Static Nested Class ===");
            // System.out.println("Accessing outer instance field: " + outerInstanceField); // ERROR
            System.out.println("Accessing outer static field: " + outerStaticField);
            System.out.println("Static counter: " + staticCounter);
            System.out.println("Static nested counter: " + staticNestedCounter);
            System.out.println("Nested field: " + nestedField);
            
            // staticOuterMethod(); // Can call outer static methods
            // outerMethod(); // ERROR: Cannot call instance methods
            
            // Need outer instance to access instance members
            InnerVsStaticComparison outer = new InnerVsStaticComparison();
            System.out.println("Via outer instance: " + outer.outerInstanceField);
            outer.outerMethod();
        }
        
        // Static method in static nested class
        public static void staticNestedMethod() {
            System.out.println("Static method in static nested class");
            System.out.println("Outer static field: " + outerStaticField);
        }
    }
    
    // Outer class methods
    public void outerMethod() {
        System.out.println("Outer instance method called");
    }
    
    private void privateOuterMethod() {
        System.out.println("Private outer method called from inner class");
    }
    
    public static void staticOuterMethod() {
        System.out.println("Outer static method called");
    }
    
    // Method to demonstrate memory implications
    public void demonstrateMemory() {
        System.out.println("\n=== Memory Implications ===");
        
        // Creating multiple inner class instances
        System.out.println("Creating 5 inner class instances:");
        for (int i = 0; i < 5; i++) {
            InnerClass inner = new InnerClass();
            inner.display();
        }
        
        System.out.println("\nCreating 5 static nested class instances:");
        for (int i = 0; i < 5; i++) {
            StaticNestedClass nested = new StaticNestedClass();
            nested.display();
        }
        
        System.out.println("\n=== Key Memory Differences ===");
        System.out.println("Inner Class:");
        System.out.println("- Each instance holds reference to outer instance");
        System.out.println("- Cannot exist without outer instance");
        System.out.println("- Can cause memory leaks if outer instance is held");
        
        System.out.println("\nStatic Nested Class:");
        System.out.println("- No reference to outer instance");
        System.out.println("- Can exist independently");
        System.out.println("- More memory efficient");
    }
    
    // Real-world example: Collection with Iterator
    class SimpleCollection {
        private String[] items;
        private int size;
        
        public SimpleCollection(int capacity) {
            items = new String[capacity];
            size = 0;
        }
        
        public void add(String item) {
            if (size < items.length) {
                items[size++] = item;
            }
        }
        
        // Inner class for iterator (needs access to collection's internal array)
        class Iterator {
            private int currentIndex = 0;
            
            public boolean hasNext() {
                return currentIndex < size;
            }
            
            public String next() {
                if (hasNext()) {
                    return items[currentIndex++];
                }
                throw new java.util.NoSuchElementException();
            }
            
            public void remove() {
                // Implementation needs access to items array
                // This is why iterator is often an inner class
            }
        }
        
        public Iterator iterator() {
            return new Iterator();
        }
    }
    
    // Real-world example: Builder pattern with static nested class
    static class Computer {
        private String CPU;
        private String RAM;
        private String storage;
        private String GPU;
        
        private Computer(Builder builder) {
            this.CPU = builder.CPU;
            this.RAM = builder.RAM;
            this.storage = builder.storage;
            this.GPU = builder.GPU;
        }
        
        // Static nested class for Builder
        static class Builder {
            private String CPU;
            private String RAM;
            private String storage;
            private String GPU;
            
            public Builder setCPU(String CPU) {
                this.CPU = CPU;
                return this;
            }
            
            public Builder setRAM(String RAM) {
                this.RAM = RAM;
                return this;
            }
            
            public Builder setStorage(String storage) {
                this.storage = storage;
                return this;
            }
            
            public Builder setGPU(String GPU) {
                this.GPU = GPU;
                return this;
            }
            
            public Computer build() {
                return new Computer(this);
            }
        }
        
        @Override
        public String toString() {
            return "Computer [CPU=" + CPU + ", RAM=" + RAM + 
                   ", Storage=" + storage + ", GPU=" + GPU + "]";
        }
    }
    
    public static void main(String[] args) {
        InnerVsStaticComparison demo = new InnerVsStaticComparison();
        
        System.out.println("=== Creating and Using Inner Class ===");
        // Inner class requires outer instance
        InnerVsStaticComparison.InnerClass inner = demo.new InnerClass();
        inner.display();
        inner.accessOuterPrivate();
        
        System.out.println("\n=== Creating and Using Static Nested Class ===");
        // Static nested class doesn't need outer instance
        InnerVsStaticComparison.StaticNestedClass staticNested = 
            new InnerVsStaticComparison.StaticNestedClass();
        staticNested.display();
        StaticNestedClass.staticNestedMethod();
        
        // Demonstrate memory implications
        demo.demonstrateMemory();
        
        System.out.println("\n=== Real-World Examples ===");
        
        // Collection with Iterator (Inner Class)
        System.out.println("\n1. Collection with Iterator (Inner Class):");
        SimpleCollection collection = demo.new SimpleCollection(5);
        collection.add("Apple");
        collection.add("Banana");
        collection.add("Cherry");
        
        SimpleCollection.Iterator iterator = collection.iterator();
        while (iterator.hasNext()) {
            System.out.println("Item: " + iterator.next());
        }
        
        // Computer Builder (Static Nested Class)
        System.out.println("\n2. Computer Builder (Static Nested Class):");
        Computer computer = new Computer.Builder()
            .setCPU("Intel i9")
            .setRAM("32GB")
            .setStorage("1TB SSD")
            .setGPU("RTX 4080")
            .build();
        System.out.println(computer);
        
        System.out.println("\n=== When to Use Which? ===");
        System.out.println("Use INNER CLASS when:");
        System.out.println("- Class needs access to outer instance state");
        System.out.println("- Implementing iterator/adapter pattern");
        System.out.println("- Class is tightly coupled to outer instance");
        System.out.println("- You need callback with access to outer state");
        
        System.out.println("\nUse STATIC NESTED CLASS when:");
        System.out.println("- Class is logically related but independent");
        System.out.println("- Implementing builder pattern");
        System.out.println("- Creating utility/helper classes");
        System.out.println("- No need to access outer instance state");
        System.out.println("- Better memory efficiency needed");
        
        System.out.println("\n=== Best Practice ===");
        System.out.println("Default to static nested class unless you need");
        System.out.println("access to outer instance members. This reduces");
        System.out.println("memory overhead and coupling.");
    }
}

import java.io.*;
import java.util.*;

public class InnerClassesChecklist {
    
    public static void innerClassesChecklist() {
        System.out.println("=== INNER CLASSES IMPLEMENTATION CHECKLIST ===\n");
        
        System.out.println("✅ 1. Choose the Right Type");
        System.out.println("   - Does it need access to outer instance? → Inner Class");
        System.out.println("   - Is it logically related but independent? → Static Nested");
        System.out.println("   - Used only in one method? → Local Class");
        System.out.println("   - One-time implementation? → Anonymous/Lambda");
        
        System.out.println("\n✅ 2. Memory Considerations");
        System.out.println("   - Inner classes hold reference to outer (potential leaks)");
        System.out.println("   - Static nested classes are more memory efficient");
        System.out.println("   - Consider weak references if needed");
        
        System.out.println("\n✅ 3. Serialization Readiness");
        System.out.println("   - Inner classes have synthetic fields");
        System.out.println("   - May need custom readObject/writeObject");
        System.out.println("   - Consider static nested classes for serialization");
        
        System.out.println("\n✅ 4. Access Control");
        System.out.println("   - Use appropriate access modifiers");
        System.out.println("   - Private inner classes for implementation details");
        System.out.println("   - Protected for extension in same package");
        
        System.out.println("\n✅ 5. Testing Strategy");
        System.out.println("   - Test inner classes independently when possible");
        System.out.println("   - Mock outer instance for inner class testing");
        System.out.println("   - Test serialization if required");
        
        System.out.println("\n✅ 6. Documentation");
        System.out.println("   - Document relationship to outer class");
        System.out.println("   - Explain when to use static vs non-static");
        System.out.println("   - Note any serialization considerations");
        
        System.out.println("\n✅ 7. Code Review Points");
        System.out.println("   - Is nesting necessary?");
        System.out.println("   - Could it be a top-level class?");
        System.out.println("   - Is the coupling appropriate?");
    }
    
    // Example: Well-designed inner class usage
    
    // Outer class designed for extension with inner classes
    static abstract class DataProcessor {
        protected String dataSource;
        
        public DataProcessor(String dataSource) {
            this.dataSource = dataSource;
        }
        
        // Template method using inner class
        public final void process() {
            Validator validator = createValidator();
            if (!validator.validate()) {
                throw new IllegalArgumentException("Invalid data");
            }
            
            Processor processor = createProcessor();
            processor.processData();
            
            Notifier notifier = createNotifier();
            notifier.notifyCompletion();
        }
        
        // Factory methods to be implemented by subclasses
        protected abstract Validator createValidator();
        protected abstract Processor createProcessor();
        protected abstract Notifier createNotifier();
        
        // Inner interface for validator
        protected interface Validator {
            boolean validate();
        }
        
        // Inner interface for processor
        protected interface Processor {
            void processData();
        }
        
        // Inner interface for notifier
        protected interface Notifier {
            void notifyCompletion();
        }
    }
    
    // Concrete implementation
    static class FileProcessor extends DataProcessor {
        
        public FileProcessor(String filePath) {
            super(filePath);
        }
        
        @Override
        protected Validator createValidator() {
            // Local class for file validation
            class FileValidator implements Validator {
                @Override
                public boolean validate() {
                    File file = new File(dataSource);
                    return file.exists() && file.canRead();
                }
            }
            return new FileValidator();
        }
        
        @Override
        protected Processor createProcessor() {
            // Lambda for simple processing
            return () -> {
                System.out.println("Processing file: " + dataSource);
                // Actual file processing logic
            };
        }
        
        @Override
        protected Notifier createNotifier() {
            // Anonymous class for notification
            return new Notifier() {
                @Override
                public void notifyCompletion() {
                    System.out.println("File processing completed: " + dataSource);
                    // Additional notification logic
                }
            };
        }
    }
    
    // Example: Avoiding common pitfalls
    
    static class PitfallExamples {
        
        // PITFALL 1: Memory leak with inner class
        static class MemoryLeakExample {
            private byte[] largeData = new byte[1000000]; // 1MB
            private List callbacks = new ArrayList<>();
            
            // Inner class holding reference to outer
            class Callback implements Runnable {
                @Override
                public void run() {
                    System.out.println("Callback using: " + largeData.length);
                }
            }
            
            public void addCallback() {
                callbacks.add(new Callback()); // Keeps reference to outer instance
            }
            
            // Solution: Use static nested class with weak reference
            static class SafeCallback implements Runnable {
                private WeakReference outerRef;
                
                SafeCallback(MemoryLeakExample outer) {
                    this.outerRef = new WeakReference<>(outer);
                }
                
                @Override
                public void run() {
                    MemoryLeakExample outer = outerRef.get();
                    if (outer != null) {
                        System.out.println("Safe callback");
                    }
                }
            }
        }
        
        // PITFALL 2: Serialization issues
        static class SerializationExample implements Serializable {
            private String data = "Important Data";
            
            // Non-static inner class - serialization problem!
            class InnerData implements Serializable {
                private String inner = "Inner Data";
            }
            
            // Solution: Make it static
            static class SerializableData implements Serializable {
                private String data = "Serializable Data";
            }
        }
        
        // PITFALL 3: Overly complex anonymous class
        static class ComplexAnonymous {
            public void problematicMethod() {
                // Too complex for anonymous class
                Runnable complexTask = new Runnable() {
                    private int state = 0;
                    private List buffer = new ArrayList<>();
                    
                    @Override
                    public void run() {
                        // 50 lines of complex logic...
                        System.out.println("Too complex for anonymous class");
                    }
                    
                    private void helperMethod() {
                        // Even more complexity...
                    }
                };
                
                // Solution: Extract to named class
                complexTask.run();
            }
            
            // Better: Extract to static nested class
            static class ComplexTask implements Runnable {
                private int state = 0;
                private List buffer = new ArrayList<>();
                
                @Override
                public void run() {
                    // Complex logic here
                }
                
                private void helperMethod() {
                    // Helper methods
                }
            }
        }
    }
    
    public static void main(String[] args) {
        innerClassesChecklist();
        
        System.out.println("\n=== EXAMPLE: WELL-DESIGNED DATA PROCESSOR ===\n");
        
        DataProcessor processor = new FileProcessor("data.txt");
        processor.process();
        
        System.out.println("\n=== COMMON PITFALLS AND SOLUTIONS ===\n");
        
        System.out.println("PITFALL 1: Memory Leaks");
        System.out.println("Problem: Inner classes hold strong references to outer");
        System.out.println("Solution: Use static nested classes with WeakReference");
        
        System.out.println("\nPITFALL 2: Serialization Issues");
        System.out.println("Problem: Inner classes have synthetic fields");
        System.out.println("Solution: Use static nested classes for serialization");
        
        System.out.println("\nPITFALL 3: Anonymous Class Complexity");
        System.out.println("Problem: Large anonymous classes are hard to read/maintain");
        System.out.println("Solution: Extract to named static nested class");
        
        System.out.println("\nPITFALL 4: Static Context Errors");
        System.out.println("Problem: Trying to access instance members from static nested class");
        System.out.println("Solution: Pass outer instance as parameter if needed");
        
        System.out.println("\nPITFALL 5: Capturing Mutable Variables");
        System.out.println("Problem: Modifying captured variables in lambda/local class");
        System.out.println("Solution: Use atomic references or avoid modification");
        
        System.out.println("\n=== FINAL RECOMMENDATIONS ===\n");
        System.out.println("1. Prefer static nested classes over inner classes");
        System.out.println("2. Use lambdas instead of anonymous classes when possible");
        System.out.println("3. Keep inner classes small and focused");
        System.out.println("4. Be mindful of memory and serialization implications");
        System.out.println("5. Document the design decisions for inner classes");
        System.out.println("6. Test inner classes thoroughly, especially for memory leaks");
        
        System.out.println("\n=== WHEN TO REEVALUATE ===\n");
        System.out.println("Consider moving to top-level class when:");
        System.out.println("- Inner class grows beyond 100 lines");
        System.out.println("- Inner class is used by multiple outer classes");
        System.out.println("- Inner class has complex dependencies");
        System.out.println("- Testing becomes difficult");
    }
}