Kotlin泛型位置规律与设计考量

1. 泛型出现的位置分类

在Kotlin中，泛型可以出现在以下几个主要位置：

1.1 类声明中的泛型

kotlin 复制代码

class ViewRef<T : DeclarativeBaseView<*, *>>(
    val pagerId: String,
    val nativeRef: Int
) {
    val view: T?
        get() = PagerManager.getPager(pagerId)
            .getViewWithNativeRef(nativeRef) as? T
}

规律：

泛型参数<T : DeclarativeBaseView<*, *>>紧跟在类名后面
用于定义整个类的类型参数
可以在类的任何地方使用这个类型参数

设计考量：

类型安全：确保ViewRef只能引用特定类型的视图
代码复用：一个类可以处理多种类型，但保持类型安全
API一致性：所有ViewRef实例都有相同的方法签名，但类型不同

1.2 函数声明中的泛型

kotlin 复制代码

fun <T : DeclarativeBaseView<*, *>> T.ref(ref: (viewRef: ViewRef<T>) -> Unit) {
    ref(ViewRef<T>(pagerId, nativeRef))
}

规律：

泛型参数<T : DeclarativeBaseView<*, *>>在fun关键字和函数名之间
用于定义函数的类型参数
可以在函数的参数、返回值和函数体中使用这个类型参数

设计考量：

扩展函数：为特定类型的所有子类提供统一方法
类型推断：编译器可以自动推断T的类型
灵活性：同一个函数可以处理多种类型，但保持类型安全

1.3 接口声明中的泛型

kotlin 复制代码

interface IViewPublicApi<A : Attr, E : Event> {
    fun <T : DeclarativeBaseView<*, *>> T.ref(ref: (viewRef: ViewRef<T>) -> Unit)
    fun attr(init: A.() -> Unit)
    fun event(init: E.() -> Unit)
}

规律：

接口级别的泛型<A : Attr, E : Event>在接口名后
方法级别的泛型<T : DeclarativeBaseView<*, *>>在方法名前

设计考量：

接口泛型：定义接口的类型参数，影响整个接口
方法泛型：只影响特定方法的类型参数

2. 泛型位置的设计规律

2.1 作用域规律

kotlin 复制代码

// 类级别泛型：作用域是整个类
class ViewRef<T : DeclarativeBaseView<*, *>> {
    val view: T? // T在整个类中可用
    fun doSomething(): T? { return view } // T在方法中可用
}

// 函数级别泛型：作用域是整个函数
fun <T : DeclarativeBaseView<*, *>> T.ref(ref: (viewRef: ViewRef<T>) -> Unit) {
    // T只在函数内可用
    ref(ViewRef<T>(pagerId, nativeRef))
}

2.2 生命周期规律

kotlin 复制代码

// 类泛型：与类实例生命周期相同
class Container<T> {
    private val items = mutableListOf<T>()
    fun add(item: T) { items.add(item) }
    fun get(index: Int): T = items[index]
}

// 函数泛型：只存在于函数调用期间
fun <T> createList(vararg items: T): List<T> {
    return listOf(*items) // T只在函数执行期间有效
}

3. 泛型约束的位置规律

3.1 上界约束

kotlin 复制代码

// 类泛型约束
class ViewRef<T : DeclarativeBaseView<*, *>> { // T必须是DeclarativeBaseView的子类
    // ...
}

// 函数泛型约束
fun <T : DeclarativeBaseView<*, *>> T.ref(...) { // T必须是DeclarativeBaseView的子类
    // ...
}

// 多重约束
fun <T> process(item: T) where T : DeclarativeBaseView<*, *>, T : Cloneable {
    // T必须同时满足两个约束
}

3.2 型变约束

kotlin 复制代码

// 生产者位置（out）
class Producer<out T> {
    fun produce(): T { ... }
}

// 消费者位置（in）
class Consumer<in T> {
    fun consume(item: T) { ... }
}

// 不变位置
class Container<T> {
    fun get(): T { ... }
    fun set(item: T) { ... }
}

4. 泛型在Kotlin中的特殊位置

4.1 扩展函数中的泛型

kotlin 复制代码

// 扩展函数泛型：T是接收者类型
fun <T : DeclarativeBaseView<*, *>> T.ref(ref: (viewRef: ViewRef<T>) -> Unit) {
    // T既是泛型参数，也是接收者类型
}

// 扩展属性中的泛型
val <T : DeclarativeBaseView<*, *>> T.refCount: Int
    get() = 1

4.2 高阶函数中的泛型

kotlin 复制代码

// 函数类型中的泛型
fun <T> execute(operation: (T) -> Unit, param: T) {
    operation(param)
}

// 函数类型参数中的泛型
fun <T> ref(ref: (viewRef: ViewRef<T>) -> Unit) {
    // T在函数类型参数中使用
}

4.3 泛型型变

kotlin 复制代码

// 协变（out）
interface Producer<out T> {
    fun produce(): T
}

// 逆变（in）
interface Consumer<in T> {
    fun consume(item: T)
}

// 星投影
fun process(list: List<*>) {
    // List<*> 表示未知类型的List
}

5. 实际项目中的泛型位置选择

5.1 类泛型 vs 函数泛型

kotlin 复制代码

// 使用类泛型的情况：类型需要在整个类中保持一致
class ViewRef<T : DeclarativeBaseView<*, *>> {
    val view: T? // 需要在多个地方使用T
    fun doSomething(): T? { return view }
}

// 使用函数泛型的情况：类型只在函数中使用
fun <T : DeclarativeBaseView<*, *>> T.ref(ref: (viewRef: ViewRef<T>) -> Unit) {
    // T只在函数内使用
}

5.2 多层泛型嵌套

kotlin 复制代码

// 多层泛型嵌套
class PagerManager {
    fun <T : DeclarativeBaseView<*, *>> getView(pagerId: String, nativeRef: Int): T? {
        return PagerManager.getPager(pagerId)
            .getViewWithNativeRef(nativeRef) as? T
    }
}

// 使用时
val textView: TextView? = PagerManager.getView<TextView>("pager1", 123)
val buttonView: Button? = PagerManager.getView<Button>("pager1", 456)

6. 泛型位置的设计原则

6.1 最小作用域原则

kotlin 复制代码

// 好的设计：泛型作用域最小化
fun <T> process(item: T): String {
    return item.toString()
}

// 避免：不必要的类泛型
class Processor<T> {
    fun process(item: T): String {
        return item.toString()
    }
}

6.2 类型安全原则

kotlin 复制代码

// 好的设计：明确的类型约束
class ViewRef<T : DeclarativeBaseView<*, *>> {
    // 确保T是DeclarativeBaseView的子类
}

// 避免：无约束的泛型
class ViewRef<T> {
    // T可以是任何类型，可能导致运行时错误
}

6.3 可读性原则

kotlin 复制代码

// 好的设计：有意义的泛型参数名
class ViewRef<TView : DeclarativeBaseView<*, *>> {
    fun getView(): TView? { ... }
}

// 避免：无意义的泛型参数名
class ViewRef<T> {
    fun getView(): T? { ... }
}

7. 总结

Kotlin中泛型位置的选择遵循以下规律和原则：

作用域决定位置：
- 类泛型：需要在整个类中使用
- 函数泛型：只在函数中使用
- 接口泛型：影响整个接口
生命周期决定位置：
- 长生命周期：使用类泛型
- 短生命周期：使用函数泛型
类型安全决定约束：
- 明确约束：使用上界约束
- 多重约束：使用where子句
使用场景决定型变：
- 生产者：使用out
- 消费者：使用in
- 读写操作：不变

在ViewRef的设计中：

类泛型<T : DeclarativeBaseView<*, *>>确保类型安全
函数泛型<T : DeclarativeBaseView<*, *>> T.ref(...)提供扩展能力
泛型约束确保只能引用正确的视图类型
泛型位置的选择平衡了灵活性、安全性和可读性

这种设计使得ViewRef既类型安全又使用灵活，是Kotlin泛型系统在实际项目中的优秀应用。