All 15 Inner Classes & Anonymous Classes questions
More in Inner Classes & Anonymous Classes
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? 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? 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
Java › 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?

Beginner

Answer

A non-static inner class is defined within another class and holds an implicit reference to a specific instance of its enclosing class, meaning an inner class instance cannot exist independently of an associated outer instance and can freely access that outer instance's fields and methods (including private ones) without any special qualification -- this differs fundamentally from a regular top-level class, which has no inherent connection to any other class's instances, requiring inner class instances to always be created through (or in relation to) an existing outer instance.
public class Outer {
    private int value = 42;

    class Inner {
        void printValue() {
            System.out.println(value);  // accesses Outer's private field directly, no qualification needed
        }
    }
}

Outer outer = new Outer();
Outer.Inner inner = outer.new Inner();  // requires an outer instance to create
inner.printValue();  // prints 42
Real-world example A GUI event-handling inner class defined within a Window class directly accesses the Window's private fields (like its title or state) to update the UI in response to user interaction, without needing to pass those fields explicitly since the inner class automatically retains a reference to its specific enclosing Window instance.

Common follow-ups: Why does creating an inner class instance require the unusual outer.new Inner() syntax rather than just new Inner()?;What happens to memory if the outer instance is kept alive solely because an inner class instance derived from it is still referenced?

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