Question

鉴于我所知道的其他类型的静态编程功能 - 我认为答案是'不'。但是，看到像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 Inner Classes and Enclosing Instances

inner 类是未显式或隐式声明static的嵌套类。

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

那么static是什么意思？

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

另见

Answer 2

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

为了确保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());
        }
    }
}

当然结果是：

Answer 3

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

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

Answer 4

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

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

Answer 5

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

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

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

6 个答案:

另见

JLS 8.1.3 Inner Classes and Enclosing Instances

另见