Java - generics & wildcards & interface versus implementation

Question

I have a question about Java generics. Say I have the following interface:

public static class Something<T> {
    public void set(T t) {
    }
}

public static interface Manager<T> {
    public void add(final String key, final Something<T> o);

    public Something<T> get(final String key);
}

An example of usage:

final Manager<Number> m = ...;

m.add("key", new Something<Number>());
m.get("key").set(new Integer(5));

I would also like to be able to add Something<Integer>, Something<Double>, ... to the a Manager<Number>. I would say I have to change the signature of the add-function:

public static interface Manager<T> {
    public void add(final String key, final Something<? extends T> o);

    public Something<T> get(final String key);
}

final Manager<Number> m = ...;

m.add("key", new Something<Integer>());
m.get("key").set(new Integer(5));

So far, so good. Let's look at a possible implementation of the manager:

public static class ManagerImplementation<T> implements Manager<T> {
    protected HashMap<String, Something<T>> map = new HashMap<String, Something<T>>();

    public void add(final String key, final Something<? extends T> o) {
        map.put(key, o); // <--- here
    }

    public Something<T> get(final String key) {
        return map.get(key);
    }
}

This fails, since you cannot add a Something<? extends T> to a Map<X, Something<T>>. So let's change this:

public static class ManagerImplementation<T> implements Manager<T> {
    protected HashMap<String, Something<? extends T>> map = new HashMap<String, Something<? extends T>>();

    public void add(final String key, final Something<? extends T> o) {
        map.put(key, o);
    }

    public Something<T> get(final String key) {
        return map.get(key); // <--- here
    }
}

This fails since map.get(key) returns Something<? extends T> while the get-function is required to return Something<T>, as defined in the interface.

What is the common approach to solve this?

Thanks!

Answer 1

Inside your class you are always using Something<? extends T>, thus in your public get method you must convert the inside world to the outside world format. E.g. you can simply cast the result of map.get(key) to Something<T>:

return (Something<T>) map.get(key); // <--- here