Implementing abstract methods

Question

Hello guys,
I have a LPQueue class that implements a interface PQueue
Here are the fiels:
//PQueue interface
import java.util.Iterator;
interface PQueue<E extends Comparable<E>>
  public void insert(E x);
  public E peekMax();
  public E deleteMax();
  public int size();
  public void clear();
  public Iterator<E> iterator();
//LPQueue class
import java.util.*;
import java.util.Iterator;
public class LPQueue<E extends Comparable<E>> implements PQueue<E>
     private Node<E> first;
     private int size;
     public LPQueue(){
          first = null; //pointing to the first element
          size = 0;
     public void insert(E x){
          Node <E> tmp = new Node<E>(x);
          size++; //when we call insert we want to increase size by one to keep the size of queue current
          Node <E> p = first; //p points to first element
          Node <E> q = null; //this points to null initially because q has to stay behind p
          while(p != null && x.compareTo(p.data) > 0){
               q = p;
               p = p.next;
          if(q == null){
               tmp.next = first;
               first = tmp;
          else{
               tmp.next = p;
               q.next = tmp;
     public E peekMax(E x){
          if(size == 0){
               throw new NoSuchElementException();
          if(x.compareTo(first.data) > 0){
               return x;
          }else return first.data;
     public E deleteMax(E x){
          Node <E> tmp;
          if(size == 0){
               throw new NoSuchElementException();
          if(x.compareTo(first.data) > 0){
               first.data = null;
               return x;
          }else
               tmp = first;
               first.data = null;
          return tmp.data;
     public int size(){
          return size;
     public void clear(){
          size = 0;
          first = null;
     public Iterator<E> iterator()
         return new LQIterator();
     private class LQIterator implements Iterator<E>{
          public Node<E> current;
          private LQIterator()
              current = first;
            public boolean hasNext()
                return current !=null;
            public E next()
                if(!hasNext()){
                    throw new NoSuchElementException();
                E x = current.data;
                current = current.next;
                return x;
            public void remove()
                throw new UnsupportedOperationException();
     //seting up static Node class
     private static class Node <E>{
          public E data; //seting up paramtere data for node
          public Node<E> next; //
          public Node(E x){ //sting up constructor for Node passing the paramter x to data
               data = x;
}When i try to compile i get :
The type LPQueue<E> must implement the inherited abstract method PQueue<E>.deleteMax() LPQueue.java
The type LPQueue<E> must implement the inherited abstract method PQueue<E>.peekMax() LPQueue.java
I have written the definition for both the peekMax and deletMax methods why am i still getting the above error?
Thank you for your help,
-Lovac

Answer 1

The method signatures of the interface must match up exactly with the implementing classes. In the interface, neither method signature accepted a parameter, but in your concrete class, they do, and this just won't work.