Generics syntax and Comparing Comparables of type ?

I am trying to write a RangedMap and when I "genericify" it, it
occurred to me that I am not completely sure how I can Quite express
the syntax. Admittedly I am learning my generics, but the code is
definitely correct when I remove the generics (run main for a test).

Essentially, I want to be able to apply this Map to any Comparable
object such as Date, Integer, String, whatever. Clearly though, the
comparison must be between comparables of the Same Type.

So, Comparable<?> min and Comparable<?> max could both be Integers,
but 1 can't be Integer and the other Date. Maybe the code will explain
better. Anyone have some input?

Christian
http://christian.bongiorno.org

/**
 * Date: Jul 9, 2007
 * Time: 4:25:18 PM
 * This Map allows for a ranged mapping of values. The key can be
anything comparable such
 * as Numbers and Dates or Strings
 */

import java.util.TreeMap;
import java.util.Map;

public class RangedMap<RangedKey, V> extends TreeMap<RangedKey, V> {

    public static void main(String[] args) {
        Map<RangedKey, String> testMap = new RangedMap<RangedKey,
String>();
        testMap.put(new RangedKey(50, 60), "Blue");
        testMap.put(new RangedKey(61, 70), "Yellow");
        testMap.put(new RangedKey(71, 80), "Red");

        System.out.println(testMap.get(new RangedKey(55)));
        System.out.println(testMap.get(new RangedKey(67)));
        System.out.println(testMap.get(new RangedKey(73)));

        System.out.println(testMap.get(new RangedKey(1)));
        System.out.println(testMap.get(new RangedKey(90)));

        testMap.put(new RangedKey(62, 80), "Fail");

    }

    public V put(RangedKey key, V value) {
        rangeCheck(key.getMin());
        rangeCheck(key.getMax());

        return super.put(key, value);
    }

    public void putAll(Map<? extends RangedKey, ? extends V> map) {
        for (Map.Entry<? extends RangedKey, ? extends V> entry :
map.entrySet())
            put(entry.getKey(), entry.getValue());
    }

    private void rangeCheck(Comparable<?> c) throws
IllegalArgumentException {
        V val = get(new RangedKey(c));
        if (val != null)
            throw new IllegalArgumentException("range: " + c + "
overlaps with another range and would cause an ambiguous mapping ");
    }

    public static final class RangedKey implements
Comparable<RangedKey> {
        private Comparable<?> min;
        private Comparable<?> max;

        public RangedKey(Comparable<?> single) {
            this.min = single;
            this.max = single;
        }

        public RangedKey(Comparable<?> min, Comparable<?> max) {
            this.min = min;
            this.max = max;
        }

        public int compareTo(RangedKey range) {

            if (this.max.compareTo(range.min) < 0)
                return -1;
            if (this.min.compareTo(range.max) > 0)
                return 1;
            else
                return 0;
        }

        public Comparable<?> getMin() {
            return min;
        }

        public Comparable<?> getMax() {
            return max;
        }

        public String toString() {
            return min + "-" + max;
        }
    }
}