我见过类似的问题,但没有多大帮助。
例如我有这个通用类:
public class ContainerTest<T>
{
public void doSomething()
{
//I want here to determinate the Class of the type argument (In this case String)
}
}
以及使用此容器类的另一个类
public class TestCase
{
private ContainerTest<String> containerTest;
public void someMethod()
{
containerTest.doSomething();
}
}
是否可以确定方法 doSomething() 中类型参数的类没有具有显式类型变量/字段或 ContainerTest 类中的任何构造函数?
更新:更改了 ContainerTest 类的格式
唯一的方法是将类存储在实例变量中,并将其作为构造函数的参数:
public class ContainerTest<T>
{
private Class<T> tClass;
public ContainerTest(Class<T> tClass) {
this.tClass = tClass;
}
public void doSomething()
{
//access tClass here
}
}
如果您对反射方式感兴趣,我在这篇很棒的文章中找到了部分解决方案:http://www.artima.com/weblogs/viewpost.jsp?thread=208860
简而言之,您可以使用
java.lang.Class.getGenericSuperclass()
和 java.lang.reflect.ParameterizedType.getActualTypeArguments()
方法,但您必须子类化某些父超类。
以下代码片段适用于直接扩展超类
AbstractUserType
的类。请参阅参考文章以获取更通用的解决方案。
import java.lang.reflect.ParameterizedType;
public class AbstractUserType<T> {
public Class<T> returnedClass() {
ParameterizedType parameterizedType = (ParameterizedType) getClass()
.getGenericSuperclass();
@SuppressWarnings("unchecked")
Class<T> ret = (Class<T>) parameterizedType.getActualTypeArguments()[0];
return ret;
}
public static void main(String[] args) {
AbstractUserType<String> myVar = new AbstractUserType<String>() {};
System.err.println(myVar.returnedClass());
}
}
没有“干净”的方法可以从类中获取通用类型参数。 相反,一种常见的模式是将通用类型的类传递给构造函数,并将其保留为内部属性,就像在 java.util.EnumMap 实现中所做的那样。
http://docs.oracle.com/javase/1.5.0/docs/api/java/util/EnumMap.html http://grepcode.com/file/repository.grepcode.com/java/root/jdk/openjdk/6-b14/java/util/EnumMap.java
public class ContainerTest<T> {
Class<T> type;
T t;
public ContainerTest(Class<T> type) {
this.type = type;
}
public void setT(T t) {
this.t = t;
}
public T getT() {
return t;
}
public void doSomething() {
//There you can use "type" property.
}
}
不。这是不可能的,因为类型擦除(类型参数被编译为对象+类型转换)。如果您真的需要在运行时了解/强制执行该类型,您可以存储对
Class
对象的引用。
public class ContainerTest<T> {
private final Class<T> klass;
private final List<T> list = new ArrayList<T>();
ContainerTest(Class<T> klass) {
this.klass = klass;
}
Class<T> getElementClass() {
return klass;
}
void add(T t) {
//klass.cast forces a runtime cast operation
list.add(klass.cast(t));
}
}
用途:
ContainerTest<String> c = new ContainerTest<>(String.class);
有is有一种方法可以通过使用Guava的
TypeToken
来捕获类型参数的运行时类型。该解决方案的缺点是每次需要 Container
的实例时都必须创建一个匿名子类。
class Container<T> {
TypeToken<T> tokenOfContainedType = new TypeToken<T>(getClass()) {};
public Type getContainedType() {
return tokenOfContainedType.getType();
}
}
class TestCase {
// note that containerTest is not a simple instance of Container,
// an anonymous subclass is created
private Container<String> containerTest = new Container<String>() {};
@Test
public void test() {
Assert.assertEquals(String.class, containerTest.getContainedType());
}
}
此解决方案的关键在上面代码中使用的
TypeToken
构造函数的 JavaDoc 中进行了描述:
客户端创建一个空的匿名子类。这样做会将类型参数嵌入到匿名类的类型层次结构中,这样我们就可以在运行时重新构造它,尽管它被删除了。
如果你可以这样定义
public class ContainerTest<T>
{
public void doSomething(T clazz)
{
}
}
那就可以了