静态嵌套类可以多次实例化吗？

Question

鉴于我所知道的其他类型的静态编程功能 - 我认为答案是'不'。 但是，看到像OuterClass.StaticNestedClass nestedObject = new OuterClass.StaticNestedClass();这样的语句OuterClass.StaticNestedClass nestedObject = new OuterClass.StaticNestedClass(); 我好疑惑。

Answer 1

是的， static嵌套类型的语义中没有任何内容可以阻止您这样做。 这个片段运行正常。

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

也可以看看

• public static interface Map.Entry<K,V>
  • public static class AbstractMap.SimpleEntry<K,V>
    • 可能是最着名的嵌套类型。 显然多次实例化。

---

现在，嵌套类型当然可以进行自己的实例控制（例如private构造函数，单例模式等），但这与嵌套类型无关。 此外，如果嵌套类型是static enum ，当然您根本无法实例化它。

但总的来说，是的， static嵌套类型可以多次实例化。

请注意，从技术上讲， static嵌套类型不是“内部”类型。

JLS 8.1.3内部类和封闭实例

内部类是未显式或隐式声明为static的嵌套类。

也就是说，根据JLS术语， 内部类是非static 。 如果它是static ，那么它只是一个嵌套类型。

---

那么static意味着什么呢？

static只是意味着嵌套类型不需要实例化封闭类型的实例。

也可以看看

• Java内部类和静态嵌套类
• Java：静态与非静态内部类

Answer 2

@polygenelubricants：但总的来说，是的，静态嵌套类型可以多次实例化。

只是为了确保100％我扩展你的片段：

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

当然结果是：

0
1
2
3
.
.
.
97
98
99

Answer 3

这是合法的。 内部类是静态的这一事实在这里给你一个好处; 它的实例没有绑定到包含类的任何实例，因此可以自由地实例化它们（只要访问限定符允许它）。

然而，价格是内部类不能使用包含类的非静态成员/方法。

Answer 4

内部类可以使用非静态成员/包含类的方法。 它只能通过封闭类的对象引用来使用它们 -

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

}

因此，内部类不必支付无法访问封闭类的非静态成员的代价。

Answer 5

是的，你可以根据需要多次制作它。

也许你之所以看到这个，是因为该程序考虑在某处存储引用。 虽然我同意你的看法很奇怪：S

Answer 6

静态嵌套类确实是实例化的 - 如上所述，它们是位于“外部”类的命名空间中的顶级类，并遵循关于“外部”类的引用的静态语义。 此代码示例演示：

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