nested classes : Java Glossary

The Six Types of Classes

1. top level classes: not nested, but possibly sharing a *.java file.
2. nested classes: like Russian dolls (either static or inner).
3. static classes: no associated outer class instance.
4. inner classes: with an associated outer class instance.
5. anonymous classes: unnamed inner class defined in the middle of a method (where static init blocks and instance init blocks count as methods).
6. local classes: named inner class defined in the middle of a method. (where static init blocks and instance init blocks count as methods). Just to keep you on your toes, some programmers us the term local class to include anonymous class.

Properly, the term inner classes only applies to the fourth, fifth and sixth types. For the remainder of this essay, I will attempt to use the term inner class only in that sense.

Just to make matters even more confusing, many programmers refer to both static nested classes and inner instance classes as inner classes, even though properly speaking inner implies non-static i.e. instance. I tend to use the term nested only for static nested classes, which is not quite kosher either.

The word static is so badly abused in Java. It has so many meanings, none of them anything like its meaning in ordinary English. The term static class is especially misleading. Static classes can be instantiated just like any other. They have both static and instance fields. They were probably called static just to avoid creating another reserved keyword.

The Basics

Inner classes have no keyword to mark them, other than class. Anonymous inner classes don’t even have that. What makes them nested is the way the {} marking the beginning and end of the class nest with other classes.

You can define an anonymous class, create an anonymous instance of it and pass it as a parameter to some method all in one (albeit very long) line. Anonymous classes were originally intended primarily for use by code generators. If you want to write really hard to follow code, you can nest inner classes within inner classes and make them anonymous if you

Here

Instantiating

// instantiating an inner class from inside the outer class.
Inner in = new Inner();

// instantiating an inner class from outside the outer class.
Outer out = new Outer();
Outer.Inner in = out.new Inner();

You can instantiate an static nested class like this:

Extending Inner or Static Nested Classes

When To Use Inner Classes

Scope

Inheritance

Accessing methods and Fields

You might imagine that inner classes are merely a scope mechanism, that they are independent classes, visible only to the outer class. Not so. For every inner class object there must exist an associated outer class object. You can’t create inner class objects without first creating an outer class object. You must create inner class objects in instance methods so that this implicitly gives you the corresponding outer class object.

On the other hand, if you declare the nested class static, that class can be independently instantiated. Since the class is not associated with any particular instance of the outer class, you may not use MyOuterClass. this.myOuterInstanceMethod() to access its instance methods. You could use someInstance. myOuterInstanceMethod() though and, of course, you can access the outer class’s static methods with myOuterStaticMethod() or MyOuterClass. myOuterStaticMethod()

If you are an assembler programmer, the following explanation may be helpful. If not, please ignore the rest of this paragraph. It will just confuse you. Inner class constructors get passed a hidden parameter, a reference to the outer class object that created them. static nested classes don’t have this hidden parameter. This is analogous to the way instance methods have hidden this parameter, where static methods do not.

The reverse rules for how outer classes get at the field and methods of nested ones are obvious. Outer classes access inner class and nested class fields and methods the same way they would any other independent class.

Variable Visibility In Inner and Outer Classes

Variable Visibility In Anonymous Classes

The local variables that must be final in order to be accessed, live in the method that instantiates and encloses the anonymous class. The access we are talking about is direct use of the variable names from inside the methods of the anonymous class.

Again, let

You might ask, why do the local variables have to be final? Could not the compiler just as well take a copy of non-final local variables, much the way it does for a non-final parameters? If it did so, you would have two copies of the variable. Each could change independently, much like caller and callee’s copy of a parameter, however, you would use the same syntax to access either copy. This would be confusing. So Sun insisted the local be final. This makes irrelevant that there are actually two copies of it.

The ability for an anonymous class to access the caller’s final local variables is really just syntactic sugar for automatically passing in some local variables as extra constructor parameters. The whole thing smells to me of diluted eau de kludge.

Variable Visibility In Local Classes

Nested Interfaces

Gotchas

1. The good news first: Top level classes sharing a source file are handled no differently than ones that each get their own independent source file.
2. Inner classes are not permitted to have static methods or fields. That is not quite true. They are allowed static final compile time constants, which are treated as if there were literals. Sorry I don’t know why the restriction. Nobody I have asked knows why. This is probably the single most annoying fact about nested classes. If inner classes need statics, they have to get the outer class to hold them, or you have to use static nested classes or you have to inherit the static fields. Oddly, inner classes are permitted to extend classes that do have static methods and fields.

   static methods in an anonymous class could not be called from outside the anyonymous class, which perhaps explains part of it.

   Mark Space offers this explanation for the restriction. Conceptually, non-static member classes, local and anonymous classes are all a part of the enclosing class. Thus they should be using the enclosing class for any static members.

   For future potential optimization, preventing static members might allow future JVMs (Java Virtual Machines) to take some short cuts with inner class objects and initialize the objects more quickly or otherwise do away with one or more steps involved in creating their class object. Since static members weren’t needed (since they could be promoted to an enclosing class (however, not enclosing object)), they were proscribed.

3. There is no such thing as an anonymous static nested class, or static local class.
4. There is no such thing as a top level static class.
5. An enum is a species of class, so it can be a public class, a top level default class or a nested static class. Inner class enums are considered static even if you don’t use the static keyword. An enum follows the same scope and visibility rules as any other class. enums can have static or instance fields and methods that apply to the enum as a whole. However, enum constants, since they are implemented as inner classes, may not have static fields or methods, just instance fields and methods.

Learning More