学习kotlin系列之七（嵌套类和泛型）

1、嵌套类

说明：即类的内部再创建类 但是不适用inner关键字；
嵌套类是属于静态类，和外部类没有任何关系

fun main(args: Array<String>) {
    //访问内部的方法
    var name = OutClass.InnerClass().sayHello()
}

class OutClass {
    var name = "张三"

    class InnerClass {
        fun sayHello() {
//            println("你好$name")
            println("你好${OutClass().name}")
        }
    }
}

2、内部类

说明：即类的内部再创建类使用inner关键字

fun main(args: Array<String>) {
    //访问内部的方法
    var inClass = OutClass().InnerClass()
    inClass.sayHello()
}

class OutClass {
    var name = "张三"

    inner class InnerClass {
        fun sayHello() {
//            println("你好$name")
            println("你好${OutClass().name}")
        }
    }
}

3、内部类使用this

说明：内部类访问属性使用关键是this

class OutClass {
    var name = "张三"

    inner class InnerClass {
        var name = "李四"
        fun sayHello() {
//            println("你好$name")
//            println("你好${OutClass().name}")
            println("你好${this.name}")
        }
    }
}

4、泛型

1）泛型

泛型:在强类型程序设计语言中编写代码时定义一些可变部分
描述：
1）定义对象的时候使用泛型；
2）定义子类时候执行泛型；
3）定义子类的时候不知道具体类型，继续使用泛型。

fun main(args: Array<String>) {
    val box = Box<String>("大头梨")
    println(box.thing)
}

//定义一个箱子,箱子内不知道放啥
open class Box<T>(var thing: T) {
}

//定一个只放水果的箱子
class FruitBox(thing: Fruit) : Box<Fruit>(thing)
//不是道具体放什么
class SonBox<T>(thing:T):Box<T>(thing)

//抽象类水果
abstract class Fruit

//苹果
class Apple : Fruit()

//橘子
class Orange : Fruit()

2）泛型函数

说明：使用泛型可以判断基本数据类型和 类的类型

fun main(args: Array<String>) {
    parseType(10)
}

fun <T> parseType(thing: T) {
    when (thing) {
        is Int -> {
            println("是Int类型")
        }
        is String -> {
            println("是String类型")
        }
        is Boolean -> {
            println("是Boolean类型")
        }
        else -> {
            println("不是道具体类型")
        }
    }
}

3）泛型擦除

泛型擦除：在kotlin中泛型背擦除
说明：获取泛型使用方法
1）泛型前加reified关键字；
2）方法前加上inline关键字

fun main(args: Array<String>) {
    val box1 = Box<String>("")
    val box2 = Box<Int>(10)
    //获取其class类型
//    println(box1.javaClass.name)
//    println(box2.javaClass.name)
//    println(box1::class.java.name)
//    println(box2::class.java.name)
//    com.hunter.kotlin.day03.Box
    parseType(10)
}
inline  fun <reified T> parseType(thing:T){
    //获取传递的thing的class类型
    println(T::class.java.name)
}

4）泛型类型投射

泛型类型投射:即抽象类作为参数，则继承抽象类的子类无法放入有该参数的方法中
描述：out关键字 类似于java中的 ? extents

fun main(args: Array<String>) {
    val list = ArrayList<Fruit>()
    val apple = ArrayList<Apple>()
//    println(setFruitList(list))
    println(setFruitList(apple))//会报错则要是用关键字out
    val intList = ArrayList<Int>()
    setFruitList1(intList)

}


fun setFruitList(list: ArrayList<out Fruit>) {
    //使用关键字out


}

fun setFruitList1(list: ArrayList<*>) {
    //使用关键字* 即型号投射}
    //定义一个箱子,箱子内不知道放啥
    open class Box<T>(var thing: T) {
    }

    abstract class Thing
    //抽象类水果
    abstract class Fruit : Thing()

    //苹果
    class Apple : Fruit()

    //橘子
    class Orange : Fruit()}

5、智能类型推断

说明：类似于java的强转

fun main(args: Array<String>) {
//    val shepDog = ShepHerdDog()
//    val ruralDog = RuralDog()
//    shepDog.herdShep()
//    ruralDog.LookDoor()

    val shepDog: Dog = ShepHerdDog()
    val ruralDog: Dog = RuralDog()
//    shepDog.herdShep()
//    ruralDog.LookDoor()
    //增加判断
    //判断完之后 已经将shepDog类型由Dog转换成ShepHerdDog
    if (shepDog is ShepHerdDog) {
        //
        shepDog.herdShep()
    }
    if (ruralDog is RuralDog) {
        ruralDog.LookDoor()
    }


}

//定义狗 狗有很多品种
abstract class Dog

//牧羊犬
class ShepHerdDog : Dog() {
    fun herdShep() {
        println("牧羊犬放羊")
    }
}

//中华田园犬
class RuralDog : Dog() {
    fun LookDoor() {
        println("中华田园犬看家")
    }
}