使用类实例作为泛型类型

Question

有没有办法使用SomeClass.class作为类型的泛型类型？

例如，我有一个枚举：

enum MyEnum {
    FOO(String.class);
    private Class fooClass;
    private MyEnum(Class fooClass) {
        this.fooClass = fooClass;
    }
    public Class getFooClass(){
        return fooClass;
    }
}

然后在我的代码中的某个地方：

List<MyEnum.FOO.getFooClass()> list = new ArrayList<>();

Answer 1

在编译时评估泛型，而此调用的值为：

MyEnum.FOO.getFooClass()

只在运行时才知道。

Answer 2

通用类型在编译时使用，而不是在运行时使用 - 看看Java如何使用泛型擦除。 结果，你不能这样做。

你可能能够做到，这是更详细的不少，就是用铸造方法你从枚举有，而你遍历列表中的类，但即使如此，你将无法做任何动态通用分配。

Answer 3

其实，这是可能的一个黑客位，这就是为什么GSON是能够构建的List<T>从JSON -它采用了TypeToken<T>类来解决“输入通用父”匿名typetoken实施。

基于此，我认为应该可以从Class<T>对象获取List<T>实例，如果我们可以以某种方式提取JSON反序列化，并且只是像这样构造列表本身。

//from https://stackoverflow.com/a/18321048/2413303
private <T> List<T> getList(Class<T> elementType) {
    ...
    TypeToken<List<T>> token = new TypeToken<List<T>>() {}
        .where(new TypeParameter<T>() {}, elementType);
    List<T> something = gson.fromJson(data, token); //this would have needed to be replaced
    ...
}

我试图找出GSON为获得超类所做的工作。

所以我发现了这个 ：

//from https://stackoverflow.com/a/75345/2413303
//from subclass
T instance = ((Class)((ParameterizedType)this.getClass().
       getGenericSuperclass()).getActualTypeArguments()[0]).newInstance();

然后我尝试了这个：

public static abstract class MyTypeToken<T> {
    public T factory() {
        try {
            Type type = getClass().getGenericSuperclass();
            ParameterizedType paramType = (ParameterizedType) type;
            return ((Class<T>) paramType.getActualTypeArguments()[0]).newInstance();
        } catch (InstantiationException e) {
            e.printStackTrace();
            throw new RuntimeException(e);
        } catch (IllegalAccessException e) {
            e.printStackTrace();
            throw new RuntimeException(e);
        }
    }
}

和

    MyTypeToken<String> typeToken = new MyTypeToken<String>() {
    };
    System.out.println(typeToken.factory().getClass().getName()); //works and prints java.lang.String

但是以下崩溃：

public <T> List<T> getList(Class<T> clazz) {
    MyTypeToken<ArrayList<T>> token = new MyTypeToken<ArrayList<T>>() {};
    return token.factory();
}

同

Exception in thread "main" java.lang.ClassCastException: sun.reflect.generics.reflectiveObjects.ParameterizedTypeImpl cannot be cast to java.lang.Class

所以我很确定Google会遇到这种情况，正如他们在TypeToken中的魔术代码以及更重要的$ Gson $ Types中的Canonicalize方法所表明的那样，他们使用内部Sun类的重新实现版本，例如ParametrizedTypeImpl等（因为他们有私人访问权限 ）。

所以，如果你像这样制作一个“enum”：

public static abstract class MyEnum<T> {
    public static final MyEnum<String> FOO = new MyEnum<String>(new MyTypeToken<String>() {}) {};

    protected MyTypeToken<T> typeToken;

    private MyEnum(MyTypeToken<T> typeToken) {
        this.typeToken = typeToken;
    }

    public MyTypeToken<T> getTypeToken() {
        return typeToken;
    }
}

public void execute() {
    String string = MyEnum.FOO.getTypeToken().factory();
    System.out.println(string.getClass().getName());
}

然后你得到java.lang.String ，但是如果你将它与ArrayList<String> ，那么你得到了

Exception in thread "main" java.lang.ClassCastException: sun.reflect.generics.reflectiveObjects.ParameterizedTypeImpl cannot be cast to java.lang.Class
    at com.company.Main$TypeToken.factory(Main.java:19)
    at com.company.Main.execute(Main.java:49)
    at com.company.Main.main(Main.java:55)
    at sun.reflect.NativeMethodAccessorImpl.invoke0(Native Method)
    at sun.reflect.NativeMethodAccessorImpl.invoke(NativeMethodAccessorImpl.java:62)
    at sun.reflect.DelegatingMethodAccessorImpl.invoke(DelegatingMethodAccessorImpl.java:43)
    at java.lang.reflect.Method.invoke(Method.java:483)
    at com.intellij.rt.execution.application.AppMain.main(AppMain.java:134)

---

所以我想 如果你不想窃取GSON内部代码就 可以 做到这一点（使用GSON和它自己的TypeToken）：

import com.google.gson.Gson;
import com.google.gson.reflect.TypeToken;
import java.util.ArrayList;
import java.util.List;

/**
 * Created by EpicPandaForce on 2015.05.06..
 */
public class Main {
    public static abstract class MyEnum<T> { //typed `enum`-like structure
        public static final MyEnum<String> FOO = new MyEnum<String>(new TypeToken<String>() {}) {};

        protected TypeToken<T> typeToken;

        private MyEnum(TypeToken<T> typeToken) {
            this.typeToken = typeToken;
        }

        public TypeToken<T> getTypeToken() {
            return typeToken;
        }
    }

    public static <T> TypeToken<ArrayList<T>> getListToken(TypeToken<T> typeToken) {
        return new TypeToken<ArrayList<T>> () {};
    }

    public void execute() {
        Gson gson = new Gson();
        List<String> list = gson.fromJson("[]", getListToken(MyEnum.FOO.getTypeToken()).getType()); //construct empty list using GSON
        list.add("hello");
        System.out.println(list.get(0)); //writes out hello
    }

    public static void main(String[] args) {
        Main main = new Main();
        main.execute();
    }
}

它有效。

最好的是你也可以将“ enum ”的参数替换为Class<T>对象，并获得相同的结果。 此外，您可以使列表的初始化成为静态方法的一部分。

这是最终的代码 ：

public class Main {
    public static abstract class MyEnum<T> {
        public static final MyEnum<String> FOO = new MyEnum<String>(String.class) {};

        protected Class<T> typeToken;

        private MyEnum(Class<T> clazz) {
            this.typeToken = clazz;
        }

        public Class<T> getClazz() {
            return typeToken;
        }
    }

    public static class ListFactory {
        private static Gson gson;

        static {
            gson = new Gson();
        }

        private static <T> TypeToken<ArrayList<T>> getListToken(Class<T> typeToken) {
            return new TypeToken<ArrayList<T>> () {};
        }

        public static <T> List<T> getList(Class<T> clazz) {
            return gson.fromJson("[]", getListToken(clazz).getType());
        }
    }



    public void execute() {
        List<String> list = ListFactory.getList(MyEnum.FOO.getClazz());
        list.add("hello");
        System.out.println(list.get(0));
    }

    public static void main(String[] args) {
        Main main = new Main();
        main.execute();
    }
}

输出是

hello

但是，是的，你做不了类似的事情

List<MyEnum.FOO.getFooClass()> 

您需要知道您获得的对象是List<String> 。

Answer 4

由于明显的事实，这是不可能的： FOO.getFooClass()表达式的值是runtime评估的，而所有泛型都是compile-time处理的，并且在runtime没有关于泛型类型的任何信息。

Answer 5

正如其他人已经说过的那样，你做不到。 在这里查看更多信息： 如何使用反射实例化具有泛型类的java.util.ArrayList