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如何使用泛型擦除。结果，你不能这样做。

你可能能够做的事情，更详细一点，就是在迭代列表时使用枚举中的类cast方法，但即便如此你也不会能够做任何动态通用任务。

Answer 3

实际上，这可能会有点破解，这就是为什么GSON能够从JSON构造List<T> - 它使用TypeToken<T>类来解决＆＃34;键入的通用超类＆＃34;匿名typetoken实现。

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

//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为获得超类所做的事情。

所以我找到了this：

//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中的神奇代码以及更重要的Canonicalize method in $Gson$Types所示，他们使用内部Sun类的重新实现版本，例如： ParametrizedTypeImpl等（因为他们有私人访问权限）。

所以，如果你制作一个＆＃34; enum＆＃34;像这样：

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();
    }
}

它有效。

最棒的是，您还可以将＆＃34; enum＆＃34;的参数替换为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

正如其他人已经说过的那样，你不能。看看这里获取更多信息： How To Instantiate a java.util.ArrayList with Generic Class Using Reflection

使用类实例作为泛型类型

5 个答案: