用于存储函数的Java-Typesafe异构容器模式

这是对的扩展。但是，我尝试使用

映射

来存储

函数

private static Map<Class<?>, Function<?, JSONObject>> serializers = new HashMap<>();

private static <T> void addSerializer(Class<T> klass, Function<T, JSONObject> fn) {
    serializers.put(klass, fn);
}

private static <T> Function<T, JSONObject> getSerializer(Class<T> klass) {
    return (Function<T, JSONObject>) serializers.get(klass);
}

static {
    // add entries with addSerializer
}

public static JSONObject serialize(Object object) {
    Class<?> klass = object.getClass();

    return serializers.get(klass).apply(klass.cast(object));
}

---

我能做些什么来解决这个问题，或者我能用另一种结构来实现同样的目标吗？

这里有一些魔法让编译器知道

klass

是

类

代表

对象

-s类型：

public static JSONObject serialize(Object object) {
    Class cls = object.getClass();
    return serialize(cls, cls.cast(object));
}

private static <T> JSONObject serialize(Class<T> klass, T object) {
    return getSerializer(klass).apply(object);
}

公共静态JSONObject序列化（对象对象）{
类cls=object.getClass（）；
返回序列化（cls，cls.cast（object））；
}
私有静态JSONObject序列化（类klass，T对象）{
返回getSerializer（klass）.apply（对象）；
}

第一个

serialize

方法检索类（或抛出

NullPointerException

），然后将对象强制转换为自己的类型，然后调用第二个

serialize

方法。现在，第二个

serialize

方法有自己的类型参数

T

，因此它可以安全地调用

函数。apply

---

不幸的是，我们需要这种间接方式来让编译器知道

klass

运行时类型标记是属于实际对象的标记。

以下是一些魔术，让编译器知道

klass

是表示

对象的
类
-s类型：

public static JSONObject serialize(Object object) {
    Class cls = object.getClass();
    return serialize(cls, cls.cast(object));
}

private static <T> JSONObject serialize(Class<T> klass, T object) {
    return getSerializer(klass).apply(object);
}

公共静态JSONObject序列化（对象对象）{
类cls=object.getClass（）；
返回序列化（cls，cls.cast（object））；
}
私有静态JSONObject序列化（类klass，T对象）{
返回getSerializer（klass）.apply（对象）；
}

第一个
serialize
方法检索类（或抛出
NullPointerException
），然后将对象强制转换为自己的类型，然后调用第二个
serialize
方法。现在，第二个
serialize
方法有自己的类型参数
T
，因此它可以安全地调用
函数。apply

不幸的是，我们需要这种间接方式来让编译器知道
klass
运行时类型标记是属于实际对象的标记。
我怀疑这两种类型是什么？都被视为同一个。您可能想创建另一个类来定义函数，而不是在同一位置定义它们的泛型？都被视为同一个。您可能希望创建另一个类来定义函数，而不是在同一位置定义它们的泛型。