Problema interfaccia Comparable

[Darèios89]

Non va...preciso che nel compareTo confronto l'elemento di un nodo e quindi uso così compareTo nella classe BSTNode<E>

class BST<E extends Comparable> implements Comparable<BST<E>>
{
	private BSTNode<E> root;
	private int nodes;
	private final int CAPACITY;
	
	public BST(int CAPACITY)
	{
		this.CAPACITY=CAPACITY;
		root=null;
		nodes=0;
	}
	
	public BSTNode<E> getRoot(){return root;}
	public void setRoot(BSTNode<E> root){this.root=root;}
	public int nodes(){return nodes;}
	
	public void addNodo(BSTNode<E> nodo)
	{
		if(nodes==0)
			setRoot(nodo);
		
		else if(nodes<CAPACITY){
			boolean inserito=false;
			
			BSTNode<E> tmp=getRoot();
			
			while(!inserito){
				if(tmp.getElement().compareTo(nodo.getElement())<0)
				{
					if(!(tmp.hasRight())){
						tmp.setRight(nodo);
						inserito=true;
					}
					else tmp=tmp.getRight();
				}
				
			
				else if(tmp.getElement().compareTo(nodo.getElement())>0)
				{
					if(!(tmp.hasLeft())){
						tmp.setLeft(nodo);
						inserito=true;
					}
					else tmp=tmp.getLeft();
				}
			}
					
			}
		nodes++;
	}
	
	public E getMax(){
		if(getRoot()==null) return null;
		
		BSTNode<E> tmp=getRoot();
		
		while(tmp.hasRight())
			tmp=tmp.getRight();
		
		return (E)tmp;
	}
	
	
	public E remove()
	{
		if(nodes==0) return null;
		
		else{
			BSTNode<E> remove=(BSTNode)getMax();
			if(!(remove.hasRight()) && !(remove.hasLeft()))
			{
				remove.getParent().setRight(null);
				remove.setParent(null);
				nodes--;
				return (E)remove;
			}
			
			else{
				remove.getLeft().setParent(remove.getParent());
				remove.getParent().setRight(remove.getLeft());
				remove.setLeft(null);
				nodes--;
				return (E)remove;
				}
			}
	}
	
	public boolean find(E label)
	{
		boolean trovato=false;
		BSTNode<E> tmp=getRoot();
		BSTNode<E> node=new BSTNode(label);
		while(tmp!=null){
			
			if(tmp.getElement().compareTo(node.getElement())>0)
				tmp=tmp.getLeft();
			else if(tmp.getElement().compareTo(node.getElement())<0)
				tmp=tmp.getRight();
			
			else trovato=true;
		}
		
		return trovato;
	}
}

L'interfaccia diventa:

interface BSTSet270710<E extends Comparable>

E in Insieme ho:

class Insieme<E extends Comparable> implements Comparable<Insieme<E>>

Ma così non va, mi dà sempre errore nell'uso del comparable...

 BST is not abstract and does not override abstract method compareTo(BST<E>) in java.lang.Comparable
class BST<E extends Comparable> implements Comparable<BST<E>>

Credo dipenda sempre dal tipo che passo a Comparable.....

P.S. ma nella classe insieme che implementa tra l'altro l'interfaccia BSTSet non dovrei avere tra l'altro una dichiarazione così?

class Insieme<E extends Comparable> implements Comparable<Insieme<E>>, BSTSet270710<E>