What are inner classes and static nested classes

Question

What is the difference between inner classes and static nested classes?

Answer 1

These are some major differences and similarities between Java inner class and static nested class.

Inner class:

• Access outer class both instance and static methods and fields

• Associated with instance of enclosing class so to instantiate it needs an instance of outer class

  Outerclass.InnerClass innerClass = outerClass.new Innerclass();

• Cannot define any static members itself

• Cannot have Class or Interface declaration

Static nested class

• Cannot access outer class instance methods or fields

• Not associated with any instance of enclosing class, we can instantiate it:

  OuterClass.StaticNestedClass nestObject = new OuterClass.StaticNestedClass();

Similarities

• Both Inner classes can access even private fields and methods of outer class
• Also the Outer class have access to private fields and methods of inner classes
• Both classes can have private, protected or public access modifier

Answer 2

Nested classes are divided into two categories: static and non-static. Nested classes that are declared static are simply called static nested classes. Non-static nested classes are called inner classes.

Static nested classes are accessed using the enclosing class name:

OuterClass.StaticNestedClass

For example, to create an object for the static nested class, use this syntax:

OuterClass.StaticNestedClass nestedObject = new OuterClass.StaticNestedClass();

Objects that are instances of an inner class exist within an instance of the outer class. Consider the following classes:

class OuterClass {
    ...
    class InnerClass {
        ...
    }
}

An instance of InnerClass can exist only within an instance of OuterClass and has direct access to the methods and fields of its enclosing instance.

To instantiate an inner class, you must first instantiate the outer class. Then, create the inner object within the outer object with this syntax:

OuterClass.InnerClass innerObject = outerObject.new InnerClass();

For completeness note that there is also such a thing as an inner class without an enclosing instance:

class A {
  int t() { return 1; }
  static A a =  new A() { int t() { return 2; } };
}

Here, new A() { ... } is an inner class defined in a static context and does not have an enclosing instance.