Nested Classes in Java – Java中的嵌套类

最后修改: 2017年 12月 2日

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
    public void test() {
        Enclosing.StaticNested nested = new Enclosing.StaticNested();;

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 = 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();;
    public void test() {
        NewEnclosing newEnclosing = new NewEnclosing();;

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 {
    public void whenRunAnonymousClass_thenCorrect() {
        SimpleAbstractClass simpleAbstractClass = new SimpleAbstractClass() {
            void run() {
                // method implementation

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);

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


5. Serialization


To avoid a 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.


As always, the full implementation of this tutorial can be found over on GitHub.