All 15 Inner Classes & Anonymous Classes questions
More in Inner Classes & Anonymous Classes
What is a non-static (inner) class in Java, and how does its relationship to an enclosing instance differ from a regular top-level class? How do you instantiate a non-static inner class from OUTSIDE the enclosing class (from a different class entirely), and what is the exact syntax required? How would you implement a callback or event listener using an anonymous class, and how does this same use case increasingly get replaced by lambda expressions for functional interfaces in modern Java? What is a local class's access to effectively-final local variables, and how does this same rule (and the underlying reason for it) apply identically to anonymous classes and lambdas? How does a local or anonymous class defined inside a static method or static context differ from one defined inside an instance method, regarding what enclosing state it can access? How does an inner class's implicit reference to its outer instance create a potential memory leak risk, and in what specific scenario does this become a genuine practical concern? Can a local class or anonymous class be generic, and how does its own type parameter interact with any generic type parameters already declared on its enclosing class or method? How would you access the enclosing outer class's instance from within a nested inner class when there's a naming conflict (like a shadowed field with the same name), using the OuterClassName.this syntax? How do local classes (defined within a method body) and anonymous classes differ in their capabilities and use cases, particularly regarding capturing local variables and reusability? How does the compiler implement inner classes at the bytecode level, and what synthetic elements (like a hidden outer-class reference field and synthetic accessor methods) does it generate to make this work?
Advertisement
Back to results for “Design Patterns in Java”
Java › Inner Classes & Anonymous Classes

What is a static nested class, and why is it generally preferred over a non-static inner class when the nested class doesn't actually need access to the enclosing instance?

Intermediate

Answer

A static nested class is declared with the static modifier, meaning it does NOT hold an implicit reference to any specific enclosing instance and can be instantiated independently (new Outer.Nested(), no outer instance required) -- it's generally preferred over a non-static inner class whenever the nested class's logic genuinely doesn't need access to the enclosing instance's state, since it avoids the memory overhead and potential memory-leak risk of an implicit outer reference (which, for a non-static inner class, can inadvertently keep the entire outer instance alive as long as any inner instance exists), and Effective Java specifically recommends defaulting to static nested classes unless outer-instance access is genuinely required.
public class Outer {
    static class Nested {  // no implicit outer reference
        void doWork() { System.out.println("Working independently"); }
    }
}

Outer.Nested nested = new Outer.Nested();  // no outer instance needed at all
nested.doWork();
Real-world example A Node class used internally by a custom LinkedList implementation is declared as a static nested class specifically because each Node instance genuinely never needs to reference the LinkedList instance itself, avoiding the unnecessary per-node memory overhead an implicit outer reference would otherwise add across potentially millions of nodes.

Common follow-ups: What's the actual memory cost (in bytes) of the implicit outer reference a non-static inner class carries?;How would you convert an existing non-static inner class to static if you later realize it doesn't actually need outer access?

Design Patterns in Java;Garbage Collection
All 15 Inner Classes & Anonymous Classes questions