Override method error
<p>I am getting the following error when I'm compiling my code...</p>

<pre><code>BSLinkedList.java:10: error: BSLinkedList is not abstract and does not override abstract method push(T) in BoundedStack
public class BSLinkedList &lt;T&gt; implements BoundedStack&lt;T&gt;{
       ^
  where T is a type-variable:
    T extends Object declared in class BSLinkedList
</code></pre>

<p>I have tried to make sure that everything I am using is generic type T.  All of the questions I've found on this topic say that people have not implemented a method from the interface, however I have implemented the method push as well as all other methods from my interface! I appreciate any help or guidance anyone can supply! Thank you!</p>

<pre><code>import java.util.EmptyStackException;
import java.util.*;
/**
 * The class BSLinkedList implements the Stack ADT as described
 * in cpsc331Stack using a linked list
 *
 * @version 1.0
 */ 
public class BSLinkedList &lt;T&gt; implements BoundedStack&lt;T&gt;{
        public class StackNode&lt;T&gt; {
        private T value;
        public StackNode&lt;T&gt; next;
        private int capacity;
        public StackNode&lt;T&gt; top;
        private int size;

        public StackNode(T x, StackNode&lt;T&gt; n){
            value = x;
            next = n;
        }


        public void BSLinkedList(int capacity) {
        assert capacity &gt;= 0;

        LinkedList&lt;T&gt; stack = new LinkedList&lt;T&gt;();
        size = 0;
        top = (StackNode&lt;T&gt;)null;
    }

        public boolean isEmpty(){
        assert size &gt;= 0;
            if (size == 0){
                return true;
            }
            else{
                return false;
            }
        }

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

        public int capacity(){
            return capacity;
        }

        public int size(){
            return size;
        }

        public void push(T x) {
            if (isFull()){
                throw new FullStackException();
            }       
            else{
                ++size;
                top = new StackNode&lt;T&gt;(x, top);
            }
        }

        public T top(){
            if(isEmpty()){
                throw new EmptyStackException();
            }
            else{
                return top.value;
            }
        }

        public T pop(){
            if (isEmpty()){
                throw new EmptyStackException();
            }
            else{
                T e = top.value;
                top = top.next;
                --size;
                return e;
            }
        }

    }
}
</code></pre>

<p>and the interface...</p>

<pre><code>/**
* The BoundedStack interface represents the Bounded Stack ADT as described in CPSC 331.
* This interface extends the interface cpsc331Stack.
*
* @version 1.0
*/
public interface BoundedStack&lt;T&gt; extends cpsc331Stack&lt;T&gt;{

    /**
     * Returns the number of elements currently on the stack.
     *
     * @return the number of elements on the stack
     */
    public int size();

    /**
     * Returns the maximum number of elements the stack can store.
     * 
     * @return the maximum number of elements the stack can store
     */
    public int capacity();

    /**
     * Tests whether the stack is full.
     *
     * @return true if number of elements in the stack is equal to 
     * the stack's capacity, false otherwise
     */
     public boolean isFull();

    /**
     * Pushes the object x onto the top of the stack.
     *
     * @param x object to be pushed onto the stack.
     * @throws FullStackException if the stack is full
     */
    public void push (T x);

}
</code></pre>

<p>Other implementation that is working correctly...    </p>

<pre><code>import java.util.EmptyStackException;

/**
 * The class BSArray implements the Stack ADT as described
 * in cpsc331Stack using an array
 *
 * @version 1.0
 */ 
public class BSArray &lt;T&gt; implements BoundedStack&lt;T&gt;{
        private T[] stack;
        private int size;
        private int top = -1;;
        private int capacity;

    /** 
     * Creates a new BSArray of size capacity
     *
     * @param capacity integer value of the maximum number of elements the array can store  
     */ 

        public BSArray(int capacity) {
            assert capacity &gt;= 0;
            stack = (T[]) new Object[capacity];
        }
    /**
     * Tests whether or not the stack is empty.
     *
     * @return true if the stack is empty, false otherwise
     */
        public boolean isEmpty(){
            if (size &gt;= 0){
                return true;
            }
            else{
                return false;
                }
        }
    /**
     * Tests whether or not the stack is full.
     *
     * @return true if number of elements in the stack is equal to 
     * the stack's capacity, false otherwise
     */
        public boolean isFull(){
            if (size == capacity){
                return true;
            }
            else{
                return false;
            }
        }

    /**
     * Returns the maximum number of elements the stack can store.
     * 
     * @return the maximum number of elements the stack can store
     */
        public int capacity(){
            return capacity;
        }

    /**
     * Returns the number of elements currently on the stack.
     *
     * @return the number of elements on the stack
     */
        public int size(){
            return size;
        }

    /**
     * Pushes the object x onto the top of the stack.
     *
     * @param x object to be pushed onto the stack.
     * @throws FullStackException if the stack is full
     */
        public void push(T x){
            if (isFull()){
                throw new FullStackException();
            }
            else{
                ++top;
                ++size;
                stack[top] = x;
            }
        }
    /**
     * Returns the object at the top of the stack.
     *
     * @return reference to the item at the top of the stack
     * @throws EmptyStackException if the stack is empty
     */
        public T top(){
            if(isEmpty()){
                throw new EmptyStackException();
            }
            else{
                return (T) stack[top];
            }
        }
    /**
     * Removes and returns the object at the top of the stack.
     *
     * @return reference to the item at the top of the stack
     * @throws EmptyStackException if the stack is empty
     */
        public T pop(){
            if (isEmpty()){
                throw new EmptyStackException();
            }
            else{
                assert top &gt;= -1;
                T e = stack[top];
                stack[top] = null;
                --top;
                --size;
                return e;
            }
        }
}
</code></pre>

<p>cpsc331Stack interface</p>

<pre><code>/**
 * The cpsc331Stack interface represents the Stack ADT as described
 * in CPSC 331.
 *
 * @version 1.0
 */
public interface cpsc331Stack&lt;T&gt; {

    /**
     * Tests whether the stack is empty.
     *
     * @return true if the stack is empty, false otherwise
     */
    public boolean isEmpty();

    /**
     * Pushes the object x onto the top of the stack.
     *
     * @param x object to be pushed onto the stack.
     */
    public void push(T x);

    /**
     * Returns the object at the top of the stack.
     *
     * @return reference to the item at the top of the stack
     * @throws EmptyStackException if the stack is empty
     */
    public T top();

    /**
     * Removes and returns the object at the top of the stack.
     *
     * @return reference to the item at the top of the stack
     * @throws EmptyStackException if the stack is empty
     */
    public T pop();
}   
</code></pre>