The basics

To define an inner class, just define one class within another:

public class Outer {
    public class Inner {

    }
}

Generally, the outer class will be responsible for creating instances of the inner classes and this could be done in the methods of the outer class, for example here where the outerClassesMethod creates an inner class instance and calls its method (lines 7-8) :

public class Outer {

    private String message = "foo";

    public void outerClassesMethod() {
        //create an inner object to do the work
        Inner ii = new Inner();
        ii.innerClassesMethod();
    }

    private class Inner {
        private void innerClassesMethod() {
            System.out.println(message);
        }
    }
}

Note above that the inner classes method (line 12), although private, can still be called by the outer class. Also note that the private message field on the outer class (line 3) can be accessed from the inner class. A call to the outerClassesMethod will cause the innerClassesMethod to be called and the message ‘foo‘ to be printed to std out.

What about ‘this’ ?

Each object in a Java application can refer to itself using the ‘this’ reference. When an instance of an inner class is created, it is created within the instance that created it; so what effect does this have on ‘this’ reference?

In fact, inner class instances have more than one ‘this’ reference: one that refers to the instance of the inner instance, and one that refers to the outer instance. Consider this simple change to the example:

public class Outer {

    private String message = "foo";

    public void outerClassesMethod() {
        //create an inner object to do the work
        Inner ii = new Inner();
        ii.innerClassesMethod();
    }

    private class Inner {
        private String message = "bar";

        private void innerClassesMethod() {
            System.out.println(message);
        }
    }
}

Now that the inner class also has a field named message, the text ‘bar‘ will be printed out instead of ‘foo’.

The reason for this is that the inner classes message field has shadowed the outer classes one. The inner classes println call (line 15) would have the exact same behaviour if it were written as:

System.out.println(this.message);

if we want to access the message field on the outer class, then we need to use a ‘this’ reference for the outer instance; we do this by pre-pending the class name to ‘this’ as follows:

System.out.println(Outer.this.message);

substituting the println statement with the one shown above, will access the message field on the Outer class and cause ‘foo‘ to be printed out once again.

Creating inner instances from outside the outer class

As noted above, the inner instances will generally be created within the outer class. However, it is possible for inner instances to be created in other places too; for example, a factory class could be used to create the outer objects and also the inner objects that they will contain.

To demonstrate this scenario, we’ll use a slightly revised example where the inner class, and its method, have been made publicly visible. Note also that the outer class now has a constructor (lines 4-6) that will allow us to initialise its private message field (line 3) :

public class Outer {

    private String message;

    public Outer(String message) {
        this.message = message;
    }

    public class Inner {
        public void innerClassesMethod() {
            System.out.println(message);
        }
    }
}

If our factory class is to create the inner class instances, then it must associate them with an outer instance. In order to do this the new keyword must be scoped to a particular outer instance using this somewhat cumbersome syntax:

Outer o = new Outer("foo");
Outer.Inner i = o.new Inner();
i.innerClassesMethod();

Note the use of the new keyword (line 2) is prepended with the outer object reference (i.e. o.new). It is this outer reference that will be accessible within the inner object’s methods using the ‘this’ syntax explained above.

So, when the call to the inner classes method is made (on line 3), the private message field of the outer instance will be printed out – i.e. we’ll see ‘foo‘ appear in std out.

Static inner classes

The static modifier can be applied to member level classes in much the same was as it can with the fields and methods of that class. As with fields and methods, use of the static modifier pretty much turns off OO.

public class Outer {

    private String message;

    static class Inner {
        private String message;

        public void innerClassesMethod() {
            //can access the message field defined on this class:
            System.out.println(this.message);

            //can't access the one from the outer class though:
            System.out.println(Outer.this.message);
        }
    }
}

In much the same way as a static method is not associated with an object instance, objects created from static inner class definitions are not associated with an outer object instance either.

Static inner classes therefore do not have a second this reference, and cannot access the non-static fields of the outer class (line 13 in the above example would produce a compiler error). Effectively, inner classes are just regular classes defined within an outer classes name-space.

Extending the Object Oriented Programming Model

Encapsulation can be regarded as a barrier that an object puts up to protect itself from other objects. Within an object we generally expect there to be fields (that each object will have it’s own instance of) and methods (that can be called to affect that object). Inner classes extend Java’s OO model by also allowing objects to be created within an object, thus making the code within an object truly object oriented.

To demonstrate this, lets start by looking at some less-than-ideal Swing GUI code. The DemoUI class is a simple application frame that uses a WindowCloser object as a listener for its window events. The code for both of these classes is shown here:

public class DemoUI extends JFrame {
    public DemoUI() {
        //add the window closing event listener
        this.addWindowListener(new WindowCloser(this));
    }

    public void shutdown() {
        int answer = JOptionPane.showConfirmDialog(this, "Are you sure?");
        if (answer == JOptionPane.YES_OPTION) {
            System.exit(0);
        }
    }
}

class WindowCloser extends WindowAdapter {
    private DemoUI demoUI;

    public WindowCloser(DemoUI demoUI) {
        this.demoUI = demoUI;
    }

    public void windowClosing(WindowEvent windowEvent) {
        demoUI.shutdown();
    }
}

When the user clicks application frame’s close button (i.e. the cross button on the frame’s title bar), the windowClosing method will be called on the event listener which will, in turn, call the shutdown method of the frame. The shutdown method prompts the user to make sure that they want to quit before calling System.exit(…) to exit the application.

Although a fairly simple example, this code is more complex than it need be. The reason for this complexity stems from the fact that the objects created from these classes are completely separate from one another, we could picture these objects as follows:

Because these objects would otherwise have no association with one another, we must provide a reference from the listener to the frame in order that the frame’s shutdown method may be called by the listener. It also means that the frame’s shutdown method cannot be declared private, thus weakening its encapsulation.

Applying Inner Classes

If we make the listener an inner class of the frame, then it will have access to all members of the frame (even private ones). We do this simply by moving the listener class definition inside the frame class:

public class DemoUI extends JFrame {
    public DemoUI() {
        //add the window closing event listener
        this.addWindowListener(new WindowCloser());
    }

    private void shutdown() {
        int answer = JOptionPane.showConfirmDialog(this, "Are you sure?");
        if (answer == JOptionPane.YES_OPTION) {
            System.exit(0);
        }
    }

    private class WindowCloser extends WindowAdapter {
        public void windowClosing(WindowEvent windowEvent) {
            shutdown();
        }
    }
}

Now that the listener is declared as an inner class of the frame, instances of the listener will be created inside the enclosing frame instance. In contrast to the above example, this can now be pictured as follows:

Note that there is now no need to keep a reference to the frame instance from the listener as the listener object is implicitly associated with it. This means that the shutdown method, although declared as private on the frame, is still available to the listener. Finally, and for good measure, because the listener is only ever used by the frame, we can make its class definition private and prevent any other classes from accessing it.

Method Level Inner Classes

The example above shows an inner class being defined at the same level of scope as the methods and fields (aka the members) of the outer class. This type of inner class is therefore commonly referred to as a member level inner class.

In Java it is common to declare variables where they are first used. It is possible to do this with inner classes too. In this example the inner class has been declared just before it is used; i.e. within the constructor method of the frame:

public class DemoUI extends JFrame {
    public DemoUI() {
        //add the window closing event listener
        class WindowCloser extends WindowAdapter {
            public void windowClosing(WindowEvent windowEvent) {
                shutdown();
            }
        }
        this.addWindowListener(new WindowCloser());
    }

    private void shutdown() {
        int answer = JOptionPane.showConfirmDialog(this, "Are you sure?");
        if (answer == JOptionPane.YES_OPTION) {
            System.exit(0);
        }
    }
}

A method level inner class can only be used in the method it is declared in and it is inherently private to that method. Classes defined at method level also have the additional advantage of being able to access local variables in that method, just so long as they are declared as final.

Anonymous Inner Classes

The next progression from a method level inner class is an anonymous inner class. In the previous example, the class was defined just before it was created and used. The name for the class was therefore only ever used in the definition and then in the subsequent call to create an instance of it. In cases such as this, it is possible to create and define the inner class in a single statement, rendering its name irrelevant:

public class DemoUI extends JFrame {
    public DemoUI() {
        //add the window closing event listener
        this.addWindowListener(new WindowAdapter() {
            public void windowClosing(WindowEvent windowEvent) {
                shutdown();
            }
        });
    }

    private void shutdown() {
        int answer = JOptionPane.showConfirmDialog(this, "Are you sure?");
        if (answer == JOptionPane.YES_OPTION) {
            System.exit(0);
        }
    }
}

You can see from this code that the inner class has now been created using the Java ‘new’ operator but that the name WindowCloser is no longer used; just the supertype WindowAdapter is used instead and the implementation of the windowClosing method is simply specified in the curly braces following the normal constructor call.

This example demonstrates how to create an anonymous subclass of the WindowAdapter class which is an abstract class defined within the Swing APIs. You can create an anonymous subclass of any class though using this syntax; just place the code for the subclass within the curly braces and you’re done.

It is also possible to implement an interface using this syntax. So for example if there were a Quit button in our GUI, then we could implement the ActionListener interface for the event listener that reuses the shutdown method like so:

JButton quitButton = new JButton("Quit");
quitButton.addActionListener(new ActionListener() {
    public void actionPerformed(ActionEvent actionEvent) {
        shutdown();
    }
});

Summary

The discussion I’ve presented above illustrates the most common use of inner classes but there are dozens of other uses; for example, the Spring data abstraction layer uses them to great effect, as does the Wicket web framework.

Fundamentally, inner classes in Java enable objects to be created within objects. This simple principle opens up a whole array of design choices for object aggregation. With careful consideration, inner classes allow your code to be more concise and maintainable than it might otherwise be. A good understanding of inner classes is therefore a key skill for any serious Java developer.