静态嵌套类在Java，为什么?

我查看了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

当前回答

内部类的优势——

一次性使用支持和改进封装 readibility 私有字段访问

没有外部类的存在，内部类就不存在。

class car{
    class wheel{

    }
}

内部类有四种类型。

正常的内部类局部内部类匿名内部类静态内部类

点——

from static inner class ,we can only access static member of outer class. Inside inner class we cananot declare static member . inorder to invoke normal inner class in static area of outer class. Outer 0=new Outer(); Outer.Inner i= O.new Inner(); inorder to invoke normal inner class in instance area of outer class. Inner i=new Inner(); inorder to invoke normal inner class in outside of outer class. Outer 0=new Outer(); Outer.Inner i= O.new Inner(); inside Inner class This pointer to inner class. this.member-current inner class outerclassname.this--outer class for inner class applicable modifier is -- public,default, final,abstract,strictfp,+private,protected,static outer$inner is the name of inner class name. inner class inside instance method then we can acess static and instance field of outer class.

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

2016-03-01 07:10:09

其他回答

使用静态嵌套类而不是非静态类在某些情况下可以节省空间。例如:在一个类中实现一个比较器，比如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。

2016-10-22 13:13:37

JVM knows no nested classes. Nesting is just syntactic sugar. Below images shows Java file: Below images show class files representation of the java file : Notice that 2 class files are generated, one for parent and another for nested class. Non-static nested class' objects have access to the enclosing scope. That access to the enclosing scope is maintained by holding an implicit reference of the enclosing scope object in the nested object Nested class is a way to represent the intent that the nested class type represents a component of the parent class. public class Message { private MessageType messageType; // component of parent class public enum MessageType { SENT, RECEIVE; } } class Otherclass { public boolean isSent(Message message) { if (message.getMessageType() == MessageType.SENT) { // accessible at other places as well return true; } return false; } } private static nested class represents Point#3 & the fact the nested type can only be the subcomponent to the parent class. It can't be used separately. public class Message { private Content content; // Component of message class private static class Content { // can only be a component of message class private String body; private int sentBy; public String getBody() { return body; } public int getSentBy() { return sentBy; } } } class Message2 { private Message.Content content; // Not possible } More details here.

2020-09-18 05:53:38

在构建器模式中使用静态内部类。静态内部类可以实例化只有私有构造函数的外部类。你不能对内部类做同样的事情，因为你需要在访问内部类之前创建外部类的对象。

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

2016-10-26 16:25:59

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

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

2008-10-31 13:46:06