Java编译错误: Cannot find symbol Priority Queue

Question

编译器中显示完整错误:ListPriorityQueue.java:11: 错误:找不到符号公共(public)类 ListPriorityQueue > 实现 PriorityQueue ^ 符号:类 PriorityQueue我只是不明白，因为显示的错误信息并不丰富。 PriorityQueue 确实存在于包中。

package data_structures;

import java.util.Iterator;
import java.util.NoSuchElementException;


/**
 * This is a linked list implementing ListADT interface
 * @param <E> The data type of the linked list
 */
public class ListPriorityQueue <E extends Comparable<E>> implements PriorityQueue<E>
{

       int count;           //number of elements in the queue
       Node<E> first;       //Head of the queue
       Node<E>  last;           //Tails of the queue
       int capacity= DEFAULT_MAX_CAPACITY;

       //Constructor
       public ListPriorityQueue()
       {
          first = null;
          last = null;
       }

       public ListPriorityQueue(int capacity )
       {
          first = null;
          last = null;
          this.capacity= capacity;
       }
            public boolean insert(E object) 
        {
            if(this.isFull())
                return false;

            Node<E> prev = null;
             Node<E> current = this.first;
             Node<E> temp = new Node<E>(object);
             // while (current != null && current.getData().pValue >= item.pValue)
             while (current != null && current.getData().compareTo(temp.getData())<0 )
              {
                 prev = current;
                 current = current.getNext();
              }

              if (prev == null)
              {
                 temp.setNext(this.first);
                 this.first = temp;
              }
              else
              {
                 temp.setNext(current);
                 prev.setNext( temp);
              }  

              count++;
            return true;
        }


       public E remove() 
       {
           E result;
           //If the list is empty
           if(count==0)
           {
               return null;
           }

           result= first.getData();
           first= first.getNext();

           count--;
           if(count==0)
           {
               last=null;
           }
           return result;
       }


            public E peek() 
        {
            if(count==0)
            {
                return null;
            }

            return first.getData();  //Return first element without removing
        }



       public int size()
       {
           return count;
       }
       public boolean contains (E target) 
       {
           boolean found= false;

           //If there is no element in the list
           if (count==0)
           {
               return found;
           }


          Node<E> current;
          current = first;

          // iterate the list looking for target
          while(!found && current != null)
          {
              //If current node data same as target
              if(target.equals(current.getData()))
              {
                 found = true;
              }
              else
                 current = current.getNext();
          }

          return found;
       }

           public Iterator<E> iterator()
       {
          return new TheIterator();
       }
            public void clear() 
        {
            //Loop to removeFirst till the list is empty 
            while (!this.isEmpty()) 
            {
                    this.remove();
             }

        }

       public boolean isEmpty()
       {
           if(count == 0){
           return true;}
           else{return false;}
       }

        public boolean isFull() 
        {
            if(count == capacity){  
              return true;}
              else { return false;}
        }









class Node<E>
{
  private Node<E> next; //Next element
  private E data;       //Data


 //Initialize Node
  public Node (E obj)
  {
    next = null;
    data = obj;
  }

  //Return next node
  public Node<E> getNext()
  {
    return next;
  }

  //Set the next node
  public void setNext (Node<E> node)
  {
    next = node;
  }

  //Get data of the node
  public E getData()
  {
    return data;
  }

  //Set node data
  public void setData (E obj)
  {
    data = obj;
  }
} 


/**
 * 
 * Iterartor for the passed in collection
 * @param <E>
 */
class TheIterator<E> implements Iterator<E>
{

   private Node<E> current; 


    public TheIterator ()
    {
       current = (Node<E>)first;     
    }


    public boolean hasNext()
    {
    return current != null;               
    }


    public E next() 
    {
       if ( hasNext() == false) //If there are no more elements
          throw new NoSuchElementException();

       E result = current.getData();
       current = current.getNext();
       return result;
    }


    public void remove()
    {
       throw new UnsupportedOperationException(); //remove not supported
    }
}
}

Answer 1

当你的编译器说

ListPriorityQueue.java:11: error: cannot find symbol 
public class ListPriorityQueue implements PriorityQueue 
                                          ^ 
    symbol: class PriorityQueue

这就是“什么是 PriorityQueue？我看到你想实现这个，但我不知道它是什么!”的方式。

javac 必须被告知程序的所有部分在哪里，以便它可以验证程序的所有代码是否正确，并且正确地组合在一起。如果单个文件依赖于其他代码，则无法仅编译该文件。你必须给它所有的信息。有多种方法可以实现此目的。

1. 具体列出文件。

   javac ListPriorityQueue.java PriorityQueue.java
   

   这告诉它您只对这两个文件感兴趣。你是说“编译器，在这些文件和标准库之间，这就是你需要知道的一切。”

2. 对编译器使用 sourcepath 参数(请注意，此命令在源代码实际所在路径的上一个文件夹中运行，而不是在同一文件夹中运行)。

   javac -sourcepath data_structures data_structures/PriorityQueue.java
   

   当您只有几个文件时，上面的数字 1 效果很好，但是如果您坚持使用 Java 编程，您很快就会了解到，您几乎永远不会只有几个文件。因此，编译器设计者添加了为其提供整个文件夹树以供使用的功能。当您执行此操作时，您是在对编译器说“我希望您编译 PriorityQueue.java，如果有您不认识的内容，请查看 data_structs文件夹。”

3. 使用编译器的 classpath 参数(这在您的特定情况下不起作用，请注意，我只是为了完整性而将其包括在内) .

   javac -classpath data_structures_api.jar PriorityQueue.java
   

   这对编译器说:“我希望你编译 PriorityQueue.java。我没有我的依赖项的源代码，但它们已经被编译了，并且编译的结果位于 data_structs_api.jar 中。您可以将其用于任何您不认识的内容。”这是告诉 java 编译器的一个非常常见的事情，因为大多数实际应用程序将使用以 .jar 文件形式分发的第 3 方库。

4. 以上选项可以组合使用。同时使用 sourcepath 和 classpath 参数是很常见的。编译整个源代码树，并使用第三方库。这实际上就是您的 IDE 正在为您做的事情，以及为什么它可以在其中工作，但不能在命令行上工作。