1

编译器中显示的完整错误：ListPriorityQueue.java:11: 错误：找不到符号 public class 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
    }
}
}
4

1 回答 1

0

当你的编译器说

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

这就是它的说法“What's a PriorityQueue？我看到你想实现这个，但我不知道它是什么！”

javac必须告诉程序的所有部分在哪里，以便它可以验证程序的所有代码是否正确，并且可以正确组合在一起。如果单个文件依赖于其他代码，则无法编译它。你必须给它所有的信息。有几种方法可以做到这一点。

  1. 具体列出文件。

    javac ListPriorityQueue.java PriorityQueue.java

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

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

    javac -sourcepath data_structures data_structures/PriorityQueue.java

    当您只有几个文件时，上面的第 1 条效果很好，但是如果您坚持使用 java 编程，您很快就会知道，您几乎永远不会只有几个文件。所以编译器设计者添加了给它一个完整的文件夹树来工作的能力。当你这样做时，你是在对编译器说“我希望你编译PriorityQueue.java，如果有你不认识的东西，请查看data_structures文件夹。”

  3. 使用编译器的参数（这在您的特定classpath情况下不起作用，请注意，我只是为了完整性而包含它）。

    javac -classpath data_structures_api.jar PriorityQueue.java

    这对编译器说“我希望你编译PriorityQueue.java.data_structures_api.jar认出。” 这是告诉 java 编译器很常见的事情，因为大多数实际应用程序将使用以 .jar 文件形式分发的第三方库。

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

于 2013-11-12T15:51:39.180 回答