Java泛型,如何获取T的class

11 篇文章 0 订阅
3 篇文章 0 订阅
public class TypeReference<T> {

    private final Type type;

    protected TypeReference(){
        Type superClass = getClass().getGenericSuperclass();

        type = ((ParameterizedType) superClass).getActualTypeArguments()[0];
    }

    public Type getType() {
        return type;
    }
    
    public final static Type LIST_STRING = new TypeReference<List<String>>() {}.getType();
}



    public static void main(String args[]) {


        List<Integer> list = new ArrayList<>();
        list.add(1);
        list.add(2);
        list.add(3);

        List<Integer> list11 = JSON.parseObject(json, new TypeReference<List<Integer>>(){});

        System.out.println("list11:" + list11);

    }
public abstract class Human extends SpiritBase{
    
    private String humanName;

    public String getHumanName() {
        return humanName;
    }

    public void setHumanName(String humanName) {
        this.humanName = humanName;
    }

}

public class RPC extends SpiritBase{

    private String rpcName;

    public String getRpcName() {
        return rpcName;
    }

    public void setRpcName(String rpcName) {
        this.rpcName = rpcName;
    }
}


public abstract class SpiritBase {

    private Integer id;


    public Integer getId() {
        return id;
    }

    public void setId(Integer id) {
        this.id = id;
    }

}
public class SpiritData<T extends SpiritBase> {

    private String id;

    private List<T> data;

    public String getId() {
        return id;
    }

    public void setId(String id) {
        this.id = id;
    }

    public List<T> getData() {
        return data;
    }

    public void setData(List<T> data) {
        this.data = data;
    }

    public Class getDataClass() {
        return (Class) ((ParameterizedType) this.getClass().getGenericSuperclass()).getActualTypeArguments()[0];
    }

    @Override
    public String toString() {
        return "SpiritData{" +
                "id='" + id + '\'' +
                ", data=" + data +
                '}';
    }

    public static void main(String args[]) {

        SpiritData<RPC> data = new SpiritData<RPC>() {};//gson打印不了这样的

        RPC rpc = new RPC();
        rpc.setRpcName("rpcNameTest");
        List<RPC> rpcList = new ArrayList<>();
        rpcList.add(rpc);
        data.setData(rpcList);
        System.out.println(data);
        System.out.println(data.getData().getClass());
        System.out.println(data.getDataClass());
        System.out.println("gson data:" + JsonUtil.toJSONString(data, 100));
        System.out.println("gson rpc:" + JsonUtil.toJSONString(rpcList));

        System.out.println("data:" + data);
        System.out.println("fastJson:" + JSON.toJSONString(data));


        SpiritData<RPC> rpcData = new SpiritData<RPC>() {};//gson打印不了这样的
        System.out.println("gson rpc data:" + new Gson().toJson(rpcData));

    }
}

  • 0
    点赞
  • 2
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
Java获取泛型T的Class通常有两种方式。 第一种方式是使用泛型类的getClass()方法来获取泛型T的Class信息。这种方式的前提是必须要创建泛型对象。具体实现方法如下: ``` public class GenericClass<T>{ public Class<T> getGenericClass() { Class<T> cls = (Class<T>) ((ParameterizedType)getClass().getGenericSuperclass()).getActualTypeArguments()[0]; return cls; } } public class Main { public static void main(String[] args) { GenericClass<String> gc = new GenericClass<String>(){}; System.out.println(gc.getGenericClass()); } } ``` 第二种方式是使用TypeReference类。这是由Jackson库提供的一个工具类,可以避免在运行时由于泛型擦除而导致的Class信息丢失的问题。具体实现方法如下: ``` public abstract class TypeReference<T> { private final Type type; protected TypeReference() { Type superClass = getClass().getGenericSuperclass(); if (superClass instanceof Class<?>) { throw new IllegalArgumentException("Internal error: TypeReference constructed without actual type information"); } type = ((ParameterizedType) superClass).getActualTypeArguments()[0]; } public Type getType() { return type; } } public class Main { public static void main(String[] args) { TypeReference<List<String>> typeReference = new TypeReference<List<String>>() {}; System.out.println(typeReference.getType()); } } ``` 无论是哪种方式,获取泛型T的Class都可以方便地进行类型检查和类型转换操作。但需要注意的是,在获取泛型T的Class时,必须要保证T已经被实例化。如果T没有被实例化,则获取Class信息可能不准确,无法保证正确性。

“相关推荐”对你有帮助么?

  • 非常没帮助
  • 没帮助
  • 一般
  • 有帮助
  • 非常有帮助
提交
评论
添加红包

请填写红包祝福语或标题

红包个数最小为10个

红包金额最低5元

当前余额3.43前往充值 >
需支付:10.00
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明:

1.余额是钱包充值的虚拟货币,按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载,可以购买VIP、付费专栏及课程。

余额充值