Kotlin中如何限定泛型为无公共父类的特定类型并合并相似函数？

1. 可以通过泛型合并两个函数 #

完全可以用泛型抽象这两个逻辑一致的函数，核心是利用Kotlin的重载解析机制，让泛型函数自动匹配bar的对应重载版本。

假设原函数实现如下：

// 原f1函数
fun f1(key: String, value: JsonNullable<ByteArray?>): SomeType? {
    return if (value.exists()) {
        if (value.value == null) delete(key) else bar(value)
    } else null
}

// 原f2函数
fun f2(key: String, value: JsonNullable<String?>): SomeType? {
    return if (value.exists()) {
        if (value.value == null) delete(key) else bar(value)
    } else null
}

合并后的泛型函数只需将类型参数抽象为<T>，其余逻辑完全复用：

fun <T> f(key: String, value: JsonNullable<T?>): SomeType? {
    return if (value.exists()) {
        if (value.value == null) delete(key) else bar(value)
    } else null
}

调用时，Kotlin会根据传入的JsonNullable具体类型自动匹配对应的bar重载，无需额外处理。

2. 限制泛型参数只能是特定类型（String/ByteArray） #

由于String和ByteArray没有非Any的公共父类，直接用普通泛型约束无法实现“只能是这两类”的限制，以下是三种常用方案：

方案一：重载辅助函数（最简洁） #

将泛型逻辑封装为私有内部函数，对外只暴露针对String和ByteArray的重载版本。这样用户只能调用允许的类型，间接实现约束：

// 私有泛型核心逻辑
private fun <T> fInternal(key: String, value: JsonNullable<T?>): SomeType? {
    return if (value.exists()) {
        if (value.value == null) delete(key) else bar(value)
    } else null
}

// 对外暴露的仅允许String的版本
fun f(key: String, value: JsonNullable<String?>): SomeType? = fInternal(key, value)

// 对外暴露的仅允许ByteArray的版本
fun f(key: String, value: JsonNullable<ByteArray?>): SomeType? = fInternal(key, value)

方案二：密封类封装目标类型 #

用密封类包裹允许的类型，强制泛型参数只能是密封类的子类，从类型系统层面限制范围：

// 密封类定义允许的类型
sealed class AllowedType {
    data class StringWrapper(val value: String) : AllowedType()
    data class ByteArrayWrapper(val value: ByteArray) : AllowedType()
}

// 调整后的泛型函数
fun f(key: String, value: JsonNullable<AllowedType?>): SomeType? {
    return if (value.exists()) {
        if (value.value == null) {
            delete(key)
        } else {
            // 根据密封类分支调用对应bar重载
            when (val wrappedValue = value.value) {
                is AllowedType.StringWrapper -> bar(JsonNullable.of(wrappedValue.value))
                is AllowedType.ByteArrayWrapper -> bar(JsonNullable.of(wrappedValue.value))
            }
        }
    } else null
}

调用时需将String或ByteArray封装为AllowedType的子类，确保类型合法。

方案三：Reified泛型+编译时检查 #

利用Kotlin的reified泛型和契约（Contracts），在编译期检查类型合法性，非法类型会触发编译警告或运行时错误：

import kotlin.contracts.ExperimentalContracts
import kotlin.contracts.contract

@OptIn(ExperimentalContracts::class)
inline fun <reified T> f(key: String, value: JsonNullable<T?>): SomeType? {
    // 定义契约，让编译器识别合法类型
    contract {
        returnsNotNull() implies (T::class == String::class || T::class == ByteArray::class)
    }

    // 检查类型合法性，非法类型直接报错
    check(T::class in setOf(String::class, ByteArray::class)) {
        "仅支持String或ByteArray类型，当前类型：${T::class.simpleName}"
    }

    return if (value.exists()) {
        if (value.value == null) delete(key) else bar(value)
    } else null
}

这种方式无需额外封装，直接在调用时检查类型，适合不想修改调用方式的场景。

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