Kotlin（二）类和对象

一、类用class关键字声明

class Person { /*……*/ }

二、构造函数

     一个类，至少有一个主构造函数 + 1个或多个次构造函数。constructor可省略（没注解的情况）

class Person constructor(firstName: String) { /*……*/ }

三、 次构造函数

也用constructor，必须直接或间接委托给主构造函数

class Person(val name: String) {
    constructor(name: String, parent: Person) : this(name) {
    }
}

四、创建类的实例

val invoice = Invoice()

val customer = Customer("Joe Smith")

 五、继承

class A ：B(){} 。默认是封闭的需要加open关键字

open class Shape {}
class Circle() : Shape() {
    override fun draw() { /*……*/ }
}

六、伴生对象

不需要实例调用，但要访问函数

七、类成员初始化顺序

1. 伴生对象 init 块

2. 基类 init 块

3. 基类构造函数

4. 子类 init 块

5. 子类构造函数

八、接口

interface MyInterface {
    fun bar()
    fun foo() {
      // 可选的方法体
    }
}

属性也能声明，必须是抽象的。覆盖冲突问题，用 super尖括号处理。

8.1、泛型

8.2、集合

九、函数式接口（SAM接口）

只有一个抽象方法的接口：

val isEven = IntPredicate { it % 2 == 0 }

十、拓展函数

对一个类或接口扩展新功能而无需继承

十一、密封类sealed

编译时就知道一个密封接口有哪些可能的子类型。更好控制继承关系

十二、委托

是实现继承的一个很好的替代方式

十三、解构

把属性从对象中解构出来，用componentN修饰，val (a, b) = student

十四、内联函数

调用的方法在编译时，直接替换为方法的执行代码：inline fun test()

十五、运算符重载

已知的运算符集提供自定义实现，如一元运算符，二元运算符

十六、中缀函数

infix修饰，省略了点和括号，但是函数只能有一个参数，不能有默认值

十七、具名函数

传参时指定具体函数名，传入时可以不按参数列表的顺序

匿名函数：没有函数名，函数体在一对花括号中，后边必须写圆括号调用，匿名函数不需要return，默认返回函数最后一行的结果

println({
        val currentYear = 2022
        "Welcome to SimVillage, Mayor!(copyright $currentYear)"
    }())

Unit函数：无返回值的函数（void）

单表达式函数：函数体内只有一行函数，可以省略函数体的大括号

十八、函数重载

通过设置默认值参数，或定义多个不同参数列表的同名函数实现函数重载

fun performCobat(){
     println("fight!")
 }
 fun performCobat(bane:String){
     println("$bane fight1!")
 }
 fun performCobat(bane:String, isBlessed:Boolean){
     println("$bane is  $isBlessed")
 }

十九、高阶函数

即参数有函数类型，或返回值是函数类型

runSim(::printCost)

inline fun runSim(printCost: (Int)-> String){
    val numB = (1..3).shuffled().last()
    println(printCost(numB))
}

fun printCost(numB: Int): String {
    val cost = 500
    return (cost * numB).toString()
}

二十、作用域函数

在一个对象上执行一个代码块。不同的是在块中如何使用，以及表达式的结果是什么

a、let 对一个非空对象执行lambda表达式，简化了重复的对象名，省略了非空检查。

对象引用是it，返回值是表达式的结果

 val sam =  Dog(5)
    sam.name = "sam"
    //1.let
    sam.let {
        it.bark()
        it.eat()
    }

b、also，对象引用是it，返回值也是对象。适合作附加效果

val seven = Dog(10)
    seven.name = "seven"
    seven.also {
        it.age++
    }

c、apply，对象引用是this，返回值是对象。适合用作对象配置

val white = Dog(20)
    white.name = "white"
    white.apply {
        this.age = 21
        this.name = "white boy"
    }

d、run，对象引用是this，返回值是lambda表达式结果。适合同时初始化对象并计算返回值时候

 val black = Dog(30)
    println(black.run {
        black.age = 31
        black.name = "black dog"
        black
    })

e、 with，对象引用this，返回值是lambda表达式结果。适合一个对象的一组函数调用

val brown = Dog(40)
    with(brown) {
        brown.eat()
        brown.bark()
    }