Kotlin编程权威指南学习知识点预览

一、变量、常量和类型：

变量、常量以及 Kotlin 基本数据类型。变量和常量在应用程序中可用来储值和传递数据。类型则用来描述常量或变量中保存的是什么样的数据。

1、声明变量:

// 变量定义关键字 —— 变量名 —— 类型定义 —— 赋值运算符 —— 赋值
    var name : Int = 5

2 、Kotlin的内置数据类型：

3、只读变量：

Kotlin 提供了一种语法来声明只读变量，也就是说，变量一旦赋值就不能更改。

要声明可修改变量，使用 var 关键字。要声明只读变量，使用 val 关键字。

4、类型推断：

Kotlin 有个语言特性叫类型推断，对于已声明并赋值的变量，它允许你省略类型定义。

var age = 5
val fristName = "Everbrilliant89"

5、编译时常量：

编译时常量只能在函数（指包括 main 在内的所有函数）之外定义。这是因为，编译时常量必须在编译时（程序编译时）赋值，而 main 和其他函数都是在运行时（程序运行时）才调用，函数内的变量也是在那时赋值。编译时常量要在这些变量赋值前就已存在。

const val MAX_VALUE = 5000

二、条件语句：

1、if/else语句：

2、range :

在 in 1..5 中，..是一种操作符，表示某个范围（range）。范围包括从..操作符左侧的值到..操作符右侧值的一系列值。所以，1..5 包括 1、2、3、4、5。除了数字，范围也可以是一系列字符。

3、when表达式：

when 表达式是 Kotlin 的另一个控制流工具。类似于 if/else 语句，when 表达式允许你编写条件式，在某个条件满足时，就执行对应的代码。它的语法比较简洁，非常适合有三到四个分支的情况。

 fun demoFunc() {
        val faction = when(race) {
            "dwarf" -> "Keepers of the Mines"
            "gnome" -> "Keepers of the Mines"
            "orc" -> "Free People of the Rolling Hills"
            "human" -> "Free People of the Rolling Hills"
            else -> "noName"
        }
    }

三、函数：

函数是能完成某项特定任务的可复用代码块，是编程非常重要的一部分。

1、函数结构的剖析：

一个函数的两个主要部分：函数头和函数体。

2、函数头：

修饰符：private、public、protected
函数声明关键字：fun
函数名：
函数参数：函数参数总是只读的，你不能在函数体内再给它们赋值。
函数返回类型

3、函数的作用域：

4、默认值参数：

参数列表中可以给参数赋值默认的值。

 private fun castFirebal(numFireballs: Int = 2) {
      println("A glass of Fireball springs into existence. (x$numFireballs)")
    }

5、单表达式函数：

函数都只有一个表达式语句，或者说都只有一条求值语句。Kotlin 提供了更简单的方式来定义这类函数，对于这类单表达式函数，返回类型、花括号、返回语句都可以省掉。

private fun castFirebal(numFireballs: Int = 2) 
    = println("A glass of Fireball springs into existence. (x$numFireballs)")

6、具名函数参数：

        castFirebal(5)
        //具名函数
        castFirebal(numFireballs = 6)

7、Unit函数：

Kotlin 使用 Unit 返回类型表明这样一件事：函数没有返回值。函数定义中如果没使用 return 关键字，那暗含的意思就是，Unit 就是这个函数的返回类型。

8、Nothing类型：

Kotlin 还有一种叫作 Nothing 的类型。类似于 Unit，Nothing 类型的函数也不返回任何东西。但这是它们唯一相同的地方。在编译器看来，Nothing 就意味着函数不可能成功执行完成，它要么抛出异常，要么因某个原因再也返不回调用处。

9、Java中的文件级函数：

Java 中，函数和变量都只能定义在类里，但 Kotlin 没有这样的要求。

10、函数重载：

如果一个函数有多种实现，就可以说它被重载了。默认值参并不是重载的唯一方式。你可以用相同的函数名定义多个实现。

11、反引号中的函数名：

定义或调用以空格和其他特殊字符命名的函数，不过，函数名要用一对反引号括起来。首先是支持 Java 互操作。Kotlin 提供了很多便利的工具，支持在 Kotlin 文件中调用现有 Java 代码的方法（Kotlin 和 Java 的互操作详见第 20 章）。Kotlin 和 Java 各自有不同的保留关键字，不能用作函数名。使用反引号括住函数名就能避免任何潜在冲突。

在 Kotlin 中，is 是个保留关键字（你会在第 14 章中看到，Kotlin 的标准库有个 is 操作符，可以用来检查实例类型）。而在 Java 中，is 不是关键字，所以是有效的方法名。有了反引号，就可以在 Kotlin 中调用 Java 的 is 方法了。

四、匿名函数与函数类型：

定义时不取名字的函数，我们称之为匿名函数。匿名函数和具名函数既相似又不同。明显的不同之处有两个：匿名函数的定义中没有名字；和其他代码交互的方式有点特别。匿名函数通常整体传递给其他函数，或者从其他函数返回。这种交互主要靠函数类型和函数参数实现。

1、匿名函数：

把一个匿名函数作为参数传递给 count 函数：

    val numLetters = "guangdongshenzhen".count({
        letters -> letters == 's'
    })
    //匿名函数作为参数传入函数count
    val numLetters1 = "guangdongshenzhen".count { letters ->
        letters == 's'
    }

    //count函数在源码中的定义
    public inline fun CharSequence.count(predicate: (Char) -> Boolean): Int {
        var count = 0
        for (element in this) if (predicate(element)) ++count
        return count
    }

函数类型：匿名函数也有类型，我们称其为函数类型（function type）。匿名函数可以当作变量值赋给函数类型变量。然后，就像其他量一样，匿名函数就可以在代码里传递了

    //匿名函数赋值给变量
    //: () -> String 表示变量存储的是哪种类型的函数
    // () -> String 是你给 greetingFunction 变量指定的函数类型定义
    val greetingFunction :() -> String = {
        val currentYear = 2018
        "Welcome to SimVillage, Mayor! (copyright $currentYear)"
    }

隐式返回：和具名函数不一样，除了极少数的情况外，匿名函数不需要 return 关键字来返回数据。没有 return 关键字，为了返回数据，匿名函数会隐式或自动返回函数体最后一行语句的结果。
函数参数：需要带参数时，参数的类型放在匿名函数的类型定义中，参数名则放在函数定义中。

    val greetingFunction :(String) -> String = { youName ->
        "你好,我的名字叫： $youName)"
    }

it关键字：定义只有一个参数的匿名函数时，可以使用 it 关键字来表示参数名。当你有一个只有一个参数的匿名函数时，it和命名参数都有效。

    val greetingFunction :(String) -> String = { 
        "你好我的名字叫： $it)"
    }

多个参数：it 关键字语法只适用于一个参数的情况。匿名函数支持多个参数。如果有多个参数，需要使用命名参数。

     val greetingFunction :(String,Int) -> String = {myName,age ->
        "你好我的名字叫： $myName" + ",今年：$age 岁了"
    }

2.类型推断：

定义一个变量时，如果已把匿名函数作为变量值赋给它，就不需要显式指明变量类型了。类型推断也支持带参数的匿名函数，但为了帮助编译器更准确地推断变量类型，匿名函数的参数名和参数类型必须有。

    val greetingFunction = {
        myName:String,age:Int ->
        "你好我的名字叫： $myName" + ",今年：$age 岁了"
    }

3、定义参数是函数的函数：

函数支持包括函数在内的任何类型的参数。一个函数类型的参数定义起来和其他类型的参数一样：在函数名后的一对圆括号内列出，再加上类型。

    val greetingFunction = {
        myName:String,age:Int ->
        "你好我的名字叫： $myName" + ",今年：$age 岁了"
    }

    fun runSimulation(name :String ,greegreetingFunction :(String,Int) -> String) {
        var age = 18
        println(greetingFunction(name, age))
    }

4、函数内联：

Kotlin 有一种优化机制叫内联，可以解决 lambda 引起的内存开销问题。有了内联，JVM 就不需要使用 lambda 对象实例了，因而避免了变量内存分配。为了使用内联方法优化 lambda，以 inline 关键字标记使用 lambda 的函数即可。

    inline fun runSimulation(name :String 
            ,greegreetingFunction :(String,Int) -> String) {
        var age = 18
        println(greetingFunction(name, age))
    }

5、函数引用：

函数引用可以把一个具名函数（使用 fun 关键字定义的函数）转换成一个值参。要获得函数引用，使用::操作符，后跟要引用的函数名。

    protected fun demoFunc() {
        runSimulation("WY",::costPrinter)
    }
    private fun runSimulation(name: String, costPrinter: KFunction1<Int, Unit>) {
    }
    fun costPrinter(num :Int) {
        val cost = 400
        println("construction cost: ${cost * num}")
    }

6、函数类型作为返回类型：

和其他数据类型一样，函数类型也是有效的返回类型，也就是说，你可以定义一个能返回函数的函数。

五、null安全与异常：

null 是个特殊值，用来表明 var 或 val 变量的值不存在。包括 Java 在内的许多编程语言中， null 常常会导致应用崩溃，因为让不存在的东西做事情是不可能的。如果一个 var 或 val 变量能接受 null 值，Kotlin 需要你做个特别声明。这有助于避免 null 相关的应用崩溃。

1、可空性：

对于 null 值问题，Kotlin 反其道而行之。除非另有规定，变量不可为 null 值。

2、Kotlin的null类型：

    protected fun demoFunc() {
        var beverage = readLine()
        beverage = null // 如返回值不是String?而是String则赋值为null则报错
    }
    //String?表示可空String的类型
    private fun readLine(): String? {
        return "nihao"
    }

3、null安全：

Kotlin 区分可空类型和非可空类型，所以，你要一个可空类型变量做事，而它又可能不存在，对于这种潜在危险，编译器时刻警惕着。为了应对这种风险，Kotlin 不允许你在可空类型值上调用函数，除非你主动接手安全管理。

安全调用操作符（?.）：不确定会不会返回null，此时可选择使用安全调用操作符；

    var beverage = readLine()?.capitalize()

使用带let的安全调用：主要作用是在指定的作用域内定义一个或多个变量。

      var beverage = readLine()?.let { 
            if (it.isNotBlank()) {
                it.capitalize()
            } else {
                "isBlank"
            }
        }

使用!!.操作符：!!.操作符也能用来在可空类型上调用函数。但我要给你个警告：相比安全调用操作符，!!.操作符太激进，一般应该避免使用。视觉上看，代码中的!!.操作符也给人语气很重的感觉，因为它真的很危险。如果你用了!!.，就是在向编译器宣布：“万一我使唤干活的东不存在，我要求你立刻抛出空指针异常！！”（顺便提一下，!!.的官方名字是非空断言操作符但开发人员更喜欢叫它“感叹号操作符”。）

    var beverage = readLine()!!.length

使用if判断null值情况；
使用空合并操作符号：另一种检查 null 值的方式是使用 Kotlin 的空合并操作符?:

        var beverage = readLine()
        val beverageServed:String = beverage ?: "Buttered Ale"

4、异常：

抛出异常：Kotlin 允许你主动示意有异常发生。这种行为又叫抛出一个异常，由throw 操作符触发。
自定义异常：
异常处理：try/catch 语句，Kotlin 可以让你决定如何来处理异常。

5、先决条件函数：

六、字符串：

1、字符串截取：

substring：
split：

2、字符串操作：

replace函数：

3、字符串比较：

引用相等比较很少用于比较字符串。一般来说，相比关心两个字符串是不是同一实例，我们

更关心它们是不是相等字符，以及顺序是否一致（或者说两个不同的类实例是否结构相同）。

就比较字符串来说，== 操作符的行为方式和 Kotlin 不一样，Java 用== 做引用比较。要在 Java 中做结构相等比较，要用 equals 函数。

4、遍历字符：

forEach函数

七、数：

1、数字类型：

2、整数（Int）：

3、小数数字（Float或Double）：

4、字符串转数值类型：

toFloat：
toDouble：
toDoubleOrNull：安全转换函数
toIntOrNull：
toLong：
toBigDecimal ：

5、Double类型格式化:

    "%.2f".format("2.6666666")

6、位运算：

八、标准库函数：

1、apply标准函数：

apply 函数可看作一个配置函数：你可以传入一个接收者，然后调用一系列函数来配置它以便使用。如果提供 lambda 给 apply 函数执行，它会返回配置好的接收者。

    val menuFile = File("1.txt")
        menuFile.setReadable(true)
        menuFile.setWritable(true)
        menuFile.setExecutable(true)
        
        val menuFile2 = File("2.txt").apply { 
            setReadable(true)
            setWritable(true)
            setExecutable(true)
        }

2、let函数：

let 函数能使某个变量作用于其 lambda 表达式里，让 it 关键字能引用它。

3、run函数：

run 和 apply 差不多。但与 apply 不同，run 函数不返回接收者。

        val menuFile3 = File("3.txt")
        menuFile3.run { 
            readText().contains("ss")
        }

4、with函数：

with函数是run的变体。它们的功能行为是一样的，但 with 的调用方式不同。调用 with 时需要值参作为其第一个参数传入。

        val nameTooLong = with("Polarcubis, Supreme Master of NyetHack") { 
             length >= 20 
            }

5、also函数:

also 函数和 let 函数功能相似。和 let 一样，also 也是把接收者作为值参传给 lambda。但有一点不同；also 返回接收者对象，而 let 返回 lambda 结果。

6、takeIf函数：

takeIf 函数需要判断 lambda 中提供的条件表达式（叫 predicate），给出 true 或 false 结果。如果判断结果是 true，从 takeIf 函数返回接收者对象；如果是 false，则返回 null。

        val menuFile4 = File("4.txt")
            .takeIf { 
                it.canRead() && it.canWrite() 
            } ?.readText()

九、List与set：

1、List:

获取列表元素：用元素的索引（index）和[]操作符可以获取列表中的任意元素。列表中的元素基于零索引（zero-indexed存放。

    private fun printList() {
        val patronList = listOf<String>("wangwu","lisan")
        var name =patronList[0];
        val contains = patronList.contains("zhangsan")
    }

更改列表内容：列表可变性是由列表的类型决定的，指的是列表元素是否可修改。支持内容修改的列表叫可变列表（mutable list）。要创建可变列表，可以使用 mutableListOf 函数。

    private fun printMutableList() {
        val mutableList = mutableListOf("wangwu","lisan")
        mutableList.add("张三")
        mutableList.remove("lisan")
    }

2、遍历：

在 for 循环里，in 指定将要被遍历的对象。也可以forEach和forEachIndexed,，或Iterable去遍历。

      private fun forList() {
        val mutableList = mutableListOf("wangwu","lisan")
        for (forList in mutableList) {

        }

        mutableList.forEach { name ->
            print("名字是 $name")
        }

        mutableList.forEachIndexed { index, name ->
            print("序列号为：$index ===名字是 $name")
        }
    }

3、解构：

通过使用_符号过滤不想要的元素，你还可以有选择地从 List 集合里解构元素。

4、set：

Set 集合里的所有元素都具有唯一性；Set 集合不支持基于索引的存取值函数，因为它里面的元素顺序不固定。

创建Set集合：

    private fun showSet() {
        val nameSet = setOf<String>("wangwu","lisan")
        nameSet.contains("zhangsan")
        //索引值读取 Set 集合的元素虽然可行，但因为 elementAt 函数内部实现机制的问题，
        //相比按索引读取 List 集合的元素，读取速度要慢上一个数量级
        nameSet.elementAt(2)   
        
    }

向Set集合中添加元素：

5、while循环：

当某个条件满足时，就执行循环体里的代码。

6、break表达式：

7、数组类型：

    val playerAges:IntArray = intArrayOf(25,23,5,9,48)

十、Map:

与 List 和 Set 类型不同的是，Map 里的元素是由你定义的键值对组成的，获取元素的方式是基于键，而不是基于索引。在 Map 里，键具有唯一性，它对应一个具体的值。值则可以重复，没有唯一性要求。从这个角度看，Map 和 Set 有了另一个共同点：就像 Set 里的元素一样，Map里的键都是唯一的。

1、创建map

Map 集合里，键必须是同一类型，值也必须是同一类型，而键和值可以是不同类型。

to 函数将它左边和右边的值转化成一个对（Pair）——一种表示两个元素一组（键和值）的特殊类型。

    private fun showMap() {
        val patronGold = mapOf(
            Pair("wangwu",15),
            Pair("lisi",18),
            Pair("wangmuzi",16)
        )
        val patronGold1 = mapOf("wangwu" to 15,"lisi" to 18)
    }

2、读取Map集合的值：

    private fun printMap() {
        val patronGold = mapOf("wangwu" to 15,"lisi" to 18)
        val gold = patronGold["wangwu"]
        val lisiGold = patronGold.getValue("lisi")
    }

3、向Map集合添加项：

     private fun putMutableMap() {
        val mutableMap = mutableMapOf("wangwu" to 15,"lisi" to 18)
        mutableMap.put("wangyi",88)
    }

4、修改Map集合值:

    private fun modifyMutableMap() {
        val mutableMap = mutableMapOf("wangwu" to 15,"lisi" to 18)
        mutableMap["wangwu"] = 66
    }

十一、定义类：

在面向对象编程的世界里，类是核心，是一类独特“事物”的代码形式的定义。具体来讲，类定义的是事物包含哪一类数据，能做什么样的工作。

1、定义类：

类可以定义在一个独立的文件中，也可以和函数或变量定义在一起。类定义在单独一个文件里，可以给应用程序未来的规模升级预留扩展空间。

2、构造实例：

构造函数的工作就是构造，说得再具体一点，就是构造一个实例以备后用。调用构造函数和调用一般函数在语法上很像：使用一对圆括号接收值参。

3、类函数：

定义类行为就是在类结构体里添加函数定义。定义在类里的函数叫类函数。

4、可见性与封装：

5、类属性：

类数据定义，又叫作类属性，用来描述类的特有状态和特征。

属性getter与setter；
属性可见性；
计算属性。

十二、初始化：

调用一个类的构造函数，创建了该类的一个实例。这个过程叫实例化。给对象分配内存就是实例化对象，给对象赋值就是初始化对象。

1、构造函数：

var name: String = ""
var heealthPoints: Int = 0
var isBlessed: Boolean = false
var isImmortal: Boolean = false
class Player (_name: String,
                 _healthPoints: Int,
                 _isBlessed: Boolean,
                 _isImmortal: Boolean){
        var name = _name
            get() = field.capitalize()
            private set(value) {
                field = value.trim()
            }
        var healthPoints = _healthPoints
        val isBlessed = _isBlessed
        private val isImmortal = _isImmortal
}

//调用
val player = Player("Madrigal", 89, true, false)

2、次构造函数：

有主就有次，对应主构造函数的是次构造函数。如果你为某个类指定了主构造函数，那么该类的所有实例都要用它构造。如果你指定了一个次构造函数，那只是多了一种构造类实例的方式（主构造函数的要求仍要满足）。

class Player (_name: String){
        var name = _name
        var age :Int = 0
    //这里 this 关键字指的是构造函数所在的类实例。
    constructor(_name :String ,_age :Int) :this(_name) {
        name = _name
        age = _age
    }
}

3、默认参数:

class Player (_name: String,_age :Int =18){
        var name = _name
        var age :Int = 0
        lateinit var adrr :String
    //age为默认参数可实现
    constructor(_name :String ,_age :Int, _adrr :String) :this(_name,_age) {
        name = _name
        age = _age
        adrr = _adrr
    }
    //age为默认参数也不可实现
    constructor(_name :String , _adrr :String) :this(_name) {
        name = _name
        adrr = _adrr
    }
}

4、初始化块：

初始化块代码会在构造类实例时执行，类似于Java中的static初始化块。用关键字init定义一个初始化块。

5、初始化顺序：

主构造函数里声明的属性；
类级别的属性赋值；
init 初始化块里的属性赋值和函数调用；
次构造函数里的属性赋值和函数调用；

6、延迟初始化：

延迟初始化：对于任何 var 属性声明，你都可以加上 lateinit 关键字。这样， Kotlin 编译器会允许你延后初始化属性。
惰性初始化：可以暂时不初始化某个变量，直到首次使用它。使用代理要用到 by 关键字。Kotlin 标准库里有一些预先配置好的代理可用，lazy 就是其中一个。惰性初始化会用到 lambda 表达式，你可以在表达式里定义属性初始化需要执行的代码。

十三、继承：

1、创建子类

子类继承哪个类，就会共享哪个类的全部属性。让子类继承的类通常叫作父类或超类。

事实上，类默认都是封闭的，也就是说不允许其他类来继承自己。要让某个类开放继承，必须使用 open 关键字修饰它。

/该类可被继承必须加上open
open class Player (_name: String,_age :Int =18){
        var name = _name
        var age :Int = 0
        lateinit var adrr :String
    //age为默认参数可实现
    constructor(_name :String ,_age :Int, _adrr :String) :this(_name,_age) {
        name = _name
        age = _age
        adrr = _adrr
    }
    //age为默认参数也不可实现
    constructor(_name :String , _adrr :String) :this(_name) {
        name = _name
        adrr = _adrr
    }

    //可重新函数必须加上open
    open fun showName() {

    }
    //要想某个函数不被子类覆盖，就使用 final 关键字修饰它
    final fun showPassdWord() {

    }

}


class MyPlayer(_name: String, _age: Int) : Player(_name) {


    override fun showName() {

    }
}

2、类型检查：

Kotlin 的 is 运算符是个不错的工具，可以用来检查某个对象的类型。

3、Kotlin类层次：

每一个类都会继承一个共同的叫作 Any 的超类。

package kotlin

public open class Any {
    
    public open operator fun equals(other: Any?): Boolean

    public open fun hashCode(): Int

    public open fun toString(): String
}

十四、对象：

1、object:

如果只想用一个实例来管理整个应用运行时间内的一致性状态的话，可以考虑定义一个单例

（ singleton ）。使用 object 关键字，你可以定义一个只能产生一个实例的类——单例。单例类一

旦实例化，在整个应用的运行周期内，只会存在一个实例。即使你再次实例化它，你得到的还是

最初产生的实例。

使用 object 关键字有三种方式：对象声明（object declaration）、对象表达式（object expression和伴生对象（companion object）。

对象声明：

object open class MyPlayer(_name: String, _age: Int) : Player(_name) {
    
    init {
        
    }
    override fun showName() {


    }
}

对象表达式：这个匿名类依然遵循 object 关键字的一个规则，即一旦实例化，该匿名类只能有唯一一个实例存在。

  val signalPlayer = object : MyPlayer("",5) {
            override fun showName() {
                super.showName()
            }
        }

伴生对象：将某个对象的初始化和一个类实例捆绑在一起，可以考虑使用伴生对象。使用 companion 修饰符，你可以在一个类定义里声明一个伴生对象。一个类里只能有一个伴生对象。第一种，包含伴生对象的类初始化时，伴生对象就会被初始

化。由于这种相伴关系，伴生对象就适合用来存放和类定义有上下文关系的单例数据。第二种，只要直接访问伴生对象的某个属性或函数，就会触发伴生对象的初始化。

open class MyPlayer(_name: String, _age: Int) : Player(_name) {

    //类似于Java中的static方法
     companion object {
         private const val MAPS_FILEPATH = "nyethack.maps"
         fun load() = File(MAPS_FILEPATH).readBytes()
     }
}
//直接调用
 MyPlayer.load()

2、嵌套类：

可以使用 class 关键字定义一个嵌套在另一个类里的命名类。

3、数据类：

数据类必须有至少带一个参数的主构造函数；

数据类主构造函数的参数必须是 val 或 var ；

数据类不能使用 abstract、open、sealed 和 inner 修饰符。

4、枚举类：

enum class Direction { 
 NORTH, 
 EAST, 
 SOUTH, 
 WEST 
}

5、运算符重载：

data class Coordinate(val x: Int, val y: Int) { 
 val isInBounds = x >= 0 && y >= 0 
 operator fun plus(other: Coordinate) = Coordinate(x + other.x, y + other.y) 
}

十五、接口与抽象类：

接口可以用来定义一组未实现的公共属性和行为。具体如何实现，开发者不用管，实现接口的类会负责处理。类之间想要共享属性或函数，但又无法建立继承关系时，就非常适合使用这种只定义而不实现的接口特性。也就是说，通过使用接口，无须继承或被继承，一组类就可以拥有共同的属性和函数。

1、定义接口：

interface Fightable { 
 var healthPoints: Int 
 val diceCount: Int 
 val diceSides: Int 
 val damageRoll: Int 
 fun attack(opponent: Fightable): Int 
}

2、实现接口：

open class MyPlayer(_name: String, _age: Int,
                    override var healthPoints: Int,
                    override val diceCount: Int,
                    override val diceSides: Int,
                    override val damageRoll: Int
)  : Fightable{
    override fun attack(opponent: Fightable): Int {
        TODO("Not yet implemented")
    }


}

3、默认实现：

不是每个属性和函数都需要在接口实现类里提供不同的具体实现。所以，接口里提供默认实

现可以减少重复代码。

4、抽象类：

在类定义之前加上 abstract 关键字。除了具体的函数实现，抽象类也可以包含抽象函数——只有定义，没有函数实现。

abstract class MyPlayer(_name: String, _age: Int,
                    override var healthPoints: Int,
                    override val diceCount: Int,
                    override val diceSides: Int,
                    override val damageRoll: Int
)  : Fightable{
   
    
}

不管超类是哪种类型的类（一般类、抽象类或接口），子类默认都会共享其超类的所有属性和函数。如果一个类实现了一个接口，那么它的子类也必须满足这个接口的所有实现需求。

首先，接口里不能定义构造函数。其次，一个类只能继承一个抽象类，但可以实现多个接口。

open class MyPlayer(
    _name: String, _age: Int,
    override var healthPoints: Int,
    override val diceCount: Int,
    override val diceSides: Int,
    override val damageRoll: Int
) : Player(_name), Fightable {
     override fun attack(opponent: Fightable): Int {
         TODO("Not yet implemented")
     }
     
 }

十六、泛型：

泛型系统允许函数和其他类型接受你或编译器当前无法预知的类型，大大提高了代码的复用率。

1、泛型类：

class LootBox<T>(item: T) { 
 private var loot: T = item 
}

2、泛型函数：

class LootBox<T>(item: T) { 
 var open = false 
 private var loot: T = item 

//定义的名为 fetch 的泛型函数会返回 T，这是 LootBox 类指定的泛型参数，
//也是代表 item类型的占位符。
 fun fetch(): T? { 
 return loot.takeIf { open } 
 } 
}

3、多泛型参数：

class LootBox<T>(item: T) { 
 var open = false 
 private var loot: T = item 
 fun fetch(): T? { 
 return loot.takeIf { open } 
 } 
//R这个泛型参数将用作 fetch 函数的返回类型
//定义时，这个 R 泛型参数要放在尖括号里，置于函数名之前：fun <R> fetch。
//fetch 返回的是一个 R?，即一个可空的 R 类型。
//由于函数类型声明(T) -> R，lootModFunction 函数能接受 T 类型的值参，返回一
//个 R 类型的结果值
 fun <R> fetch(lootModFunction: (T) -> R): R? { 
 return lootModFunction(loot).takeIf { open } 
 } 
}

4、vararg关键字与get函数：

这个 vararg 关键字，初始化泛型类时，就能把它的 item 变量看作元素数组，而非单个元素了。

5、in与out:

泛型参数可以扮演两种角色：生产者（producer）或消费者（consumer）。生产者角色就意味着泛型参数可读而不可写；消费者角色则相反，可写而不可读。

out 关键字表明，泛型参数将扮演可读而不可写的生产者角色。

6、reified关键字：

reified关键字能帮你检查泛型参数类型。Kotlin 提供了 reified 关键字，它允许你在运行时保留类型信息。

十七、扩展：

扩展可以在不直接修改类定义的情况下增加类功能。扩展可以用于自定义类。

1、定义扩展函数：

定义扩展函数和定义一般函数差不多，但有一点大不一样：除了函数定义，你还需要指定接

受功能扩展的接收者类型（ receiver type ）。

//this 的内容加上传入值参决定
//的一个或多个感叹号（默认值是 1）。this 关键字指接收者实例
fun String.addEnthusiasm(amount: Int = 1) = this + "!".repeat(amount)

2、超类上定义在扩展函数：

//在 Any 类上定义一个叫 easyPrint 的扩展函数。因为是定义在 Any 超类上的
//，所以 easyPrint支持在任何类上调用。
fun Any.easyPrint() = println(this)

3、泛型扩展函数：

//let 函数被定义成了泛型扩展函数，所以能支持任何类型。它接受一个 lambda 表达式，这个
//lambda 表达式以接收者 T 作为值参，返回的是 R——lambda 表达式返回的任何新类型。
public inline fun <T, R> T.let(block: (T) -> R): R { 
 return block(this) 
}

4、扩展属性：

5、可空类扩展：

6、定义扩展文件：

7、重命名扩展：

十八、函数式编程基础：

函数式编程范式主要依赖于高阶函数（以函数为参数或返回函数）返回的数据。这些高阶函数专用于处理各种集合，可方便地联合多个同类函数构建链式操作以创建复杂的计算行为。

1、函数类别：

变换：变换函数会遍历集合内容，用一个以值参形式传入的变换器函数变换每一个元素，然后返回包含已修改元素的集合给链上的其他函数。

        val animal = listOf("zebra", "giaffe", "elephant", "rat")
        val babies = animal
            .map { animal -> "A baby $animal" }
            .map { baby -> "$baby, with the cutest little tail ever!" }
        println(babies)

过滤：过滤函数接受一个 predicate 函数，用它按给定条件检查接收者集合里的元素并给出 true 或 false 的判定。如果 predicate 函数返回 true，受检元素就会添加到过滤函数返回的新集合里。如果 predicate 函数返回 false，那么受检元素就被移出新集合。

        val itemsOfManyColors = listOf(listOf("red apple", "green apple", "blue apple"),
            listOf("red fish", "blue fish"), listOf("yellow banana", "teal banana"))

        val redItem = itemsOfManyColors.flatMap {
            it.filter {
                it.contains("rea")
            }
        }
        println(redItem)

合并：合并函数能将不同的集合合并成一个新集合：

        val employees = listOf("Denny", "Claudette", "Peter")
        val shirtSize = listOf("large", "x-large", "medium")
        val employeeShirtSizes = employees.zip(shirtSize).toMap()
        println(employeeShirtSizes["Denny"])
        
        val foldedValue = listOf(1, 2, 3, 4).fold(0) { accumulator, number ->
            println("Accumulated value: $accumulator")
            accumulator + (number * 3)
        }
        println("Final value: $foldedValue")

2、序列：

Kotlin 有个内置惰性集合类型叫序列（Sequence）。序列不会索引排序它的内容，也不记录元素数目。事实上，在使用一个序列时，序列里的值可能有无限多，因为某个数据源能产生无限多个元素。

针对某个序列，你可能会定义一个只要序列有新值产生就被调用一下的函数，这样的函数叫迭代器函数（iterator function）。要定义一个序列和它的迭代器，你可以使用 Kotlin 的序列构造函数 generateSequence。generateSequence 函数接受一个初始种子值作为序列的起步值。在用 generateSequence 定义的序列上调用一个函数时，generateSequence 函数会调用你指定的迭代器函数，决定下一个要产生的值。

        fun Int.isPrime(): Boolean {
            (2 until this).map {
                if (this % it == 0) {
                    return false // Not a prime! 
                }
            }
            return true
        }

        val oneThousandPrimes = generateSequence(3) { value ->
            value + 1
        }.filter { it.isPrime() }
            .take(1000)