Can a Static Nested Class be Instantiated Multiple Times?

Question

Given what I know of every other type of static feature of programming––I would think the answer is 'no'. However, seeing statements like OuterClass.StaticNestedClass nestedObject = new OuterClass.StaticNestedClass(); makes me wonder.

Answer 1

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

Answer 2

@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

Answer 3

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.

Answer 4

Yeah you can make instances of it as many times as you want.

Maybe the reason why you see that, is because the programme thought about storing a reference somewhere. Though i agree with you seems strange :S

Answer 5

Inner class can use non static members/methods of containing class. It can use them only through an object reference of the enclosing class-

     public class MultipleInner {
      private int outerstate =10;
      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) {       
        Inner inner = new Inner();
        inner.setState(new MultipleInner().outerstate);
        System.out.println(inner.getState());        
     }

}

So, inner class doesn't have to pay the price of not being able to access the non static members of the enclosing class.

Answer 6

Static nested classes are indeed instanced - they are, as said, top-level classes which live in the namespace of the 'outer' class, and obey static semantics respecting references to the 'outer' class. This code sample demonstrates :

public class OuterClass {
    String outerStr = "this is the outer class!!" ;
    public static class StaticNestedClass {
        String innerStr = "default / first instance" ;      
    }

    public static void main(String[] args) {
        OuterClass.StaticNestedClass nestedObject1 = new OuterClass.StaticNestedClass();        
        OuterClass.StaticNestedClass nestedObject2 = new OuterClass.StaticNestedClass();
        nestedObject2.innerStr = "second instance" ;
        System.out.println(nestedObject1.innerStr) ;
        System.out.println(nestedObject2.innerStr) ;
    }
}

output:

default / first instance 
second instance