Question

问题：我在类中定义了一个Function Object接口：

    public static interface FunctionObject<T>  {
        void process(T object);
    }

我需要它是通用的，因为我想在流程实现中使用T方法然后，在其他泛型类中，我有一个Map，其中我将类作为键和函数对象作为值：

    Map<Class<T>, FunctionObject<T>> map;

但是我也希望地图接受子类型和超类型OF KEY TYPE的函数对象，所以我这样做了：

    Map<Class<? extends T>, FunctionObject<? super T>> map; //not what I need

基本思路是能够按如下方式使用地图：

    //if T were Number, this should be legal
    map.put(Class<Integer>, new FunctionObject<Integer>(){...});
    map.put(Class<Float>, new FunctionObject<Number>(){...});
    map.put(Class<Double>, new FunctionObject<Object>(){...});

由于我想强制执行FunctionObject具有类键或超类型的类型，我真正想要定义的是：

    Map<Class<E extends T>, FunctionObject<? super E>>> map;

如何达到预期的效果？类型安全的异质容器是唯一的选择吗？ Map泛型类型允许从引用中填充它的样子是什么？

Answer 1

你可以使用封装来做到这一点，假设你只使用地图通过每个条目检查一次的方法。

以下的add方法也避免了对类型加倍的需要。

public class Main {
interface FunctionObject<T> { }

private final Map<Class, FunctionObject> map = new LinkedHashMap<Class, FunctionObject>();

public <T> void add(FunctionObject<T> functionObject) {
    Class<T> tClass = null;
    for (Type iType : functionObject.getClass().getGenericInterfaces()) {
        ParameterizedType pt = (ParameterizedType) iType;
        if (!pt.getRawType().equals(FunctionObject.class)) continue;
        Type t = pt.getActualTypeArguments()[0];
        tClass = (Class<T>) t;
        break;
    }
    map.put(tClass, functionObject);
}

public <T> void put(Class<T> tClass, FunctionObject<T> functionObject) {
    map.put(tClass, functionObject);
}

public <T> FunctionObject<T> get(Class<T> tClass) {
    return map.get(tClass);
}

public static void main(String... args) throws IOException {
    Main m = new Main();
    m.add(new FunctionObject<Integer>() {
    });
    FunctionObject<Integer> foi = m.get(Integer.class);
    System.out.println(foi.getClass().getGenericInterfaces()[0]);
}
}

打印

Main.Main$FunctionObject<java.lang.Integer>

如果要禁用警告，可以使用@SuppressWarnings("unchecked")。

重点是;没有办法描述你在字段声明中的约束，如果你使用访问器方法进行每个条目的检查，你可以获得相同的结果。如果需要确保原始类型正确，也可以添加运行时检查。

Answer 2

参数化容器，似乎工作正常：

public class MyMap<T>
{
    interface FunctionObject<X> {}

    private Map<Class<? extends T>, FunctionObject<Object>> map = new HashMap<>();

    @SuppressWarnings("unchecked")
    public <E extends T> void put(Class<E> c, FunctionObject<? super E> f)
    {
        map.put(c, (FunctionObject<Object>) f);
    }

    public <E extends T> FunctionObject<Object> get(Class<E> c)
    {
        return map.get(c);
    }

    public static void Main(String[] args)
    {
        MyMap<Number> map = new MyMap<>();

        map.put(Integer.class, new FunctionObject<Integer>() {});
        map.put(Float.class, new FunctionObject<Number>() {});
        map.put(Double.class, new FunctionObject<Object>() {});
    }
}

已编辑以遵守该问题。可悲的是，没有办法避免倾向于反对。

修改已添加get()。

泛型：如何在Map中强制键和值之间的限制

2 个答案: