泛型参数跨方法传递问题求助：如何正确传递类型参数？

你遇到的问题核心是Java泛型擦除机制导致的：当你在方法a里创建new GenericType<T>(){}时，编译后泛型参数T会被擦除为Object，GenericType无法获取到实际的类型信息，所以抛出了IllegalArgumentException。

为什么不能这么用？ #

GenericType的工作原理是通过匿名内部类保留编译时的类型信息，但如果传入的是泛型参数（比如T、E）而不是具体类型（比如String、Exception），擦除后它根本不知道你指的是什么类型，自然会报错。

解决方案分两种场景： #

场景1：方法b不需要实际类型信息（只是创建Data对象）

如果你的b方法只是用来初始化Data实例，不需要基于T或E做反射等操作，那完全不需要传递GenericType，直接让泛型参数自动推断即可：

修改后的代码：

import javax.ws.rs.core.GenericType;
public class Test {
    public static void main(String[] args) throws IllegalAccessException, InstantiationException {
        new Test().a(() -> "ABC");
        new Test().a(() -> 42);
        new Test().a(() -> Boolean.TRUE);
    }
    public <T, E extends Exception> T a(UpdateFunction<T, E> function) throws InstantiationException, IllegalAccessException, E {
        // 直接调用b，泛型参数T、E会从当前上下文自动推断
        Data<T,E> data = b();
        data.data = function.update(); 
        return data.data;
    }
    // 移除GenericType参数，泛型参数由调用方推断
    public <T, E extends Exception> Data<T, E> b() throws IllegalAccessException, InstantiationException {
        return new Data<T, E>(); 
    }
    public class Data <T, E extends Exception> {
        T data;
    }
    @FunctionalInterface
    public interface UpdateFunction <T, E extends Exception>{
        T update() throws E;
    }
}

场景2：方法b需要实际类型信息（比如反射、序列化）

如果你的b方法确实需要基于T或E做类型相关操作，那必须让调用者在调用a方法时传递具体的类型信息，而不是依赖泛型参数T/E。可以用GenericType（或Class对象）来传递：

修改后的代码：

import javax.ws.rs.core.GenericType;
public class Test {
    public static void main(String[] args) throws IllegalAccessException, InstantiationException {
        // 调用时传入具体的GenericType实例
        new Test().a(new GenericType<String>() {}, new GenericType<Exception>() {}, () -> "ABC");
        new Test().a(new GenericType<Integer>() {}, new GenericType<Exception>() {}, () -> 42);
        new Test().a(new GenericType<Boolean>() {}, new GenericType<Exception>() {}, () -> Boolean.TRUE);
    }
    // 修改方法a的参数，接收具体的GenericType实例
    public <T, E extends Exception> T a(GenericType<T> type, GenericType<E> exceptionType, UpdateFunction<T, E> function) throws InstantiationException, IllegalAccessException, E {
        Data<T,E> data = b(type, exceptionType);
        data.data = function.update(); 
        return data.data;
    }
    public <T, E extends Exception> Data<T, E> b(GenericType<T> type, GenericType<E> exception) throws IllegalAccessException, InstantiationException {
        // 这里可以用type.getRawType()获取实际类型做操作
        System.out.println("实际数据类型：" + type.getRawType());
        return new Data<T, E>(); 
    }
    public class Data <T, E extends Exception> {
        T data;
    }
    @FunctionalInterface
    public interface UpdateFunction <T, E extends Exception>{
        T update() throws E;
    }
}

补充说明 #

如果你觉得传递GenericType太繁琐，也可以用Class<T>和Class<E>来替代，原理是一样的——都是传递编译时确定的具体类型信息，避免泛型擦除的影响。

内容的提问来源于stack exchange，提问作者munHunger