Definition

Java inner classes represent a mechanism where one class is defined within another class. These nested classes have access to the members of their enclosing class, including private fields and methods.

The primary categories include member inner classes, local inner classes, anonymous inner classes, and static nested classes.

Member Inner Classes

Definition

A member inner class is defined within the body of an outer class similar to how member variables are declared. It can access all members of the enclosing class including private ones.

Key Point: Member inner classes can unconditionally access all member properties and methods of the outer class, including private and static members.

Code Example

class Enclosing {
    private int enclosingField = 25;

    class NestedMember {
        void showValue() {
            System.out.println("Enclosing field value: " + enclosingField);
        }
    }
}

Note: To access members with the same name in the outer class, use:

OuterClass.this.memberVariable
OuterClass.this.memberMethod()

Creating Member Inner Class Instances

To instatniate a member inner class, you must first have an instance of the outer class.

First approach:

Enclosing container = new Enclosing();
Enclosing.NestedMember nested = container.new NestedMember();
nested.showValue();

Second approach:

Enclosing.NestedMember nestedInstance = container.getNestedInstance();

Access Control

Inner classes can utilize private, protected, public access modifiers, as well as package-level access.

Local Inner Classes

Definition

Local inner classes are defined within methods, constructors, or code blocks. Their scope is limited to the containing block where they are declared.

Code Example

class Enclosing {
    void someMethod() {
        class MethodInner {
            void showMessage() {
                System.out.println("This represents a method-local inner class");
            }
        }
        MethodInner methodInner = new MethodInner();
        methodInner.showMessage();
    }
}

Important: Local inner classes behave like local variables within methods and cannot use public, protected, private, or static modifiers.

Static Nested Classes

Definition

Static nested classes use the static keyword and don't depend on instances of the outer class. They can only access static members of the outer class.

Code Example

class Enclosing {
    private static int staticField = 42;

    static class StaticNested {
        void showStaticValue() {
            System.out.println("Enclosing static field: " + staticField);
        }
    }
}

Instantiation

Create static nested class instances directly through the outer class name:

Enclosing.StaticNested staticNested = new Enclosing.StaticNested();
staticNested.showStaticValue();

Note: Static nested classes don't require outer class instances, similar to static class members, and cannot access non-static members of the outer class.

Anonymous Inner Classes

Definition

Anonymous inner classes lack explicit names and provide a simplified way to define inner classes, commonly used for implementing interfaces or extending classes.

Code Example

interface MessageHandler {
    void processMessage();
}

class Enclosing {
    void execute() {
        MessageHandler handler = new MessageHandler() {
            public void processMessage() {
                System.out.println("Processing via anonymous implementation");
            }
        };
        handler.processMessage();
    }
}

Best Practices

• Commonly used for evant listener implementations
• Cannot have access modifiers or static modifiers
• The only class type without a constructor

Advanced Inner Class Concepts

Why Local and Anonymous Inner Classes Only Access Final Variables

When a method completes execution, its local variables cease to exist. However, objects created within that method might continue living beyond the method's lifecycle. To address this, Java creates copies of local variables.

Scenario: If a local variable's value can be deterimned at compile time, a copy is created directly within the anonymous inner class. For runtime-determined values, the compiler passes them as constructor parameters.

Challenge: Modifying the copied variable could lead to data inconsistency.

Solution: The Java compiler enforces that captured local variables must be final (or effectively final) to prevent modification.