泛型

package fanxing
/*
泛型 即参数化类型，将类型参数化，可以用在类，接口，方法上
与java一样 不同处：为保证类型安全提供保证，消除类型强转的烦恼
*/

class Box<T>(t:T){
var value=t
}

//-------创建类的实力的时候需要之指定参数类型
/fun main(args: Array<String>) {
val box=Box<Int>(1)
//或者
val box2:Box<Int> = Box<Int>(1)
println(box.value)
}/

/*
定义泛型类型变量，可以完整地写明类型参数，
如果编译器可以自动退订类型参数，也可以省略类型参数
Kotlin 泛型函数的声明与java相同，类型参数要凡在函数名前
*/

fun <T> boxIn(value:T)=Box(value)
//以下编译器会进行类型推断，均是合理的
val box4=boxIn<Int>(1)
val box5=boxIn(1)

fun <T> doPrintln(content:T){
when (content){
is Int->println("整型数字为$content")
is String ->println("字符串转换为大写：${content.toUpperCase()}")
else -> println("T 不是整型，也不是字符串")
}
}
/fun main(args: Array<String>) {
val age=23
val name="runoob"
val bool=true
doPrintln(age)
doPrintln(name)
doPrintln(bool)
}/

//---------泛型约束---------
/*
可以使用反省约束来设定一个给定参数允许使用的类型
Kotlin中使用：d对反省的类型上限进行约束 最常见的是upper bound
/
//Comparable 的子类型可以代替T
fun <T:Comparable<T>> sort(list:List<T>){}
/fun main(args: Array<String>) {
sort(listOf(1,2,3))
//sort(listOf(HashMap<Int,String>())) 错误HashMap<Int,String> 不是Comparable<HashMap<Int,String>>的子类型
}
/
//----------型变------------
/
Kotlin中没有通配符类型，它有两个其他的东西：声明处型便于类型投影
声明处型变

声明处的类型变异使用斜边注解符：in 、 out ，消费者in,生产者out
使用out 使得一个类型参数协变，协变类型参数只能用作输出，可以
作为返回值类型但是无法作为入参的类型

*/

//定义一个支持协变的类
class Runoob<out A>(val a:A){
fun foo():A{
return a
}
}

/*fun main(args: Array<String>) {

var strCo:Runoob<String> = Runoob("a")
var anyCo:Runoob<Any> = Runoob("b")
anyCo=strCo
println(anyCo.foo())//输出a

}*/

/*
in 是的一个类型参数你变，你变类型参数只能用作输入，
可以作为入参的类型但是无法作为返回值的类型
*/
//定义一个支持逆变 的类
class Runoob2<in A>(a:A){
fun foo(a:A){
println(a)
}
}

fun main(args: Array<String>) {
var strDco=Runoob2("a")
var anyDco=Runoob2("b")
strDco=anyDco
}