1、泛型类
/**
* 1、泛型的定义
* （1）类名后面接 <T> 定义泛型，其中 T 可以任意指定
* （2）主构函数里面的 T 为泛型使用，代表其参数为 T 类型
*/
open class Box<T>(var thing: T)
/**
* 2、泛型类的继承
* （1）已知具体类型则使用具体类型
* （2）未知具体类型则继续以泛型类定义
*/
abstract class Fruit
class Apple : Fruit()
class FruitBox(thing: Fruit) : Box<Fruit>(thing)
class SonBox<T>(thing: T) : Box<T>(thing)
fun main() {
val box = Box<String>("空箱子")
val apple = Apple()
val fruitBox = FruitBox(apple)
val sonBox = SonBox<Fruit>(apple)
}
2、泛型函数
/**
* 1、泛型函数
* （1）fun 关键字后面、函数名前面的 <T> 为泛型的定义
* （2）参数类型 T 为泛型的使用
*/
fun <T> parseType(thing: T) {
when(thing){
is Int -> println("Int类型")
is String -> println("String类型")
else -> println("未知类型")
}
}
fun main() {
parseType(10) //Int 类型
parseType("Kotlin") //String 类型
parseType(1L) //未知类型
}
3、泛型上限
/**
* 泛型上限：<T : Fruit> 泛型只能是 Fruit 或者 Fruit 的子类
*/
open class Fruit
class Apple : Fruit()
open class Thing
class Orange : Thing()
class FruitBox<T : Fruit>(var fruit: T)
fun main() {
val fruit = Fruit()
val fruitBox0 = FruitBox(fruit)
val apple = Apple()
val fruitBox1 = FruitBox(apple)
val orange = Orange()
//val fruitBox2 = FruitBox(orange) //编译失败，orange 不是 Fruit 的子类
}
4、泛型擦除
/**
* 1、泛型擦除
* （1）和 java 一样，kotlin 也是通过类型擦除来支持泛型的
* （2）kotlin 的泛型在运行时被擦除了，获取不到泛型的具体类型
* （3）泛型类型只存在于编译阶段
*
* 2、解决泛型擦除（声明成内联函数）
* （1）在泛型的定义前加上 reified
* （2）在函数最前面加上 inline
*/
class Box<T>(var thing: T)
inline fun <reified T> parseType(thing: T){
println(T::class.java)
}
fun main() {
val box1 = Box<Int>(10)
val box2 = Box<String>("Kotlin")
//泛型被擦除了，所以这里获取到的都是 Box 类型，而没有泛型的具体类型
println(box1.javaClass) //class com.wf.kotlin.study.Box
println(box2.javaClass) //class com.wf.kotlin.study.Box
//内联函数使得类型不会被擦除
parseType(10) //class java.lang.Integer
parseType("") //class java.lang.String
}
5、泛型投射
open class Thing
open class Fruit : Thing()
class Apple : Fruit()
/**
* 泛型投射
* （1）<out Fruit>：接受当前类或它的子类，相当于 java 的 <? extends Fruit>
* （2）<in Fruit>：接收当前类或它的父类，相当于 java 的 <? super Fruit>
*/
fun printFruitList1(list: ArrayList<out Fruit>) {
println(list.size)
}
fun printFruitList2(list: ArrayList<in Fruit>) {
println(list.size)
}
fun main() {
val things = ArrayList<Thing>()
val fruits = ArrayList<Fruit>()
val apples = ArrayList<Apple>()
//printFruitList1(things) //编译失败，只接收 Fruit 及其子类
printFruitList1(fruits)
printFruitList1(apples)
printFruitList2(things)
printFruitList2(fruits)
//printFruitList2(apples) //编译失败，只接收 Fruit 及其父类
}
6、星号投射
/**
* 星号投射
* <*>：代表可以传任何类型，相当于 java 的 <?>
*/
fun boxingThings(list: ArrayList<*>){
println(list.size)
}
fun main() {
val strings = ArrayList<String>()
boxingThings(strings)
val ints = ArrayList<Int>()
boxingThings(ints)
}
