Java中的静态嵌套类，为什么？

Question

我正在查看 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

Answer 1

您链接到的 Sun 页面两者之间有一些关键区别：

嵌套类是其封闭类的成员。 非静态嵌套类（内部类）可以访问封闭类的其他成员，即使它们被声明为私有。 静态嵌套类无法访问封闭类的其他成员。
...

注意：静态嵌套类与其外部类（和其他类）的实例成员进行交互，就像任何其他顶级类一样。 实际上，静态嵌套类在行为上是一个顶级类，为了打包方便而嵌套在另一个顶级类中。

不需要 LinkedList.Entry成为顶级类，因为它仅由 LinkedList 使用（还有一些其他接口也具有名为 Entry 的静态嵌套类，例如作为Map.Entry - 相同的概念）。 由于它不需要访问 LinkedList 的成员，因此将其设置为静态是有意义的 - 这是一种更简洁的方法。

正如 Jon Skeet 指出的，我认为如果您使用嵌套类，那么从它开始是一个更好的主意是静态的，然后根据您的使用情况决定是否真的需要非静态。

Answer 2

在我看来，每当你看到内部类时，问题应该是相反的 - 它真的是否需要成为一个内部类，具有额外的复杂性和隐式的（而不是显式的和更清晰的） ，IMO）对包含类的实例的引用？

请注意，作为 C# 粉丝，我有偏见 - C# 没有等效的内部类，尽管它确实有嵌套类型。 我还不能说我错过了内部课程:)

Answer 3

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

Answer 4

静态内部类用于构建器模式。 静态内部类可以实例化它的外部类，该外部类只有私有构造函数。 您不能对内部类执行相同的操作，因为您需要在访问内部类之前创建外部类的对象。

class OuterClass {
    private OuterClass(int x) {
        System.out.println("x: " + x);
    }
    
    static class InnerClass {
        public static void test() {
            OuterClass outer = new OuterClass(1);
        }
    }
}

public class Test {
    public static void main(String[] args) {
        OuterClass.InnerClass.test();
        // OuterClass outer = new OuterClass(1); // It is not possible to create outer instance from outside.
    }
}

这将输出 x: 1

Answer 5

静态嵌套类就像任何其他外部类一样，因为它无法访问外部类成员。

只是为了打包方便，我们可以将静态嵌套类合并到一个外部类中以提高可读性。 除此之外，静态嵌套类没有其他用例。

这种用法的示例，您可以在 Android R.java（资源）文件中找到。
android的Res文件夹包含布局（包含屏幕设计）、drawable文件夹（包含项目使用的图像）、values文件夹（包含字符串常量）等。

正弦所有文件夹都是Res文件夹的一部分，android工具生成一个R. java（资源）文件，其内部包含每个内部文件夹的许多静态嵌套类。

这是在 android 中生成的 R.java 文件的外观：
在这里他们只是为了包装方便而使用。

/* AUTO-GENERATED FILE.  DO NOT MODIFY.
 *
 * This class was automatically generated by the
 * aapt tool from the resource data it found.  It
 * should not be modified by hand.
 */

package com.techpalle.b17_testthird;

public final class R {
    public static final class drawable {
        public static final int ic_launcher=0x7f020000;
    }
    public static final class layout {
        public static final int activity_main=0x7f030000;
    }
    public static final class menu {
        public static final int main=0x7f070000;
    }
    public static final class string {
        public static final int action_settings=0x7f050001;
        public static final int app_name=0x7f050000;
        public static final int hello_world=0x7f050002;
    }
}

Answer 6

嗯，一方面，非静态内部类有一个额外的隐藏字段，指向外部类的实例。 因此，如果 Entry 类不是静态的，那么除了具有不需要的访问权限之外，它还会携带四个指针而不是三个。

一般来说，我想说，如果您定义的类基本上充当数据成员的集合，例如 C 中的“结构”，请考虑将其设为静态。

Answer 7

来自 http://docs.oracle.com/javase/tutorial/java/ javaOO/whentouse.html：

如果需要访问，请使用非静态嵌套类（或内部类）
到封闭实例的非公共字段和方法。 使用静态
嵌套类（如果您不需要此访问权限）。

Answer 8

简单的例子：

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 是静态函数的示例中）

Answer 9

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

PS：我一直认为“嵌套”和“内部”是可以互换的。 这些术语可能存在细微差别，但大多数 Java 开发人员都会理解。

Answer 10

1. JVM 不知道嵌套类。 嵌套只是语法糖。

   下图显示了 Java 文件：

   

   下图显示了 java 文件的类文件表示：

   

   请注意，生成了 2 个类文件，一个用于父类，另一个用于嵌套类。

2. 非静态嵌套类的对象可以访问封闭范围。 通过在嵌套对象中保存封闭范围对象的隐式引用来维护对封闭范围的访问

3. 嵌套类是表示嵌套类类型表示父类组件的意图的一种方式。

   公共类消息{ 
   
     私有消息类型消息类型；   // 父类的组件 
   
     公共枚举消息类型{ 
         发送、接收； 
     } 
     } 
   
   
   
     类 其他类 { 
   
     公共布尔 isSent(消息消息) { 
         if (message.getMessageType() == MessageType.SENT) { // 也可以在其他地方访问 
             返回真； 
         } 
         返回假； 
     } 
     } 
     

4. 私有静态嵌套类表示 Point#3 和 Point#3 事实上，嵌套类型只能是父类的子组件。 不能单独使用。

   公共类消息{ 
   
      私人内容内容；   // 消息类的组成部分 
   
      private static class Content { // 只能是消息类的组件 
   
       私有字符串体； 
       私有 int 发送者； 
   
       公共字符串 getBody() { 
          返回主体； 
       } 
   
       公共 int getSentBy() { 
          返回发送者； 
       } 
   
     } 
     } 
   
     类消息2 { 
       私人留言.Content内容；   // 不可能 
     } 
     

5. 更多详细信息此处< /a>.

   
   

Answer 11

非静态内部类可能会导致内存泄漏，而静态内部类可以防止内存泄漏。 如果外部类保存大量数据，则可能会降低应用程序的性能。

Answer 12

我不知道性能差异，但正如您所说，静态嵌套类不是封闭类实例的一部分。 创建静态嵌套类似乎更简单，除非您确实需要它作为内部类。

这有点像为什么我总是在 Java 中将变量设置为最终变量 - 如果它们不是最终变量，我知道它们会发生一些有趣的事情。 如果您使用内部类而不是静态嵌套类，应该有一个很好的理由。

Answer 13

在某些情况下，使用静态嵌套类而不是非静态嵌套类可能会节省空间。 例如：在类中实现一个Comparator，比如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() {...}
  }
}

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

Answer 14

内部类的优点——

1. 一次性使用
2. 支持并提高封装的
3. 可读性
4. 私有字段访问

没有外部类的存在内部类将不存在。

class car{
    class wheel{

    }
}

内部类有四种类型。

1. 普通内部类
2. 方法 本地内部类
3. 匿名内部类
4. 静态内部类

要点 ---

1. 从静态内部类中，我们只能访问外部类的静态成员。
2. 在内部类中我们不能声明静态成员。

3. 为了在外部类的静态区域调用普通内部类。

   外部 0=new 外部();
Outer.Inner i= O.new Inner();

4. 为了在外部类的实例区调用普通内部类。

   Inner i=new Inner();

5. 为了在外部类之外调用正常的内部类。

   外部 0=new 外部();
Outer.Inner i= O.new Inner();

6. inside Inner class 这个指向内部类的指针。

   this.member-当前内部类
externalclassname.this--外部类

7. 对于内部类适用的修饰符是 --public,default,

   final,abstract,strictfp,+private,protected,static

8. outer$inner 是内部类名。

9. 内部类在实例方法中，我们可以访问外部类的静态和实例字段。

10.内部类中有静态方法，那么我们只能访问

外部类的静态字段。

class outer{

    int x=10;
    static int y-20;

    public void m1() {
        int i=30;
        final j=40;

        class inner{

            public void m2() {
                // have accees x,y and j
            }
        }
    }
}