我查看了LinkedList的Java代码,注意到它使用了一个静态嵌套类Entry。

public class LinkedList<E> ... {
...

 private static class Entry<E> { ... }

}

为什么要使用静态嵌套类,而不是普通的内部类?

我能想到的唯一原因是,Entry不能访问实例变量,所以从OOP的角度来看,它有更好的封装。

但我想可能还有其他原因,可能是表现。可能是什么?

请注意。我希望我的术语是正确的,我将它称为静态内部类,但我认为这是错误的:http://java.sun.com/docs/books/tutorial/java/javaOO/nested.html


当前回答

静态与普通的原因之一与类加载有关。不能在其父类的构造函数中实例化内部类。

PS:我一直认为“嵌套”和“内部”是可以互换的。术语之间可能有细微的差别,但大多数Java开发人员都能理解。

其他回答

简单的例子:

package test;

public class UpperClass {
public static class StaticInnerClass {}

public class InnerClass {}

public static void main(String[] args) {
    // works
    StaticInnerClass stat = new StaticInnerClass();
    // doesn't compile
    InnerClass inner = new InnerClass();
}
}

如果是非静态的,类不能被实例化,除非在上层类的实例中(所以在main是静态函数的例子中就不是这样)

在我看来,当你看到一个内部类时,问题应该是反过来的——它真的需要是一个内部类吗?它有额外的复杂性和隐式(而不是显式和更清晰的)引用包含类的实例?

请注意,作为一个c#爱好者,我有偏见——c#没有等价的内部类,尽管它有嵌套类型。我还不能说我错过了内部类:)

你链接到的Sun页面在这两者之间有一些关键的区别:

A nested class is a member of its enclosing class. Non-static nested classes (inner classes) have access to other members of the enclosing class, even if they are declared private. Static nested classes do not have access to other members of the enclosing class. ... Note: A static nested class interacts with the instance members of its outer class (and other classes) just like any other top-level class. In effect, a static nested class is behaviorally a top-level class that has been nested in another top-level class for packaging convenience.

不需要LinkedList。Entry是顶级类,因为它只被LinkedList使用(还有一些其他接口也有名为Entry的静态嵌套类,例如Map。入口-相同的概念)。因为它不需要访问LinkedList的成员,所以它是静态的是有意义的——这是一种更简洁的方法。

正如Jon Skeet所指出的,我认为如果你正在使用一个嵌套类,最好从它是静态的开始,然后根据你的使用情况决定它是否真的需要是非静态的。

使用静态嵌套类而不是非静态类在某些情况下可以节省空间。例如:在一个类中实现一个比较器,比如Student。

public class Student {
  public static final Comparator<Student> BY_NAME = new ByName();
  private final String name;
  ...
  private static class ByName implements Comparator<Student> {
    public int compare() {...}
  }
}

然后静态确保Student类只有一个Comparator,而不是每次创建新的Student实例时都实例化一个新的Comparator。

这里有一些不明显的内存保留问题需要考虑。由于非静态内部类维护对其“外部”类的隐式引用,如果内部类的一个实例被强引用,那么外部实例也会被强引用。当外部类没有被垃圾收集时,这可能会导致一些令人费解的问题,即使看起来没有任何东西引用它。