Question

我正在使用List作为底层数据结构来查看Stack接口的实现，在被声明之前我从未见过任何东西。我通常将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

编译器是一个残忍，残忍的情妇，只接受完美。因为编译器范围中有多个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;

}

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

为什么私有最终java.util.List＆lt; E>这里将堆栈声明为变量？

1 个答案: