java - 为什么 private Final java.util.List< E > stack 在这里声明为变量？

Question

已关闭。此问题不符合 Stack Overflow guidelines 。目前不接受答案。

---

这个问题似乎与 help center 中定义的范围内的编程无关。 .

已关闭 9 年前。

Improve this question

我正在研究使用 List 作为底层数据结构的 Stack 接口(interface)的实现，在声明这样的东西之前我从未见过任何东西。我通常看到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( );
    }

}

堆栈接口(interface)

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

编译器是一个残忍、残酷的情妇，只接受完美。因为编译器的作用域中有多个 List，所以我需要“消除”变量类型声明的歧义。我可能会忘记导入并且到处都是冗长的......

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;

}

这通常就是您所看到的。完全限定的情况是一些边缘情况，仅在源文件中发生一次，允许导入根据需要将尽可能多的命名空间带入范围。女主人很高兴。