Question

我对以下代码中使用静态内部类有疑问，改编自Eckel的Thinking in Java第4版（第625页）。

代码使用名为Node的静态内部类。当您创建堆栈结构时，您可以将节点推入堆栈并将其弹出 - 到目前为止一切都很好。但我很困惑为什么节点类是静态的？这不意味着在LinkedStack类中只创建了一个Node吗？实际上/为什么你可以将许多不同的节点推入堆栈，然后将它们弹出（当然这是堆栈应该做的事情）。实际上，您可以将private static class Node更改为“私有类节点”，它也可以工作......那么为什么Eckels会选择静态类节点？

在这个例子中，输入是三个词“Phasers”，“on”，“stun！”输出是“stun！”，“on”，“Phasers”。

public class LinkedStack<T> {

    //generic inner class node
    private static class Node<U> {

        U item;
        Node<U> next;
        Node() {
            item = null;
            next = null;
        }
        Node(U item, Node<U> next) {
            this.item = item;
            this.next = next;
        }
        boolean isDummyNode() {
            return item == null && next == null;
        }
    }

    //initialize top of stack as a dummy first node
    private Node<T> top = new Node<T>();

    public void push(T item) {
        top = new Node<T>(item, top);
    }

    public T pop() {
        T result = top.item;
        if(!top.isDummyNode())
            top = top.next;
        return result;
    }

    public static void main(String[] args) {
        LinkedStack<String> stack = new LinkedStack<String>();
        for(String s : "Phasers on stun!".split(" "))
            stack.push(s);
        String s;
        while((s = stack.pop()) != null)
            System.out.println(s);
    }

}

Answer 1

不，静态内部类是不需要封闭类型实例的类，在方法或字段的上下文中使用时，它与静态不同。内部类的静态特性使它们成为顶级类。声明非静态内部类时，它具有对实例字段和封闭类型方法的隐式访问权限，因此使所述类型的实例成为必需。静态类没有那么奢侈，因此不需要封闭类型的实例。

Answer 2

静态内部类与外部类（在本例中为LinkedStack）相关联，而不与其实例相关联。对于非静态内部类，应该有外部类的封闭实例。如果Node不是静态的，则意味着对于Node的任何实例，必须有LinkedStack的实例包含该实例。

将Node类作为静态使它更像是一个未绑定到外部类实例的顶级类。因此，其他类可以创建Node的实例，而无需创建LinkedStack的任何实例。

有关差异的更多详细信息，请参阅Java教程中的Nested classes。

使用静态内部类

2 个答案: