Static Nested Class

A static nested class in Java is a static member of an enclosing class that behaves structurally and behaviorally like a standard top-level class, but is nested within another class’s namespace. Because it is declared static, it does not maintain an implicit reference to an instance of its enclosing class.

public class OuterClass {
    private static int staticOuterField = 10;
    private int instanceOuterField = 20;

    // Static Nested Class declaration
    public static class StaticNestedClass {
        private int nestedField;
        
        public void display() {
            // Can access private static members of the enclosing class
            System.out.println(staticOuterField); 
            
            // COMPILATION ERROR: Cannot make a static reference to the non-static field
            // System.out.println(instanceOuterField); 
        }
    }
}

Key Characteristics

• Memory and Reference: A static nested class does not require an instance of the enclosing class to be instantiated. It exists independently of any outer class instances.
• Access to Enclosing Class Members: It can directly access all static members (fields and methods) of its enclosing class, including those marked private. It cannot directly access non-static (instance) members of the enclosing class. To access instance members, it must explicitly instantiate the outer class.
• Internal Member Declarations: Unlike non-static nested classes (inner classes) prior to Java 16, a static nested class can freely declare both static and non-static fields, methods, and initialization blocks.
• Access Modifiers: Because it is a class member, a static nested class can be declared with any access modifier: public, protected, package-private (default), or private. This contrasts with top-level classes, which can only be public or package-private.

Instantiation Syntax

To instantiate a static nested class from outside the enclosing class, you use the enclosing class name as a namespace qualifier. You do not use an instance of the outer class.

// Correct instantiation: using the OuterClass type as a qualifier
OuterClass.StaticNestedClass nestedObj = new OuterClass.StaticNestedClass();

// Incorrect instantiation: attempting to bind to an outer instance
OuterClass outerObj = new OuterClass();
// OuterClass.StaticNestedClass invalidObj = outerObj.new StaticNestedClass(); // COMPILATION ERROR

Import Semantics

If you need to use the static nested class frequently in another file, you can import it directly to avoid qualifying it with the outer class name.

// Standard import
import com.example.OuterClass.StaticNestedClass;

public class Consumer {
    public void create() {
        // Instantiation without the OuterClass qualifier
        StaticNestedClass obj = new StaticNestedClass();
    }
}

Master Java with Deep Grasping Methodology!

Learn More