Java defines four specific structures for nesting class definitions within an outer scope: member inner classes, static nested classes, local inner classes, and anonymous inner classes. Among these, anonymous implementations are frequently utilized for calback mechanisms and event handling.

Member Inner Classes

When a class is declared within the instance scope of another class without the static modifier, it is termed a member inner class. This structure allows the inner class to maintain an implicit reference to the enclosing instance.

A key characteristic of member inner classes is their ability to access all members of the outer class, including private fields and static variables, without restriction.

public class FinancialSystem {

    private double balance = 0.0;
    public static String currency = "USD";

    public FinancialSystem(double initialBalance) {
        this.balance = initialBalance;
    }

    public class TransactionLog {
        public void recordActivity() {
            // Accessing private instance variable
            System.out.println("Current Balance: " + balance);
            // Accessing static variable
            System.out.println("Currency Type: " + currency);
        }
    }
}

Conversely, the outer class cannot directly access members of the inner class. An instance of the inner class must be instantiated first.

public class FinancialSystem {

    private double balance = 0.0;

    public FinancialSystem(double initialBalance) {
        this.balance = initialBalance;
        // Instantiating the inner class to use its methods
        obtainLogger().recordActivity();
    }

    private TransactionLog obtainLogger() {
        return new TransactionLog();
    }

    public class TransactionLog {
        public void recordActivity() {
            System.out.println("Balance: " + balance);
        }
    }
}

Static Nested Classes

If a nested class is declared with the static keyword, it becomes a static nested class. Unlike member inner classes, static nested classes do not hold an implicit reference to an instance of the outer class.

Consequently, static nested classes can only access static members of the outer class. Attempting to access instance variables directly will result in a compilation error.

public class CloudInfrastructure {

    private String instanceId = "inst-123";
    private static String region = "us-east-1";

    private static class RegionConfig {
        public void displayConfig() {
            // Cannot access instanceId without an outer instance
            // System.out.println(instanceId); 
            
            // Can access static members directly
            System.out.println("Region: " + region);
        }
    }
}

Similar to member inner classes, the outer class requires an instance of the static nested class to access its instance members. However, if the nested class contains static members, they can be accessed via the class name directly.

public class CloudInfrastructure {
    
    private static class RegionConfig {
        private String configValue = "dynamic";
        private static String staticValue = "fixed";
    }

    public void checkConfig() {
        // Instance variable requires object instantiation
        System.out.println(new RegionConfig().configValue);
        
        // Static variable accessed via class name
        System.out.println(RegionConfig.staticValue);
    }
}

Local Inner Classes

Local inner classes are defined within a method body or a specific block scope. Their visibility is restricted strictly to the block in which they are declared. Like local variables, they cannot be declared with access modifiers such as public or private.

public class DataPipeline {
    public void executeProcess() {
        System.out.println("--- Starting Pipeline ---");
        
        class ValidationRule {
            public void verify() {
                System.out.println("Validating data integrity");
            }
        }
        
        new ValidationRule().verify();
    }
}

Anonymous Inner Classes

Anonymous inner classes allow for the immediate creation of a subclass or implementation of an interface without explicitly naming the class. This reduces boilerplate code when a class is used only once.

public class EventManager {
    public void triggerEvent() {
        System.out.println("--- Event Triggered ---");
        
        new EventHandler() {
            public void onActivate() {
                System.out.println("Handling event anonymously");
            }
        }.onActivate();
    }
}

interface EventHandler {
    void onActivate();
}

Compilation and Internal Mechanics

Access Privileges in Member Inner Classes

Examining the compiled bytecode reveals that the nested relationship does not exist at the runtime level. The compiler generates separate .class files for each class, naming the inner class file as OuterClass$InnerClass.class.

Decompiling the member inner class reveals that the compiler injects a synthetic field, typically named this$0, which holds a reference to the enclosing outer class instance. Additionally, a synthetic constructor is created that accepts the outer class instance as a parameter. To access private members of the outer class, the compiler generates synthetic accessor methods (e.g., access$000).

// Representation of compiled structure
class FinancialSystem$TransactionLog {
    private FinancialSystem this$0;
    
    private FinancialSystem$TransactionLog(FinancialSystem outerInstance) {
        this.this$0 = outerInstance;
    }
    
    public void recordActivity() {
        // Uses synthetic accessor to read private field
        System.out.println(FinancialSystem.access$000(this.this$0));
    }
}

This mechanism confirms that member inner classes are tightly coupled to the outer instance. Without an existing outer object, the this$0 reference cannot be initialized, preventing the instantiation of the inner class.

Outer Class Access to Inner Members

While inner classes can access outer members freely, the outer class must instantiate the inner class to access its members. The compiler does not automatically generate an instance of the inner class within the outer class constructor.

Compiled output shows that the outer class treats the inner class as a separate type, requiring explicit instantiation logic.

Distinctions and Instantiation

1. File Generation: All four types generate independent .class files. Except for static nested classes, the compiler adds a reference to the outer instance for the others.
2. Static Restrictions: Member, local, and anonymous inner classes cannot define static members (unless they are constant variables). Static nested classes can define static members freely.
3. External Instantiation:
   • Member Inner Class: Requires an instance of the outer class.

     FinancialSystem system = new FinancialSystem(100.0);
     FinancialSystem.TransactionLog log = system.new TransactionLog();
     

   • Static Nested Class: Does not require an outer instance.

     CloudInfrastructure.RegionConfig config = new CloudInfrastructure.RegionConfig();
     

Understanding these structural differences ensures correct usage of nested classes depending on whether access to the outer instance state is required.