Java 混合内部类和静态嵌套类

我试图找出静态嵌套类和内部类（非静态嵌套类）在实现上的细微差别。例如，在上，可以找到以下代码：

public class Queue<Item> implements Iterable<Item> {
    private Node<Item> first;    // beginning of queue
    private Node<Item> last;     // end of queue
    private int N;               // number of elements on queue

    // helper linked list class
    private static class Node<Item> {
        private Item item;
        private Node<Item> next;
    }

    ...
    /**
     * Returns an iterator that iterates over the items in this queue in FIFO order.
     *
     * @return an iterator that iterates over the items in this queue in FIFO order
     */
    public Iterator<Item> iterator()  {
        return new ListIterator<Item>(first);  //why parameter needed?
    }

    // an iterator, doesn't implement remove() since it's optional
    private class ListIterator<Item> implements Iterator<Item> {
        private Node<Item> current;  //why not current = first?

        public ListIterator(Node<Item> first) {
            current = first;
        }

        public boolean hasNext()  { return current != null;                     }
        public void remove()      { throw new UnsupportedOperationException();  }

        public Item next() {
            if (!hasNext()) throw new NoSuchElementException();
            Item item = current.item;
            current = current.next; 
            return item;
        }
    }
    ...

公共类队列实现Iterable{
private Node first；//队列的开头
private Node last；//队列结束
private int N；//队列上的元素数
//助手链表类
私有静态类节点{
私人物品；
私有节点下一步；
}
...
/**
*返回一个迭代器，该迭代器按FIFO顺序遍历此队列中的项。
*
*@返回一个迭代器，该迭代器按FIFO顺序遍历此队列中的项目
*/
公共迭代器迭代器（）{
返回新的ListIterator（第一个）；//为什么需要参数？
}
//迭代器不实现remove（），因为它是可选的
私有类ListIterator实现了迭代器{
私有节点当前；//为什么不当前=第一个？
公共ListIterator（节点优先）{
电流=第一；
}
公共布尔值hasNext（）{返回当前值！=null；}
public void remove（）{抛出新的UnsupportedOperationException（）；}
公共项目下一步（）{
如果（！hasNext（））抛出新的NoSuchElementException（）；
项目=当前项目；
当前=当前。下一步；
退货项目；
}
}
...

---

我想知道为什么您必须通过

列表迭代器的构造函数传递变量
first
？为什么我不能在声明时使用
私有节点current=first；
。我知道如果我对
节点使用了内部类，我可以直接将
first
分配给
current
（如中所示）.
嵌套类有点奇怪。在第一个示例中，我们有一个静态嵌套类。它必须通过“父类”访问
变量
OuterClass
的实例，因为它没有封闭的
OuterClass
实例。当我们静态定义嵌套类时，几乎就像它们是在自己的单独文件中定义的一样。唯一的区别是静态嵌套类可以访问
OuterClass
的私有成员，而如果它们被反编译，则不会访问在他们自己的单独档案中罚款

public class OuterClass{
    private Object variable = "variable";

    private static class StaticNestedClass{
        private OuterClass parent;

        private StaticNestedClass(OuterClass p){ parent = p; }

        private void method(){
            //This line compiles:
            System.out.println("variable = "+parent.variable);

            //This won't - there's no OuterClass enclosing instance:
            //System.out.println("variable = "+OuterClass.this.variable);

            //This one won't either, for the same reason:
            //System.out.println("variable = "+variable);
        }
    }
}

让我们稍微修改一下。现在我们的嵌套类不是静态的，这意味着它包含在
OuterClass
的实例中。它仍然可以访问
OuterClass
的私有成员，但我们不需要将
OuterClass
的实例存储到其构造函数中，因为它隐式地引用了包围它的
OuterClass
实例

public class OuterClass{
    private Object variable = "variable";

    private class InnerClass{
        private void method(){
            //This line compiles:
            System.out.println("variable = "+variable);

            //So does this one - both lines refer to the same 
            //enclosing instance of OuterClass:
            System.out.println("variable = "+OuterClass.this.variable);
        }
    }
}

它不是必需的，但它更好的封装。祝贺你获得了正确的术语。“静态内部”是一个。OP的这一点非常正确。不要混淆这个问题。它仍然是在外部类块中定义的，不是吗？请阅读链接或OP的括号。你要查找的单词是“嵌套的”。修复了它-天哪…我一直在使用它从12年前读大学开始，术语就乱七八糟了……哎呀……；）你可不是唯一一个这么做的人。我已经在这里贴了几十次甚至几百次了。