Nested Classes in Java

1. Introduction

This tutorial is a quick and to-the-point introduction to nested classes in the Java language.

Simply put, Java allows us to define classes inside other classes. Nested classes enable us to logically group classes that are only used in one place, write more readable and maintainable code and increase encapsulation.

Before we get started, let’s have a look at the several types of nested classes available in the language:

• Static nested classes
• Non-static nested classes
• Local classes
• Anonymous classes

In the next sections, we’re going to discuss each of these in detail.

2. Static Nested Classes

Here are a few points to remember about static nested classes:

• As with static members, these belong to their enclosing class, and not to an instance of the class
• They can have all types of access modifiers in their declaration
• They only have access to static members in the enclosing class
• They can define both static and non-static members

Let’s see how we can declare a static nested class:

public class Enclosing {
    
    private static int x = 1;
    
    public static class StaticNested {

        private void run() {
            // method implementation
        }
    }
    
    @Test
    public void test() {
        Enclosing.StaticNested nested = new Enclosing.StaticNested();
        nested.run();
    }
}

3. Non-Static Nested Classes

Next, here are a few quick points to remember about non-static nested classes:

• They are also called inner classes
• They can have all types of access modifiers in their declaration
• Just like instance variables and methods, inner classes are associated with an instance of the enclosing class
• They have access to all members of the enclosing class, regardless of whether they are static or non-static
• They can only define non-static members

Here’s how we can declare an inner class:

public class Outer {
    
    public class Inner {
        // ...
    }
}

If we declare a nested class with a modifier static, then it’s a static member one. Otherwise, it’s an inner class. Even though syntactically the difference is just a single keyword (i.e., static), semantically there is a huge difference between these kinds of nested classes. Inner class instances are bound to the enclosing class ones and therefore they have access to their members. We should be aware of this issue when selecting whether to make a nested class be an inner one.

To instantiate an inner class, we must first instantiate its enclosing class.

Let’s see how we can do that:

Outer outer = new Outer();
Outer.Inner inner = outer.new Inner();

In the next subsections, we’re going to show some special types of inner classes.

3.1. Local Classes

Local classes are a special type of inner classes – in which the class is defined inside a method or scope block.

Let’s see a few points to remember about this type of class:

• They cannot have access modifiers in their declaration
• They have access to both static and non-static members in the enclosing context
• They can only define instance members

Here’s a quick example:

public class NewEnclosing {
    
    void run() {
        class Local {

            void run() {
                // method implementation
            }
        }
        Local local = new Local();
        local.run();
    }
    
    @Test
    public void test() {
        NewEnclosing newEnclosing = new NewEnclosing();
        newEnclosing.run();
    }
}

3.2. Anonymous Classes

Anonymous classes can be used to define an implementation of an interface or an abstract class without having to create a reusable implementation.

Let’s list a few points to remember about anonymous classes:

• They cannot have access modifiers in their declaration
• They have access to both static and non-static members in the enclosing context
• They can only define instance members
• They’re the only type of nested classes that cannot define constructors or extend/implement other classes or interfaces

To define an anonymous class, let’s first define a simple abstract class:

abstract class SimpleAbstractClass {
    abstract void run();
}

Now let’s see how we can define an anonymous class:

public class AnonymousInnerUnitTest {
    
    @Test
    public void whenRunAnonymousClass_thenCorrect() {
        SimpleAbstractClass simpleAbstractClass = new SimpleAbstractClass() {
            void run() {
                // method implementation
            }
        };
        simpleAbstractClass.run();
    }
}

For more details, we may find useful our tutorial on Anonymous Classes in Java.

4. Shadowing

The declaration of the members of an inner class shadow those of the enclosing class if they have the same name.

In this case, the this keyword refers to the instances of the nested class and the members of the outer class can be referred to using the name of the outer class.

Let’s see a quick example:

public class NewOuter {

    int a = 1;
    static int b = 2;

    public class InnerClass {
        int a = 3;
        static final int b = 4;

        public void run() {
            System.out.println("a = " + a);
            System.out.println("b = " + b);
            System.out.println("NewOuterTest.this.a = " + NewOuter.this.a);
            System.out.println("NewOuterTest.b = " + NewOuter.b);
            System.out.println("NewOuterTest.this.b = " + NewOuter.this.b);
        }
    }

    @Test
    public void test() {
        NewOuter outer = new NewOuter();
        NewOuter.InnerClass inner = outer.new InnerClass();
        inner.run();

    }
}

5. Serialization

To avoid a java.io.NotSerializableException while attempting to serialize a nested class, we should:

• Declare the nested class as static
• Make both the nested class and the enclosing class implement Serializable

6. Conclusion

In this article, we’ve seen what nested classes are and their different types. We also took a look at how field visibility and access modifiers differ across those different types.