泛型

泛型的定义

泛型是可以在类或方法中预支地使用未知的类型。泛型的定义有多种，第一种是在定义的时候在类上面加上泛型声明，进行使用的时候再确定泛型：

fun main(args: Array<String>) {
    var box = Box<Apple>(Apple())
}

class Box<T>(var thing: T)

class Apple

第二种是定义专门的类继承泛型类，确定泛型类型：

fun main(args: Array<String>) {
    AppleBox(Apple())
}

open class Box<T>(var thing: T)

open class AppleBox(thing: Apple) : Box<Apple>(thing)//专门定义AppleBox

class Apple

第三种是父类定义有泛型，子类不知道具体类型，还可以再传递一个泛型给它：

class FruitBox<FRUIT>(thing:FRUIT):Box<FRUIT>(thing)

泛型函数

不仅类可以有类型参数，函数也可以有。类型参数要放在函数名称之前。要调用泛型函数，在调用处函数名之后指定类型参数即可：

fun main(args: Array<String>) {
    fanxing("qwe")
}

fun <T> fanxing(thing: T) {
    when (thing) {
        is Int -> println("整形")
        is String -> println("字符串")
        is Char -> println("字符型")
    }
}    

泛型上限

泛型上线是最常见的约束类型，与 Java 的 extends 关键字相对应：

fun <T:Comparable<T>>sort(list:List<T>) {}

冒号之后指定的类型是上界：只有 Comparable<T> 的子类型可以替代 T 。

泛型擦除

在泛型中无法获取到泛型类型，这叫做泛型擦除。

fun main(args: Array<String>) {
    val box1 = Box<Int>(10)
    val box2 = Box<String>("张三")
    val clz1 = box1.javaClass.name
    val clz2 = box2.javaClass.name
    println(clz1)
    println(clz2)
}
open class Box<T>(var thing: T)

在上面代码中，box1和box2的泛型类型不一样，但是打印的结果是相同的。想要解决这个问题，需要在泛型前面加上reified，在泛型函数前加上inline：

inline fun <reified T>parse(thing:T):String{
    return T::class.java.name
}

泛型类型投射

有下面一段代码：

fun main(args: Array<String>) {
    val list = arrayListOf(Thing())
}

//实物
open class Thing
//水果
open class Fruit: Thing()
//梨
class Pear: Fruit()

如果我们需要Arraylist里面只能传递Fruit或者子类，可以改为：

fun main(args: Array<String>) {
    val list = arrayListOf(Thing())
    parse(list)
}

fun parse(list:ArrayList<out Fruit>){

}

如果我们需要Arraylist里面只能传递Fruit或者父类，可以改为：

fun main(args: Array<String>) {
    val list = arrayListOf(Thing())
    parse(list)
}

fun parse(list:ArrayList<in Fruit>){

}

其中：out 相当于java的 ? extends；in 相当于java的 ? super。

星号投射

如果我们希望ArrayList可以传递任何东西，这时可以使用星号投射，也就是星投影：

fun main(args: Array<String>) {

}
fun parse(list:ArrayList<*>){

}

代码中的" * "相当于java的 " * "

中缀表达式

标有 infix 关键字的函数也可以使用中缀表达式（忽略该调用的点与圆括号）调用。中缀函数必须满足以下要求：

1.必须是成员函数和扩展函数

2.必须只有一个参数

3.不能是可变参数

fun main(args: Array<String>) {
    var p1 = person("张三",20)
    p1 sayhelloto "李四"
}

class person(var name: String, var age: Int) {
    infix fun sayhelloto(person: String) {
        println("$name 给$person 打招呼")
    }
}

注意：中缀表达式调用this不能省略:

    fun hehe() {}
    fun haha() {
        this.hehe()
        //中缀调用
        this.sayhelloto("王五")
    }
}

类委托
有以下案例：
围裙妈妈只做饭不洗碗，小头爸爸洗碗一次十元，大头儿子洗碗一次三元。围裙妈妈让小头爸爸洗碗，小头爸爸委托给大头儿子洗。小头爸爸和大头儿子都有洗碗的功能，但是小头爸爸把洗碗的能力委托给了大头儿子实现，这就是类委托。类委托有两种形式，第一种是指定委托，即只委托给大头儿子实现：

fun main(args: Array<String>) {
    var big = BigHeadSon()
    var small = SmallHeadFather()
    big.wash()
    small.wash()
}

//实现洗碗的功能
interface WashPower {
    fun wash()
}

//大头儿子实现洗碗的功能
class BigHeadSon : WashPower {
    override fun wash() {
        println("大头儿子开始洗碗")
    }
}

//小头爸爸委托大头儿子洗碗
class SmallHeadFather : WashPower by BigHeadSon()

第二种委托：只要有洗碗功能都可以实现：

fun main(args: Array<String>) {
    var big = BigHeadSon()
    var small = SmallHeadFather(big)
    big.wash()
    small.wash()
}

//实现洗碗的功能
interface WashPower {
    fun wash()
}

//大头儿子实现洗碗的功能
class BigHeadSon : WashPower {
    override fun wash() {
        println("大头儿子开始洗碗")
    }
}

//小头爸爸委托大头儿子洗碗->第一种委托
//class SmallHeadFather : WashPower by BigHeadSon()

class SmallHeadFather(washPower: WashPower):WashPower by washPower

属性委托

属性委托就是把属性的get和set方法委托给其他对象。

过年时，爷爷奶奶给了大头儿子压岁钱，围裙妈妈替大头儿子保管。就属于属性委托：

fun main(args: Array<String>) {
    var bigheadson = BigHeadSon()
    bigheadson.money = 100
    println(bigheadson.money)
}

class WeiQunMom {
    //存储儿子的压岁钱
    var son = 0//儿子的压岁钱
    var mom = 0//自己的存钱罐
    //委托压岁钱的get方法
    operator fun getValue(bigHeadSon: BigHeadSon, property: KProperty<*>): Int {
        return son
    }

    //委托压岁钱的set方法
    operator fun setValue(bigHeadSon: BigHeadSon, property: KProperty<*>, i: Int) {
        son += 20
        mom += i - 20
    }
}

class BigHeadSon {
    var money: Int by WeiQunMom()
}

加载

惰性加载

需要使用的时候才加载，属于懒加载。用by lazy关键字。惰性加载需要注意以下几点：

1.by lazy用在字段，必须val修饰

2.by lazy返回值在最后一行

3.by lazy只会加载一次

4.对象里面也可以使用by lazy

5.惰性加载只要调用就会都会加载，所以在需要的时候再进行加载

fun main(args: Array<String>) {
    println(name)
    println(name)
}

val name by lazy {
    println("执行了加载1")
    "加载1"
}

class D {
    val name by lazy {
        println("执行了加载2")
        "加载2"
    }
}

输出结果是

执行了加载1

加载1

加载1

可见：

by lazy只会初始化一次

by lazy最后一行为返回值

by lazy是线程安全的

延迟加载

延迟加载所用到的关键字是lateinit，不确定具体值，var可变，且独立于类单独存在：

fun main(args: Array<String>) {
    val person = Person()
    person.name = "张三"
    person.sayHello()
}

lateinit var name: String

class Person {
    //现在不知道name对应的数据  后面初始化的时候才能确定
    //延迟初始化
    lateinit var name: String

    fun sayHello() {
        println(name)
    }
}

这段代码中的name在person类中没有赋值，在main方法中才予以赋值。若name没有赋值，没有赋值直接访问会报错:UninitializedPropertyAccessException。

扩展函数

扩展函数是在不改变已有类的情况下，为类添加新的函数。主要是为了替代java中的util类。父类定义的扩展函数，子类也可以使用。

fun main(args: Array<String>) {
    //可空类型
    val str: String? = null
    //判断str是否为空
    var res = str?.IsEmpty() ?: true
}
//给String类型扩展了一个IsEmpty函数
fun String.IsEmpty(): Boolean {
    return this == null || this.length == 0
}

对于扩展函数来说，如果通过父类接收，那么执行的是父类的扩展函数：

fun main(args: Array<String>) {
    val view = View()
    val button:Button = Button()
    button.onclick()
}
fun View.onclick(){
    println("点击了view")
}

fun Button.onclick(){
    println("点击了button")
}
open class View

class Button:View()

object单例

单例的原理：通过静态代码块创建Person对象实例，用的时候可以使用这个实例。object单例每一个字段都是静态的，比较消耗内存。object单例适用于成员变量比较少的情况：

fun main(args: Array<String>) {
    Person.sayHello()
    Person.sayHello()
}

object Person{
    var name = "张三"
    var age = "20"
    var phone = "123"
    fun sayHello(){
        println("hello")
    }
}

伴生对象

可以将定义成static静态的属性放在伴生对象里，外部类可以直接调用伴生对象里面的方法和属性。伴生对象的字段都是静态的：

class Person{
    var name = "张三"
    companion object {
        var phone = "123444"
    }
}

枚举

枚举类的最基本的用法是实现类型安全的枚举，枚举里面保存的就是有限的实例对象：

fun todo(week: Week) {
    when (week) {
        Week.星期一 -> println("工作")
        Week.星期二 -> println("工作")
        Week.星期三 -> println("工作")
        Week.星期四 -> println("工作")
        Week.星期五 -> println("工作")
        Week.星期六 -> println("休息")
        Week.星期日 -> println("休息")
    }
}

enum class Week {
    星期一, 星期二, 星期四, 星期五, 星期六, 星期日, 星期三
}

枚举的高级用法

以RGB颜色为例：

RED r:255 g:0 b:0

GREEN r:0 g:255 b:0

BLUE r:0 g:0 b:255

fun main(args: Array<String>) {
    println(Color.RED.r)
}

enum class Color(var r:Int,var g:Int,var b:Int){
    RED(255,0,0),GREEN(0,255,0),BLUE(0,0,255)
}

数据类

我们经常创建一些只保存数据的类。 在这些类中，一些标准函数往往是从数据机械推导而来的。在 Kotlin 中，这叫做数据类并标记为data。数据类只保存数据，没有其他任何逻辑操作，对应java的bean类。数据类相当于提供了bean类的模板，可以替代java的bean：

fun main(args: Array<String>) {
    val news = News("d:/path/a.jpg","标题","简介")
    news.component1()//对应imgPath
    news.component2()//对应title
    news.component3()
}

data class News(var imgPath:String,var title:String,var desc:String)

密封类

密封类可以理解为增强型的枚举。枚举在意数据，而密封类更在意类型。所以，密封类密封的是类型：

fun main(args: Array<String>) {
    println(isLegel(JonSnow()))
}

fun isLegel(stark: NedStark): Boolean {
    when (stark) {
        is NedStark.AryaStark -> return true
        is NedStark.RobStark -> return true
        is NedStark.SansaStark -> return true
        is NedStark.BrandonStark -> return true
        else -> return false
    }
}

sealed class NedStark {
    class RobStark : NedStark()
    class SansaStark : NedStark()
    class AryaStark : NedStark()
    class BrandonStark : NedStark()
}

class JonSnow : NedStark()
class KonSnow : NedStark()