如何通过单类型参数推导返回值类型简化Java泛型接口？

首先需要修正你提供的枚举代码（原枚举存在语法错误：字段未修饰、常量定义格式错误、静态方法无法返回实例字段等），然后可以通过以下几种方式实现你的需求：

方案1：预定义类型三元组容器 + 接口静态工厂（推荐） #

这种方式既简化了使用者的调用，又能严格限制合法的类型三元组，避免不兼容组合。

步骤1：定义类型三元组容器 #

// 封装合法的A/B/C类型组合，私有构造确保只能创建预定义实例
public class TypeTriplet<A, B, C> {
    public final Class<A> aType;
    public final Class<B> bType;
    public final Class<C> cType;

    private TypeTriplet(Class<A> aType, Class<B> bType, Class<C> cType) {
        this.aType = aType;
        this.bType = bType;
        this.cType = cType;
    }

    // 预定义所有合法的类型三元组
    public static final TypeTriplet<String, Integer, Boolean> STR_INT_BOOL =
            new TypeTriplet<>(String.class, Integer.class, Boolean.class);
    public static final TypeTriplet<Long, Float, Double> LONG_FLOAT_DOUBLE =
            new TypeTriplet<>(Long.class, Float.class, Double.class);
}

步骤2：保留原三泛型接口，添加静态工厂方法 #

public interface MyInterface<A, B, C> {
    A method1();
    B method2();
    C method3();

    // 静态工厂方法：通过TypeTriplet自动推导A/B/C类型，避免手动声明
    static <A, B, C> MyInterface<A, B, C> create(TypeTriplet<A, B, C> triplet,
                                                 Supplier<A> method1Impl,
                                                 Supplier<B> method2Impl,
                                                 Supplier<C> method3Impl) {
        return new MyInterface<>() {
            @Override
            public A method1() {
                return method1Impl.get();
            }

            @Override
            public B method2() {
                return method2Impl.get();
            }

            @Override
            public C method3() {
                return method3Impl.get();
            }
        };
    }
}

使用方式 #

使用者无需手动指定A/B/C类型，直接传入预定义的TypeTriplet即可，编译器会自动推断类型：

// 自动推导为MyInterface<String, Integer, Boolean>
var myInstance = MyInterface.create(TypeTriplet.STR_INT_BOOL,
                                    () -> "Hello",
                                    () -> 42,
                                    () -> true);

方案2：泛型枚举 + 抽象类封装 #

如果坚持使用枚举，可以定义带泛型的枚举，再通过抽象类封装泛型参数，实现接口的简化：

步骤1：泛型枚举定义 #

public enum Triplet<A, B, C> {
    STR_INT_BOOL(String.class, Integer.class, Boolean.class),
    LONG_FLOAT_DOUBLE(Long.class, Float.class, Double.class);

    public final Class<A> aType;
    public final Class<B> bType;
    public final Class<C> cType;

    Triplet(Class<A> aType, Class<B> bType, Class<C> cType) {
        this.aType = aType;
        this.bType = bType;
        this.cType = cType;
    }
}

步骤2：抽象类封装泛型 #

// 抽象类绑定Triplet和对应的A/B/C类型
public abstract class AbstractMyInterface<T extends Triplet<A, B, C>, A, B, C> implements MyInterface<A, B, C> {
    protected final T triplet;

    protected AbstractMyInterface(T triplet) {
        this.triplet = triplet;
    }
}

步骤3：实现类 #

public class StrIntBoolImpl extends AbstractMyInterface<Triplet<String, Integer, Boolean>, String, Integer, Boolean> {
    public StrIntBoolImpl() {
        super(Triplet.STR_INT_BOOL);
    }

    @Override
    public String method1() {
        return "Test";
    }

    @Override
    public Integer method2() {
        return 123;
    }

    @Override
    public Boolean method3() {
        return false;
    }
}

这种方式的优点是通过枚举强制类型组合的合法性，缺点是实现类需要声明多个泛型参数，略繁琐。

方案3：单泛型接口 + 类型转换（不推荐） #

如果一定要将接口限制为单个泛型参数，可以通过Triplet作为泛型，再配合类型转换，但会失去编译时类型安全：

public interface MyInterface<T extends Triplet<?, ?, ?>> {
    default Object method1() {
        return null;
    }

    default Object method2() {
        return null;
    }

    default Object method3() {
        return null;
    }
}

// 实现类
public class StrIntBoolImpl implements MyInterface<Triplet<String, Integer, Boolean>> {
    private final Triplet<String, Integer, Boolean> triplet = Triplet.STR_INT_BOOL;

    @Override
    public String method1() {
        return "Hello";
    }

    @Override
    public Integer method2() {
        return 42;
    }

    @Override
    public Boolean method3() {
        return true;
    }
}

这种方式虽然接口只有一个泛型，但编译器无法强制实现类的返回类型与Triplet匹配，存在类型安全隐患，仅在特殊场景下使用。

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