kotlin语法总结（一）

下一章地址

kotlin语法总结（二）

---

前言

接下来几章将总结一下kotlin的语法，总结kotlin和java不一样的地方

---

（1）var可修改、val只读（类型推断）、const val a = 1（编译时常量）

（2）kotlin只提供引用数据类型，会在字节码中变成基本书记类型

（3）when(a)、in 4…6->

    val art = 10
    when (art) {
        //等于3为少儿
        in 0..3 -> println("shaoer")
        in 3..12 -> println("11")
        else -> {
            print("$art lo")
        }
    }

（4）String模板：“Answer $b”，可带变量

（5）private fun fix(age:Int):String{}

（6）具名参数 fun fix(age:Int = 2,name:String){}

（7）没有返回值，Unit函数

（8）TODO函数：抛出异常

（9）匿名函数（lambda表达式）、it关键字、类型推断

val ble:()->String = {
        val ho = "aa"
        "happy $ho"
    }

val ble = {
        val ho = "aa"
        "happy $ho"
    }
val ble = {name:String,year:Int->

}

（10）内联函数：消除lambda表达式带来的额外开销

（11）高级函数：能接收函数或者返回函数的函数

（12）闭包：匿名函数能修改和引用定义在自己作用域之外的变量

（13）java中不支持函数作为参数传递，替代方案：匿名内部类

（14）安全调用操作符？：为空跳过函数调用

（15）let函数安全调用 it.isNotBlank()判空

var str1 = readLine()?.let {
        if (it.isNotBlank())
            it.capitalize()
        else
            "aaa"
    }
    //上面代码可简写成
    str1 = str1?.let { it.capitalize() }?:"aaa"

（16）非空断言操作符!!：为null抛异常

（17）空合并操作符?:：左边值为空则使用右边的值，和let一起使用替代if/else

（18）异常：先决条件函数：checkNotNull require requireNotNull error assert

（19）subString：字符串截取函数

（20）List集合支持结构语法，可在一个表达式中给多个变量赋值

（21）===：比较地址、==比较值

（22）"aa s f ef g ".forEach{}

（23）安全转换函数：toIntOrNull 转换错误返回null

（24）“%.2f”.format(5.4566)、8.145.toInt()、roundToInt() 四舍五入

（25) apply函数 配置函数 返回当前接受者、let函数返回最后一行

（26）run函数返回lambda函数结果（true/false）

（27）::把一个方法当做参数传入

（28）with需要值参当做第一个参数传入

val isTooLong = with("aaaaaaaaaaa"){
        length>=0
    }

（31）集合List Set Map（只读和可变）MutableList/Set/Map listOf() +=/-= toList() IntArray数组 getOrNull getOrElse getOrPut

（32）kotlin中每一个属性，会自动产生field、getter、setter方法，可以去重写它们

（33）初始化顺序：主构造函数->初始化块->次构造函数

class Player01 (
    _name:String,
    //既是参数又是属性
    var age :Int = 20,
    var isNormal:Boolean
//    _age:Int,
//    _isNormal:Boolean

){
    var name = _name
    get() = field.capitalize()
    private set(value){
        field = value.trim()
    }
//    var age = _age
//    var nor = _isNormal

    //次构造函数
    constructor(name: String):this(name,100,false){
        this.name = name.toLowerCase()
    }

    //初始化块，在构造实例时执行
    init {
        require(age>0){"age < 0"}
        require(name.isNotBlank()){"Null"}
    }

}

fun main() {
    var player01 = Player01("a",10,true)
    var player02 = Player01("add")
    var player03 = Player01("s",isNormal = false)
    println(player02.name)
}

（34）延迟初始化两种方式：lateinit var a

class Player03(_name:String) {
    var name = _name
//    val config = loadConfig()
    val config by lazy { loadConfig() }

    private fun loadConfig() :String{
        println("load--")
        return "xxx"
    }
}

（35）初始化陷阱：执行顺序很重要

（36）开放继承 open（类和函数都要加）

open class produck(val name: String){
    fun de() = "Pr:$name"
    open fun lo() = "no"
}

//继承
class Lux:produck("aa"){
    override fun lo(): String {
        return "nn"
    }
}

（37）Any：所有类的父类

（38）智能类型转换

（39）object 单例

//object：对象声明
object AppConfig{
    init {
        println("........")
    }
    fun setSomething(){
        println("set")
    }
}
fun main() {
    //只声明一次
    AppConfig.setSomething()
    AppConfig.setSomething()
}

open class Player06{
    open fun load() = "......."
}

fun main() {
    //object:对象表达式，只用一次
    val p = object :Player06(){
        override fun load(): String {
            return "load"
        }
    }
    println(p.load())
}

open class ConfigMap{
    //伴生对象，只会初始化一次,只会有一个，用时加载
    companion object{
        private const val PATH = "xxx"

        fun load() = File(PATH).readLines()
    }
}

fun main() {
    //方法通过类名调用
    ConfigMap.load()
}