23.泛型

object Generic {
    def main(args: Array[String]): Unit = {
        // Scala中泛型默认也是不可变，就算有父子关系也不行
        val test : Test[User] = new Test[User]()
        //val test : Test[User] = new Test[Child]()
        println(test)

        // Scala中也支持泛型可变
        // +T => 泛型的协变，协助功能扩展
        val test1 : Test1[User] = new Test1[Child]()
        // -T => 泛型的逆变，往回变
        val test2 : Test2[User] = new Test2[Parent]()

        def low[T<:User](t:T)={

            println(t)
        }
        // 使用下限时，不能传入父类
        //low(new Parent)
        low(new Child)
        low(new User)
        // 使用上限时，在函数中不会起作用，
        def high[T>:User](t:T)={
            println(t)
        }
        //high(new Child())
        high(new Parent)
        high(new Child)
        high(new User)

        // 逆变
        //println(new Test3[Parent])
        println(new Test3[User])
        println(new Test3[Child])

        // 协变
        println(new Test4[Parent])
        println(new Test4[User])
       // println(new Test4[Child])

    }
}


class Parent{

}

class User extends Parent{

}

class Child extends User{

}


class Test[T]{

}

class Test1[+T]{

}

class Test2[-T]{

}

// 上限
class Test3[T<:User]{
}

// 下限
class Test4[T>:User]{

}

// 泛型上限，T必须是comparable的字类，所以会有comapreTO
// 比较的可以为字符，但是是数字就不行
def max[T <= comparable[T]](a : T, b: T):Unit={
    a.compareTo(b)
}