Почему private final java.util.List < E > стек объявлен здесь как переменная?

Question

Я смотрю на реализацию интерфейса Stack, используя List как базовую структуру данных, и я никогда ничего не видел, прежде чем объявлять что-то вроде этого. Обычно я вижу java.util.something как импорт. Когда я буду использовать что-то вроде этого?

public class ListStack<E> implements Stack<E> 
{ 
    private final java.util.List<E> stack; 


    public ListStack() 
    { 
     this.stack = new LinkedList<E>(); 
    } 


    @Override 
    public boolean isEmpty() 
    { 
     return this.stack.isEmpty(); 
    } 


    @Override 
    public E peek() 
    { 
     if (this.stack.isEmpty()) 
     { 
      throw new EmptyStackException(); 
     } 
     return this.stack.get(this.stack.size() - 1); 
    } 


    @Override 
    public E pop() 
    { 
     if (this.stack.isEmpty()) 
     { 
      throw new EmptyStackException(); 
     } 
     return this.stack.remove(this.stack.size() - 1); 
    } 


    @Override 
    public void push(E element) 
    { 
     this.stack.add(this.stack.size(), element); 

    } 


    @Override 
    public int size() 
    { 
     return this.stack.size(); 
    } 

} 

стек интерфейс

public interface Stack<E> 
{ 
    public boolean isEmpty(); 
    public E peek(); 
    public E pop(); 
    public void push(E element); 
    public int size(); 
} 

Answer 1

С точки зрения только декларации переменной стека,

public class ListStack<E> implements Stack<E> { 
    private final java.util.List<E> stack; 
    ... 
} 

и

import java.util.List; 
public class ListStack<E> implements Stack<E> { 
    private final List<E> stack; 
    ... 
} 

есть, для всех намерений и целей , идентичны.

Обычно вы видите объявления квалифицированного типа, отображаемые в объявлениях переменных, когда есть что-то, что приходит на импорт, который конфликтует с объявляемой вещью. Подумайте, есть ли у меня собственный org.rekdev.List, который я хочу использовать для чего-то еще в ListStack, но мне нужен обычный java.util.List для самого стека. Что теперь?

Если я попытаюсь просто выполнить импорт, компилятор жалуется.

import org.rekdev.List; 
import java.util.List; 

public class ListStack<E> implements Stack<E> { 
    private List<E> stack; 
    private List<E> myOwnList; 
} 

ListStack.java:2: org.rekdev.List is already defined in a single-type import 
import java.util.List; 
^ 
1 error 

Если я попытаюсь задать проблему, компилятор больше жалуется.

import org.rekdev.*; 
import java.util.*; 

public class ListStack<E> implements Stack<E> { 
    private List<E> stack; 
    private List<E> myOwnList; 
} 

ListStack.java:5: reference to List is ambiguous, both class java.util.List in java.util and class org.rekdev.List in org.rekdev match 
    private List<E> stack; 
      ^
ListStack.java:6: reference to List is ambiguous, both class java.util.List in java.util and class org.rekdev.List in org.rekdev match 
    private List<E> myOwnList; 
      ^
2 errors 

Компилятор - жестокая, жестокая хозяйка, которая принимает только совершенство. Поскольку в области компилятора имеется более одного Списка, я должен «дизамешивать» объявления типа переменной. Я мог забыть импорт и быть все подробным везде ...

public class ListStack<E> implements Stack<E> { 
    private java.util.List<E> stack; 
    private org.rekdev.List<E> myOwnList; 
} 

Это работает, но это много печатает. В качестве альтернативы, я могу импортировать один и полностью квалифицировать другой.

import org.rekdev.*; 

public class ListStack<E> implements Stack<E> { 
    // This kid is java.util.List 
    private java.util.List<E> stack; 
    // This kid is org.rekdev.List 
    private List<E> myOwnList; 

}

Это, как правило, то, что вы видите. Полностью квалифицированный - это кросс-кейс, который происходит только один раз в исходном файле, что позволяет импортировать как можно больше пространства имен в область видимости. Хозяйка счастлива.