获得通用类型的“真实”类

时间:2011-04-26 01:54:22

标签: java generics

如何获得泛型类型的“真实”类?

例如:

public class MyClass<T> {
    public void method(){
        //something

        System.out.println(T.class) //causes a compile error, I wont the class name

        //something
    }
}

如果T =整数

输出:

java.lang.Integer

如果T = String

输出:

java.lang.String

由于

5 个答案:

答案 0 :(得分:22)

如果你的类中有一个类型为T的实例变量,并且碰巧设置了它,那么你可以打印该变量的类。

public class Test<T> {

    T var;

    public static void main(String[] args) {
        Test<Integer> a = new Test<Integer>();
        System.out.println(a.boo());
        a.setVar(new Integer(10));
        System.out.println(a.boo());
    }

    public String boo() {
        if (var == null) {
            return "Don't know yet";
        }
        return var.getClass().getSimpleName();
    }

    public void setVar(T var) {
        this.var = var;
    }

    public T getVar() {
        return var;
    }
}

答案 1 :(得分:12)

你做不到。在编译时从代码中剥离信息,这个过程称为类型擦除。有关详情,请查看此处:Type Erasure

编辑:抱歉我的不好,信息没有在运行时加载。

答案 2 :(得分:4)

正如其他人所解释的那样,你不能以这种方式做到这一点,但这就是它通常在java中实现的方式。

public class MyClass<T> {
    public void method(Class<T> clazz) {
        // something

        System.out.println(clazz.getName());

        // something
    }
}

你就像这样使用它

new MyClass<String>().method(String.class);

答案 3 :(得分:3)

就你的情况而言,你不能。但是,您可以将超类型标记用于此类事物:http://gafter.blogspot.com/2006/12/super-type-tokens.html

这些的示例实现是Jackson json处理库的TypeReference类。

这是高级的东西,可能比你想知道的更多; - )

答案 4 :(得分:0)

请注意,在使用泛型类型接收的实例上依赖于'getClass()'的方法将获得该对象的实际类型,这不一定是泛型类型 - 这是调用者知道实例的类型

例如,考虑调用者通过接口处理对象的情况;当传递给泛型构造时,泛型类型将是接口,而不是实例的实际类。

考虑以下示例“Pair”类,它允许通过POJO返回两个对象引用:

public class Pair<U,V>
{
    public final U first;
    public final V second;
    public static <U,V> Pair<U,V> of (U first, V second)
    {
        return new Pair<U,V> (first, second);
    }
    protected Pair (U first, V second)
    {
        this.first  = first;
        this.second = second;
    }
}

如果U和V都是Comparable,我们正在考虑如何修改'Pair.of()'工厂函数以返回Comparable Pair派生类。然而,虽然我们可以使用instanceof来判断“第一”和“第二”是否具有可比性,但我们不知道“U”和“V”本身是可比较的。

为此,Pair.of()返回的Pair的确切类型必须取决于泛型类型,不是实际的参数类型。