Can a Static Nested Class be Instantiated Multiple Times?

问题

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.

回答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();
        }
    }
}

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.

回答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:

回答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.

回答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

回答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.

回答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

来源：https://stackoverflow.com/questions/2719536/can-a-static-nested-class-be-instantiated-multiple-times

标签

java

static

nested-class