Java-为什么在这种情况下静态很重要

Question

I've two questions that relates to the following code (Linked Bag):

public class LinkedBag<Item> implements Iterable<Item> {

private Node first;    // beginning of bag
private int N;         // number of elements in bag

private class Node {
    private Item item;
    private Node next;
}

and this one

public class Bag<Item> implements Iterable<Item> {
private Node<Item> first;    // beginning of bag
private int N;               // number of elements in bag

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

1. What's the difference between Node<Item> and Node here? both implementations are generic, so how Node and Node<Item> differ here ?
2. What's the meaning of static in the second version, why is it crucial ? ( doesn't compile without static).

Thanks !

Answer 1

If your nested class is not static , then it's an inner class, and the enclosing class's type parameter Item is in scope. However, if your nested class is static , then the enclosing class's type parameter is not in scope, because that type parameter has to do with an instance of the enclosing class, which is not relevant for a static nested class.

Here, the static class Node declares its own Item type parameter. It could have declared any other name and it would have been equivalent. You should not receive a compiler error using Node<Item> in your second case (with the static class); that is legal.

Answer 2

1. What's the difference between Node<Item> and Node here?

Adding a generic parameter is necessary because Java prohibits static inner classes of generic types from referencing type parameters of their outer types.

2. What's the meaning of static in the second version?

static means that Node instances do not get a reference to their parent class, and can be created outside of its context if it is necessary. It is not exactly "crucial", but shrinks your node by a third (two references vs. three references), which is an advantage.

Answer 3

If a nested class is not static (called an inner class ), it means that every instance belongs to an instance of the enclosing class. Therefore in the first example, a Node instance belongs to a LinkedBag<Item> , so it already has a generic type Item (from LinkedBag<Item> ).

An instance of a static nested class does not belong to an instance of the enclosing type, so it does not get the generic type parameter from an enclosing instance - you need to give it its own generic parameter.

Looking at the source code for the various Collection and Map implementations in the standard Java collections framework, you can see that both approaches to Node classes (static and non-static) are commonly used.