/**
 * 泛型类
 */

class Animal<T> {}

/**
 * 泛型接口
 * @param T
 */
interface IAnimal<T> {
    fun <T> initAnimal(p: T)
}

//泛型约束
//泛型约束表示我们可以指定泛型类型（T）的上界，
//即父类型，默认的上界为Any?，如果只有一个上界可以这样指定
fun <T : Animal<T>> init(p: T) {}

//如果需要指定多个上界类型，就需要使用where语句：
fun <T> initA(p: T) where T : Animal<T>, T : IAnimal<T> {}

//类型擦除
//Kotlin 为泛型声明执行的类型安全检测仅在编译期进行，
 运行时实例不保留关于泛型类型的任何信息。这一点在 Java 中也是类似的。
//
//例如，Array<String>、Array<Int>的实例都会被擦除为Array<*>，
//这样带来的好处是保存在内存中的类型信息也就减少了。
//
//由于运行时泛型信息被擦除，所以在运行时无法检测一个
//实例是否是带有某个类型参数的泛型类型，
//所以下面的代码是无法通过编译的
（Cannot check for instance of erased type: Array<Int>）：

//fun isArrays(a: Any) {
//  if (a is Array<Int>) {
//    println("is array")
//  }
//}
//但我们可以检测一个实例是否是数组，
//虽然 Kotlin 不允许使用没有指定类型参数的泛型类型，
//但可以使用星投影*（这个后边会说到）：

fun isArray(a: Any) {
    if (a is Array<*>) {
        println("is array")
    }
}
//同样原因，由于类型被擦除，我们也无法安全
//的将一个实现转换成带有某个类型参数的泛型类型：

fun sumArray(a: Array<*>) {
    val intArray = a as? Array<Int> ?: throw IllegalArgumentException("Array的泛型类型必须是Int类型")
    println(intArray.sum())
}
//因为我们无法判断数组a的是不是Array<Int>类型的，
//所以可能会出现异常的情况。
//
//对于泛型函数，如果在函数内需要使用具体的泛型类型，
//同样由于运行时泛型信息被擦除的原因，
//你无法直接使用它（Cannot check for instance of erased type: T）：

//fun < T> test(param: Any) {
//  if (param is T){
//    println("param type is match")
//  }
//}
//但还是有办法的，可以用inline关键字修饰函数，
//即内联函数，这样编译器会把每一次函数调用都换成函数实际代码实现，
//同时用reified关键字修饰泛型类型，这样就能保留泛型参数的具体类型了：
inline fun <reified T> test(param: Any) {
    if (param is T) {
        println("param type is match")
    }
}
//型变
//1、声明处型变
//型变是泛型中比较重要的概念，首先我们要知道 Kotlin 中
//的泛型是不型变的，这点和 Java 类似。那什么是型变呢，看个例子：

open class A
class B : A()


fun text() {
    val arrayB: Array<B> = arrayOf(B(), B())
    //val arrayA:Array<A> = arrayB
//    你会发现第二个赋值语句会有错误提示，
//Type mismatch. Required:Array<A> Found:Array<B>类型不匹配，
//    Array<B>并不是Array<A>的子类，
就是因为 Kotlin 中的泛型是默认不型变的，
无法自动完成类型转换，但B是A的子类，
//    这个赋值操作本质上是合理的、安全的，
//但编译器似乎并不知道，这必然给我们开发过程中带来了麻烦

//    为什么Array无法正常的赋值，而List、Set、
//Map可以呢？如下代码，编译器不会有错误提示的：
//
//    val list1: List<B> = listOf(B(), B(), B())
//    val list2: List<A> = list1
//    我们可以对比一下Array和List在源码中的定义：
//
//    public class Array<T> {}
//
//    public interface List<out E> : Collection<E> {}

//    可以看到List的泛型类型使用了out修饰符，这就是关键所在了。
//这就是 Kotlin 中的声明处型变，用来向编译器解释这种情况。
//
//    关于out修饰符我们可这样理解，当类、
//接口的泛型类型参数被声明为out时，
//则该类型参数是协变的，泛型类型的子类型是被保留的，
//    它只能出现在函数的输出位置，只能作为返回类型，
//即生产者。带来的好处是，A是B的父类，
那么List<A>可以是List<B>的父类。

    // 我们修改下上边List赋值的代码：

    val list1: List<A> = listOf(A(), A(), A())
//    val list2: List<B> = list1
//    即反过来赋值，由于B并不是A的父类，
//会有Type mismatch. Required:List<B> Found:List<A>错误提示。
//    为了应对这种情况，Kotlin 还提供了一个in修饰符。

//    关于in修饰符我们可这样理解，当类、接口的泛型类型参数被声明为in时，
//则该类型参数是逆变的，泛型类型的父类型是被保留的，
//    它只能出现在函数的输入位置，作为参数，只能作为消费类型，即消费者。
//    其实 Kotlin 中的Comparable接口使用了in修饰符：

//    写一个测试函数，编译器并不会报错：

    fun test(a: Comparable<A>) {
        val b: Comparable<B> = a
    }
   // 所以in修饰符和out修饰符的作用看起来的相对的，
//A是B的父类，那么Comparable<B>可以是Comparable<A>的父类，体会下区别。

//    那么在 Kotlin 中我们自然想到的是型变修饰符了：
//
//    Kotlin 中的out A类似于 Java 中的? extends A，
//即泛型参数类型必须是A或者A的子类，用来确定类型的上限
//    Kotlin 中的in A类似于 Java 中的? super A，
//即泛型参数类型必须是B或者B的父类，用来确定类型的下限
}