inner-classes java static-classes

Java inner class and static nested class


What is the main difference between an inner class and a static nested class in Java? Does design / implementation play a role in choosing one of these?


  • 91

    Joshua Bloch’s answer is in Effective Java read item 22 : Favor static member classes over non static

    Mar 31, 2015 at 10:33

  • 18

    For the record, it’s item 24 in the 3rd edition of the same book.

    – ZeroCool

    May 7, 2019 at 22:20


From the Java Tutorial:

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:


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 outerObject = new OuterClass()
OuterClass.InnerClass innerObject = InnerClass();

see: Java Tutorial – Nested Classes

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.


  • 146

    Mind that you can also import a static nested class directly, i.e. you could do (at the top of the file): import OuterClass.StaticNestedClass; then reference the class just as OuterClass.

    Jul 16, 2011 at 0:22

  • So, can I say that ‘static nested class’ are just top-level classes placed within a class, and that outer class can be considered a ‘namespace’. While, ‘nested classes’ is a member of the outer class and it requires an enclosing instance of the outer class?

    – Ngọc Hy

    Jul 6 at 8:40


The Java tutorial says:

Terminology: 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

In common parlance, the terms “nested” and “inner” are used interchangeably by most programmers, but I’ll use the correct term “nested class” which covers both inner and static.

Classes can be nested ad infinitum, e.g. class A can contain class B which contains class C which contains class D, etc. However, more than one level of class nesting is rare, as it is generally bad design.

There are three reasons you might create a nested class:

  • organization: sometimes it seems most sensible to sort a class into the namespace of another class, especially when it won’t be used in any other context
  • access: nested classes have special access to the variables/fields of their containing classes (precisely which variables/fields depends on the kind of nested class, whether inner or static).
  • convenience: having to create a new file for every new type is bothersome, again, especially when the type will only be used in one context

There are four kinds of nested class in Java. In brief, they are:

  • static class: declared as a static member of another class
  • inner class: declared as an instance member of another class
  • local inner class: declared inside an instance method of another class
  • anonymous inner class: like a local inner class, but written as an expression which returns a one-off object

Let me elaborate in more details.

Static Classes

Static classes are the easiest kind to understand because they have nothing to do with instances of the containing class.

A static class is a class declared as a static member of another class. Just like other static members, such a class is really just a hanger on that uses the containing class as its namespace, e.g. the class Goat declared as a static member of class Rhino in the package pizza is known by the name pizza.Rhino.Goat.

package pizza;

public class Rhino {


    public static class Goat {

Frankly, static classes are a pretty worthless feature because classes are already divided into namespaces by packages. The only real conceivable reason to create a static class is that such a class has access to its containing class’s private static members, but I find this to be a pretty lame justification for the static class feature to exist.

Inner Classes

An inner class is a class declared as a non-static member of another class:

package pizza;

public class Rhino {

    public class Goat {

    private void jerry() {
        Goat g = new Goat();

Like with a static class, the inner class is known as qualified by its containing class name, pizza.Rhino.Goat, but inside the containing class, it can be known by its simple name. However, every instance of an inner class is tied to a particular instance of its containing class: above, the Goat created in jerry, is implicitly tied to the Rhino instance this in jerry. Otherwise, we make the associated Rhino instance explicit when we instantiate Goat:

Rhino rhino = new Rhino();
Rhino.Goat goat = Goat();

(Notice you refer to the inner type as just Goat in the weird new syntax: Java infers the containing type from the rhino part. And, yes new rhino.Goat() would have made more sense to me too.)

So what does this gain us? Well, the inner class instance has access to the instance members of the containing class instance. These enclosing instance members are referred to inside the inner class via just their simple names, not via this (this in the inner class refers to the inner class instance, not the associated containing class instance):

public class Rhino {

    private String barry;

    public class Goat {
        public void colin() {

In the inner class, you can refer to this of the containing class as Rhino.this, and you can use this to refer to its members, e.g. Rhino.this.barry.

Local Inner Classes

A local inner class is a class declared in the body of a method. Such a class is only known within its containing method, so it can only be instantiated and have its members accessed within its containing method. The gain is that a local inner class instance is tied to and can access the final local variables of its containing method. When the instance uses a final local of its containing method, the variable retains the value it held at the time of the instance’s creation, even if the variable has gone out of scope (this is effectively Java’s crude, limited version of closures).

Because a local inner class is neither the member of a class or package, it is not declared with an access level. (Be clear, however, that its own members have access levels like in a normal class.)

If a local inner class is declared in an instance method, an instantiation of the inner class is tied to the instance held by the containing method’s this at the time of the instance’s creation, and so the containing class’s instance members are accessible like in an instance inner class. A local inner class is instantiated simply via its name, e.g. local inner class Cat is instantiated as new Cat(), not new this.Cat() as you might expect.

Anonymous Inner Classes

An anonymous inner class is a syntactically convenient way of writing a local inner class. Most commonly, a local inner class is instantiated at most just once each time its containing method is run. It would be nice, then, if we could combine the local inner class definition and its single instantiation into one convenient syntax form, and it would also be nice if we didn’t have to think up a name for the class (the fewer unhelpful names your code contains, the better). An anonymous inner class allows both these things:

new *ParentClassName*(*constructorArgs*) {*members*}

This is an expression returning a new instance of an unnamed class which extends ParentClassName. You cannot supply your own constructor; rather, one is implicitly supplied which simply calls the super constructor, so the arguments supplied must fit the super constructor. (If the parent contains multiple constructors, the “simplest” one is called, “simplest” as determined by a rather complex set of rules not worth bothering to learn in detail–just pay attention to what NetBeans or Eclipse tell you.)

Alternatively, you can specify an interface to implement:

new *InterfaceName*() {*members*}

Such a declaration creates a new instance of an unnamed class which extends Object and implements InterfaceName. Again, you cannot supply your own constructor; in this case, Java implicitly supplies a no-arg, do-nothing constructor (so there will never be constructor arguments in this case).

Even though you can’t give an anonymous inner class a constructor, you can still do any setup you want using an initializer block (a {} block placed outside any method).

Be clear that an anonymous inner class is simply a less flexible way of creating a local inner class with one instance. If you want a local inner class which implements multiple interfaces or which implements interfaces while extending some class other than Object or which specifies its own constructor, you’re stuck creating a regular named local inner class.


  • 45

    Great story, thanks. It has one mistake though. You can access the fields of an outer class from an instance inner class by Rhino.this.variableName .

    – Thirler

    Jul 30, 2009 at 7:44

  • 1

    You start the comment with there are two categories and then in the middle of the comment you write there are four kinds ..., it confused me to be honest. A category is not the same as “kind”?

    – NoobCoder

    Aug 16, 2021 at 22:08


I don’t think the real difference became clear in the above answers.

First to get the terms right:

  • A nested class is a class which is contained in another class at the source code level.
  • It is static if you declare it with the static modifier.
  • A non-static nested class is called inner class. (I stay with non-static nested class.)

Martin’s answer is right so far. However, the actual question is: What is the purpose of declaring a nested class static or not?

You use static nested classes if you just want to keep your classes together if they belong topically together or if the nested class is exclusively used in the enclosing class. There is no semantic difference between a static nested class and every other class.

Non-static nested classes are a different beast. Similar to anonymous inner classes, such nested classes are actually closures. That means they capture their surrounding scope and their enclosing instance and make that accessible. Perhaps an example will clarify that. See this stub of a Container:

public class Container {
    public class Item{
        Object data;
        public Container getContainer(){
            return Container.this;
        public Item(Object data) {
   = data;


    public static Item create(Object data){
        // does not compile since no instance of Container is available
        return new Item(data);
    public Item createSubItem(Object data){
        // compiles, since 'this' Container is available
        return new Item(data);

In this case you want to have a reference from a child item to the parent container. Using a non-static nested class, this works without some work. You can access the enclosing instance of Container with the syntax Container.this.

More hardcore explanations following:

If you look at the Java bytecodes the compiler generates for an (non-static) nested class it might become even clearer:

// class version 49.0 (49)
// access flags 33
public class Container$Item {

  // compiled from:
  // access flags 1
  public INNERCLASS Container$Item Container Item

  // access flags 0
  Object data

  // access flags 4112
  final Container this$0

  // access flags 1
  public getContainer() : Container
    ALOAD 0: this
    GETFIELD Container$Item.this$0 : Container
    LOCALVARIABLE this Container$Item L0 L1 0
    MAXSTACK = 1

  // access flags 1
  public <init>(Container,Object) : void
    ALOAD 0: this
    ALOAD 1
    PUTFIELD Container$Item.this$0 : Container
    ALOAD 0: this
    INVOKESPECIAL Object.<init>() : void
    ALOAD 0: this
    ALOAD 2: data
    PUTFIELD Container$ : Object
    LOCALVARIABLE this Container$Item L0 L3 0
    LOCALVARIABLE data Object L0 L3 2
    MAXSTACK = 2

As you can see the compiler creates a hidden field Container this$0. This is set in the constructor which has an additional parameter of type Container to specify the enclosing instance. You can’t see this parameter in the source but the compiler implicitly generates it for a nested class.

Martin’s example

OuterClass.InnerClass innerObject = InnerClass();

would so be compiled to a call of something like (in bytecodes)

new InnerClass(outerObject)

For the sake of completeness:

An anonymous class is a perfect example of a non-static nested class which just has no name associated with it and can’t be referenced later.


  • 20

    “There is no semantic difference between a static nested class and every other class.” Except the nested class can see the parent’s private fields/methods and the parent class can see the nested’s private fields/methods.

    Jun 22, 2010 at 14:56

  • Wouldn’t the non-static inner class potentially cause massive memory leaks? As in, every time you create a listener, you create a leak?

    – G_V

    Dec 15, 2014 at 8:24

  • 3

    @G_V there’s definitely potential for memory leaks because an instance of the inner class keeps a reference to the outer class. Whether this is an actual problem depends on where and how references to instances of the outer and the inner classes are held.

    – jrudolph

    Dec 17, 2014 at 9:09