wrapper osztaly, származtatás

Hello,
készítettem egy wrapper osztalyt, és abból szerettem volna származtatni egy másikat, és felülírni az eredetinek a put metodusat, ám ez nem sikerült. Mivel, a netbeans hibat dobott, amit nemértek, hogy mit, miért:
/home/tyson/Progs/Nyelvtechnológia - Ricsi/progs/proba/parse/src/parse/VerifyListMap.java:20: name clash: put(K,E) in parse.VerifyListMap<K,E> and put(K,E) in parse.ListMap have the same erasure, yet neither overrides the other

A kód:
wrapper osztaly:


import java.util.ArrayList;
import java.util.Collection;
import java.util.HashMap;

import java.util.LinkedList;
import java.util.Map;
import java.util.Map.Entry;
import java.util.List;
import java.util.Set;


public class ListMap<K extends Object, E extends Object> {
   
    private Map<K,List<E> > map;
    private int size;
    /** Creates a new instance of ListMap */
    public ListMap() {
        map = new HashMap<K,List<E> >();
    }
   
    public int size() {
        return map.size();
    }
   
    public boolean isEmpty() {
        return map.isEmpty();
    }
   
    public boolean containsKey(Object key) {
        return map.containsKey(key);
    }
   
    public boolean containsValue(Object value) {
        for (Entry<K,List<E> > entry:map.entrySet()){
            List<E> List = entry.getValue();
            if (List.contains(value)){
                return true;
            }
        }
       
        return false;
    }
   
    public List<E> get(Object key) {
        return map.get(key);
    }
   
    public List<E> put(K key, E value) {
        List<E> List = map.get(key) ;
        if (List == null){
            List = new ArrayList();
        }
        List.add(value);
       
        return map.put(key,List);
    }
   
    public List<E> remove(Object key) {
        return map.remove(key);
    }
   
    public void putAll(Map<? extends K, ? extends E> t) {
        for (Entry<? extends K,? extends E > entry:t.entrySet()){
            this.put(entry.getKey(),entry.getValue());
        }
    }
   
    public void clear() {
        map.clear();
    }
   
    public Set<K> keySet() {
        return map.keySet();
    }
   
    public Collection<E> values() {
        Collection<E> ret = new LinkedList<E>();
        for (Entry<K,List<E> > entry:map.entrySet()){
            List<E> List = entry.getValue();
            ret.addAll(List);
        }
        return ret;
    }
   
    public Set<Map.Entry<K, List<E> > > entrySet() {
        return map.entrySet();
    }
   
    public List<Object> put(K key, List<Object> value) {
        return put(key,value) ;
    }
   
    public Map getMap(){
        return map;
    }
   
}

A gyerek:
import java.util.ArrayList;
import java.util.List;
import java.util.Map;

/**
 *
 * @author tyson
 */
public class VerifyListMap<K extends Object, E extends Object> extends ListMap{
   
     Map<K,List<E> > map;
    /** Creates a new instance of VerifyListMap */
    public VerifyListMap() {
        map = super.getMap();      
    }
   
    public List<E> put(K key, E value) {
        List<E> List = (List)map.get(key) ;
        //System.out.println("key:"+key);
        if (key.equals("p") || key.equals("h") || key.equals("l") || key.equals("0")){
           
            if (List == null){
                List = new ArrayList();
            }
            List.add(value);
           
        } else {
            throw new ListMapPutException("hibas bemenet");
        }
        return map.put(key,List);
    }
}

Itt próbálkoztam kis googlizás után olyanal, hogy:
public class VerifyListMap<K extends Object, E extends Object> extends ListMap<K extends Object, E extends Object>{
Ám ez nem volt egy sikersztori.
Segítséget előre is köszönöm.
Tyson