Kotlin 语法二

Lambda 表达式

本质是一个匿名函数，然后赋值给一个变量。可以作为参数传递。

    val lambda: (Int, Int) -> Int = { a:Int, b:Int -> a + b }
    val lambda1: (Int, Int) -> Int = { a, b -> a + b }
    // 只有一个参数的时候，可以用it代替
    val lambda2: (Int) -> Int = {  it * 10 }

    println(lambda2(20))

    // 在高阶函数作为参数传递
    val list = listOf(1,2,3,4)
    // 完整写法
    list.forEach({ num -> println(num) })
    // 规则：lambda 如果是最后一个参数，可以把大括号拿到括号外面
    list.forEach(){ num -> println(num) }
    // 只有一个参数，用it简写（最常用写法）
    list.forEach{ println(it) }

其它常用的高阶函数

    val list = listOf(1,2,3,4,5)

    // filter 过滤：返回满足条件的新集合
    val res1 = list.filter { it > 2 }
    println(res1) // [3,4,5]

    // map 转换：把每个元素做变换，生成新集合
    val res2 = list.map { it * 10 }
    println(res2) // [10,20,30,40,50]

    // any：任意一个满足条件返回true
    val res3 = list.any { it > 3 }
    println(res3) // true

    // all：全部元素满足条件才返回true
    val res4 = list.all { it > 0 }
    println(res4) // true

面向对象

// 定义类，默认public
class Person{
    // 属性（成员变量）
    var name:String = ""
    var age:Int = 0

    // 成员方法
    fun sayHello(){
        println("你好，我是$name，今年$age 岁")
    }
}

fun main(){
    // 创建实例：Kotlin 不用 new！
    val p = Person()
    p.name = "张三"
    p.age = 18
    p.sayHello()
}

主构造，定义构造函数的时候默认生成属性。

// 主构造直接定义属性，一行搞定
class Person(var name:String, val age:Int){
    fun sayHello(){
        println("我是$name，${age}岁")
    }
}

fun main(){
    // 创建实例：Kotlin 不用 new！
    val p = Person("张三",18)
    p.sayHello()
    println(p.name)
    p.name = "张三丰"
    // 因为age是val类型，因此不能修改
    // p.age = 200
    println(p.name)
}

init可以有多个

class Person(var name:String, val age:Int){
    init {
        if(name.length > 5){
            println("name太长了")
        }else{
            println("name合适")
        }

    }
    init {
        if(age > 100){
            println("age太大了")
            // 不能写return
            // return
        }else{
            println("age合适")
        }
    }
}

fun main(){
    // 创建实例：Kotlin 不用 new！
    val p = Person("张三",18)
    val p1 = Person("张三是一个老6",18)
    val p2 = Person("张三",180)
    println(p)
    println(p1)
    println(p2)
}

次构造constructor

class Person(var name:String, var age:Int){
    // 次构造
    constructor(name:String):this(name,0){
        println("只传入名字的次构造")
    }
}

fun main(){
    val p = Person("李四") // age默认0
}

默认值

class Person(var name:String, var age:Int = 0){

}
fun main(){
    val p1 = Person("张三")     // age=0
    val p2 = Person("李四",20)  // age=20
}

自定义get和set方法。

// age给默认值，调用时可以不传age
class Person(var name:String){
    var age:Int = 0
        // getter，field代表后台字段。固定用field不能自定义
        get() = field
        set(value){
            if(value>0){
                field = value
            }else{
                println("年龄不能小于0")
            }
        }
}
fun main(){
    val p = Person("张三")
    p.age = 20 // 触发set，提示不能小于0
    println(p.age)
}

---

继承： 需要关键字open

open class Animal{
    fun eat(){
        println("动物吃东西")
    }
}

// 继承：子类 : 父类()
class Dog : Animal(){

}

fun main(){
    val dog = Dog()
    dog.eat()
}

继承时，子类要调用父类的构造方法。

open class Animal(var name:String){ } 
class Dog(name:String):Animal(name){ }

父类方法默认不能重写，父方法要加 open，子类用 override

open class Animal{
    open fun shout(){
        println("动物叫")
    }
}
class Dog : Animal(){
    override fun shout() {
        println("汪汪汪")
    }
}

object 直接创建单例对象，不用自己写单例模式

object UserManager{
    var name = "管理员"
    fun login(){
        println("登录")
    }
}

fun main(){
    UserManager.login() // 直接调用，不需要new实例
}

data class 自动生成 equals、toString、copy、component 解构方法，用来做实体类

data class User(val name:String, val age:Int)

fun main(){
    val u1 = User("张三",18)
    println(u1) // 自动toString，输出 User(name=张三, age=18)
    val u2 = u1.copy(age = 20) // 复制，修改部分属性
    println(u2)
}

companion object伴生对象。

class Config{
    companion object{
        val Version = 1.0
        val BaseURL = "http://api.xuejs.cn/api"
    }
}
fun main(){
    println(Config.Version)
}

接口

接口可以实现方式，对象可以实现多个接口。

interface Hello{
    var name: String
    var age: Int

    fun hello()

    fun hello1(){
        println("$name hello1")
    }
}
interface Eat{
    fun eat()
}

class Person(override var name: String, override var age: Int) : Hello, Eat{
    override fun hello() {
        println("name is $name age is $age")
    }

    override fun eat() {
        println("$name is eating")
    }
}

fun main(){
    var p = Person("张三丰", 20)
    p.hello()
    p.hello1()
    p.eat()
}

枚举

enum class API_List(val value: String){
    Category("/category"),
    Login("/login"),
    Regist("/regist")
}

fun main(){
    println(API_List.Category)
    println(API_List.Login)
}