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? 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
Back to results for “OOP”
Java › 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?

Beginner

Answer

Instantiating a non-static inner class from outside the enclosing class requires an existing outer instance combined with the special outer.new Inner() syntax (or the fully-qualified OuterClass.InnerClass typeName combined with that same instantiation syntax when referring to the type from elsewhere), since the inner class instance genuinely cannot exist without an associated outer instance to bind to -- this is a notably different, more verbose syntax than instantiating any regular top-level or static nested class, and it's a common source of compile errors for developers unfamiliar with the requirement.
public class Outer {
    class Inner { void greet() { System.out.println("Hello from Inner"); } }
}

// From a different, unrelated class:
Outer outer = new Outer();
Outer.Inner inner = outer.new Inner();  // requires an existing Outer instance first
inner.greet();

// This would NOT compile: new Outer.Inner();  -- missing the required outer instance
Real-world example A developer new to Java attempting new Outer.Inner() directly (without first creating an Outer instance) encounters a confusing compile error, resolved once they learn the required outer.new Inner() syntax that explicitly ties the new inner instance to a specific, already-existing outer instance.

Common follow-ups: Why does this instantiation requirement not apply to static nested classes, which can be created with simple new Outer.Nested() syntax?;Is there a way to change which specific outer instance an already-created inner class instance is associated with, after the fact?

OOP & Classes;Java Fundamentals: Syntax Data Types & Operators
All 15 Inner Classes & Anonymous Classes questions