如何在Java/Kotlin实现类似C++的泛型参数转发至非泛型类型的机制？

这确实是JVM平台因类型擦除带来的典型泛型限制问题，我来分享几种兼顾优雅性和扩展性的实现思路，覆盖Java/Kotlin通用方案和Kotlin独有的优化方式：

方案一：重载工厂函数（Java/Kotlin通用，最贴近C++编译期检查效果） #

这种思路核心是利用重载函数的编译期匹配特性，只对外暴露针对支持类型的工厂方法，不直接允许实例化泛型类，从而实现不支持类型的编译报错。

先定义基类：

// Kotlin版本
abstract class UniformValueBase(protected val handle: Int, protected val shader: Shader) {
    abstract fun apply()
}

// Java版本
public abstract class UniformValueBase {
    protected final int handle;
    protected final Shader shader;

    protected UniformValueBase(int handle, Shader shader) {
        this.handle = handle;
        this.shader = shader;
    }

    public abstract void apply();
}

然后针对每个支持的类型，编写私有子类+公开工厂函数：

// Kotlin版本：私有子类隐藏实现细节
private class IntUniformValue(handle: Int, shader: Shader, private val value: Int) : UniformValueBase(handle, shader) {
    override fun apply() = shader.setUniform(handle, value)
}

private class FloatUniformValue(handle: Int, shader: Shader, private val value: Float) : UniformValueBase(handle, shader) {
    override fun apply() = shader.setUniform(handle, value)
}

private class FloatListUniformValue(handle: Int, shader: Shader, private val value: List<Float>) : UniformValueBase(handle, shader) {
    override fun apply() = shader.setUniform(handle, value)
}

// 对外暴露的工厂函数，仅支持预定义类型
fun uniformValue(handle: Int, shader: Shader, value: Int): UniformValueBase = IntUniformValue(handle, shader, value)
fun uniformValue(handle: Int, shader: Shader, value: Float): UniformValueBase = FloatUniformValue(handle, shader, value)
fun uniformValue(handle: Int, shader: Shader, value: List<Float>): UniformValueBase = FloatListUniformValue(handle, shader, value)

// Java版本：用静态工厂方法+匿名内部类简化子类定义
public class UniformValues {
    public static UniformValueBase createInt(int handle, Shader shader, int value) {
        return new UniformValueBase(handle, shader) {
            @Override
            public void apply() {
                shader.setUniform(handle, value);
            }
        };
    }

    public static UniformValueBase createFloat(int handle, Shader shader, float value) {
        return new UniformValueBase(handle, shader) {
            @Override
            public void apply() {
                shader.setUniform(handle, value);
            }
        };
    }

    public static UniformValueBase createFloatList(int handle, Shader shader, List<Float> value) {
        return new UniformValueBase(handle, shader) {
            @Override
            public void apply() {
                shader.setUniform(handle, value);
            }
        };
    }
}

优点：完全模拟C++的编译期检查效果，不支持的类型直接编译失败；实现简洁，新增类型只需添加对应的工厂函数；Java和Kotlin都能方便使用。

方案二：Kotlin类型类模式（更灵活的扩展方式） #

如果需要更灵活的类型扩展（比如允许外部模块新增支持类型），可以用Kotlin的类型类(Type Class) 模式，通过接口定义"可作为Uniform的类型"，再为支持类型实现该接口：

// 定义类型类接口，描述类型如何被设置为Uniform
interface UniformSetter<T> {
    fun set(shader: Shader, handle: Int, value: T)
}

// 为每种支持的类型实现接口
object IntUniformSetter : UniformSetter<Int> {
    override fun set(shader: Shader, handle: Int, value: Int) = shader.setUniform(handle, value)
}

object FloatUniformSetter : UniformSetter<Float> {
    override fun set(shader: Shader, handle: Int, value: Float) = shader.setUniform(handle, value)
}

object FloatListUniformSetter : UniformSetter<List<Float>> {
    override fun set(shader: Shader, handle: Int, value: List<Float>) = shader.setUniform(handle, value)
}

// 扩展函数：让类型自动获取对应的Setter
inline fun <reified T> T.uniformSetter(): UniformSetter<T> = when (T::class) {
    Int::class -> IntUniformSetter as UniformSetter<T>
    Float::class -> FloatUniformSetter as UniformSetter<T>
    List::class -> FloatListUniformSetter as UniformSetter<T>
    else -> error("Unsupported uniform type: ${T::class.simpleName}")
}

// 泛型UniformValue类，依赖UniformSetter
class UniformValue<T>(
    private val handle: Int,
    private val shader: Shader,
    private val value: T,
    private val setter: UniformSetter<T> = value.uniformSetter()
) : UniformValueBase(handle, shader) {
    override fun apply() = setter.set(shader, handle, value)
}

优点：扩展性极强，外部模块可以自行实现UniformSetter接口来新增支持类型；代码更具声明式风格。
注意：默认情况下uniformSetter()的类型判断是运行时的，若要实现编译期检查，可以配合Kotlin的contract或者编译插件（比如KSP）来增强，但对于仅需支持6种左右类型的场景，运行时检查完全够用。

方案三：Java泛型+方法引用（兼顾泛型和编译期检查） #

如果想在Java中保留泛型的灵活性，同时实现编译期检查，可以用泛型类+方法引用封装Setter逻辑，通过静态工厂方法限制支持的类型：

import java.util.function.TriConsumer;
import java.util.List;

public class UniformValue<T> extends UniformValueBase {
    private final T value;
    private final TriConsumer<Shader, Integer, T> setter;

    private UniformValue(int handle, Shader shader, T value, TriConsumer<Shader, Integer, T> setter) {
        super(handle, shader);
        this.value = value;
        this.setter = setter;
    }

    @Override
    public void apply() {
        setter.accept(shader, handle, value);
    }

    // 针对每种支持类型的静态工厂方法
    public static UniformValue<Integer> createInt(int handle, Shader shader, int value) {
        return new UniformValue<>(handle, shader, value, Shader::setUniform);
    }

    public static UniformValue<Float> createFloat(int handle, Shader shader, float value) {
        return new UniformValue<>(handle, shader, value, Shader::setUniform);
    }

    public static UniformValue<List<Float>> createFloatList(int handle, Shader shader, List<Float> value) {
        return new UniformValue<>(handle, shader, value, Shader::setUniform);
    }
}

优点：Java中保留了泛型的类型信息，同时通过工厂方法实现编译期检查；代码比手动编写多个子类更简洁。

综合来看，如果你的场景只需要支持固定几种类型，方案一的重载工厂函数是最直接、最贴近C++效果的选择；如果需要长期扩展支持类型，Kotlin的类型类模式会更优雅。

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