Can a Static Nested Class be Instantiated Multiple Times?

@polygenelubricants : But in general, yes, a static nested type can be instantiated multiple times.

Just to be sure 100% of that I extended your snippet:

public class MultipleInner {
    static class Inner {
        private int state;
        public int getState() { return state; }
        public void setState(int state) { this.state = state; }
    }

    public static void main(String[] args) {
        List<Inner> inners = new ArrayList<Inner>();
        for (int i = 0; i < 100; i++) {
            Inner inner = new Inner();
            inner.setState(i);
            inners.add(inner);
        }
        for (Inner inner : inners) {
            System.out.println(inner.getState());
        }
    }
}

And of course the result is:

0
1
2
3
.
.
.
97
98
99

Yes, there is nothing in the semantics of a static nested type that would stop you from doing that. This snippet runs fine.

public class MultipleNested {
    static class Nested {
    }
    public static void main(String[] args) {
        for (int i = 0; i < 100; i++) {
            new Nested();
        }
    }
}

See also

• public static interface Map.Entry<K,V>
  • public static class AbstractMap.SimpleEntry<K,V>
    • Probably the most well-known nested type. Obviously instantiated multiple times.

---

Now, of course the nested type can do its own instance control (e.g. private constructors, singleton pattern, etc) but that has nothing to do with the fact that it's a nested type. Also, if the nested type is a static enum, of course you can't instantiate it at all.

But in general, yes, a static nested type can be instantiated multiple times.

Note that technically, a static nested type is not an "inner" type.

JLS 8.1.3 Inner Classes and Enclosing Instances

An inner class is a nested class that is not explicitly or implicitly declared static.

That is, according to JLS terminology, an inner class is one that isn't static. If it's static, then it's just a nested type.

---

So what does static mean?

static simply means that the nested type does not need an instance of the enclosing type to be instantiated.

See also

• Java inner class and static nested class
• Java: Static vs non static inner class

It is legal. The fact that the inner class is static gives you a benefit here; its instances are not bound to any instance of the containing class, so they can be freely instantiated (as long as the access qualifier allows it).

The price, however, is that the inner class can't use non static members/methods of the containing class.