Kotlin学习笔记(二)

一、面向对象进阶

数据类与单例类
数据类用data关键字修饰类，相当于JavaBean

data class Company(val name: String,val startTime:Int)

单例用object修饰类

object Singleton{
    ...
}

Lambda表达式与函数API
Lambda是一段可以作为参数的代码，代码最后一行自动作为返回值，形式:

{ 参数名1：参数类型，参数名2：参数类型 ->函数体 }

示例代码：

val list = mutableListOf("Apple","Banana","Pear","Grape")
val lambda = {fruit:String->fruit.length}
val maxLen = list.maxBy(lambda)

后两行代码可以表示为：

val maxLen=list.maxBy({fruit:String->fruit.length})

当Lambda是最后一个参数时，可以将表达式移到括号后面，即：

val maxLen=list.maxBy(){fruit:String->fruit.length}

Lambda是唯一参数时，可以去掉括号：

val maxLen=list.maxBy{fruit:String->fruit.length}

当Lambda表达式只有一个参数时，不用声明参数名，可以直接使用 it 代替，最终表示为：

val maxLen=list.maxBy{ it.length }

函数API之map
map可以将集合中的元素映射成另一个值，例如：

val list = mutableListOf("Apple","Banana","Pear","Grape")
val newList= list.map{ it.toUpperCase } //每个元素都改为大写

函数API之filter
filter用于过滤元素数据

val list = mutableListOf("Apple","Banana","Pear","Grape")
val newList= list.filter{ it.length < 5 }.map{ it.toUpperCase } //将元素长度小于5的元素改为大写

函数API之all与any
all表示所有元素满足条件，any表示至少一个元素满足条件

val list = mutableListOf("Apple","Banana","Pear","Grape")
val anyRes = list.any{ it.length < 5 } //判断list中是否存在长度小于5的元素
val allRes= list.all{ it.length < 5 } //判断list中是否所有元素长度都小于5

辅助工具 let
let是一个函数，形式：

obj.let { obj2 ->
	// 逻辑
}

其中obj与obj2是同一对象。

示例：

fun study(stu:Student?){
   stu?.doHomework();
}

用let表示：

fun study(stu:Student?){
	stu?.let{ s->
	   s.doHomework();
	}
}
//Lanbda只有一个参数，进一步简化
fun study(stu:Student?){
	stu?.let{
	   it.doHomework();
	}
}

二、标准函数与静态方法

标准函数with、run与apply
with用法

val res = with(obj){
	// obj上下文
	...//最后一行作为返回值
}

例子：

val res = with(StringBuilder()){
     append("aaa")
     append("bbb")
     toString() //返回值
}
println(res) // 结果：aaabbb

run用法

val res = obj.run{
	// obj上下文
	...//最后一行作为返回值
}

例子：

val res = StringBuilder().run{
     append("aaa")
     append("bbb")
     toString() //返回值
}
println(res) // 结果：aaabbb

apply用法

val res = obj.run{
	// obj上下文
	...//最后一行返回obj本身
}

例子：

val res = StringBuilder().apply{
     append("aaa")
     append("bbb") //返回值是 StringBuilder()对象
}

println(res.toString()) // 结果：aaabbb

静态方法
方式1：注解

class Util{
    companion object{
        @JvmStatic
        fun doAction(){
            println("doAction")
        }
    }
}

方式2：顶层方法（没有定义在任何类中的方法）

//创建Helper.kt文件，直接在里面写方法就是静态方法
fun action(){
    println("action")
}

三、延迟初始化与密封类

延迟初始化

private lateinit var adapter:MyAdapter
...
//判断是否初始化了
if(!::adapter.isInitialized){
	//...
}

使用密封类优化代码
一般情况

interface Result
class Success(val msg:String):Result
class Fail(val error:String):Result

fun getResult(res:Result) = when(res){
    is Success ->res.msg
    is Fail -> res.error
    else -> throw IllegalArgumentException() //必须添加
}

使用密封类

sealed class Result  // interface 改为 sealed class
class Success(val msg:String):Result() //继承类后面加()
class Fail(val error:Exception):Result()

fun getResult(res:Result) = when(res){
    is Success ->res.msg
    is Fail -> res.error.message
    //最后不用加else
}

1.密封类是一个可以继承的类
2.Kotlin会自动检查密封类有哪些子类，并强制要求对每个子类对应的条件处理
3.密封类及其子类只能定义在同一文件的顶层位置，不能嵌套在其他类中

四、扩展函数与运算符重载

扩展函数可以为现有类添加函数（添加API）
语法结构

fun ClassName.method(p1:Int,p2:Int):Int {
   return 0
}

示例：自定义统计字符串长度

fun String.lettersLen():Int{
    var count = 0
    for (char in this){
        if (char.isLetter()){
            count++
        }
    }
    return count
}

运算符重载
“+”运算符重载示例：

class Money(val value:Int){
    //money + money
    operator fun plus(money: Money):Money{
        val sum = value + money.value
        return Money(sum)
    }
    // money + v
    operator fun plus(v: Int):Money{
        val sum = value + v
        return Money(sum)
    }
}

调用

val money = Money(1)
val money2 = Money(2)
val money3 = money + money2
val money4 = money3 + 3
println(money4.value)

“*”运算符重载示例：

operator fun String.times(n:Int):String{
    val sb = StringBuilder()
    repeat(n){ //执行n次
        sb.append(this) //this是String对象
    }
    return sb.toString()
}

表达式与实际函数对比

表达式	函数API
a + b	a.plus(b)
a - b	a.minus(b)
a / b	a.div(b)
a % b	a.rem(b)
a++	a.inc()
a - -	a.dec()
+ a	a.unaryPlus
- a	a.unaryMinus()
! a	a.not()
a - -	a.dec()
a == b	a.equals(b)
a < b、a > b、a >= b、a <= b	a.compareTo(b)
a…b	a.rangeTo(b)
a[b]	a.get(b)
a[b] = c	a.set(b,c)
a in b	b.contain(a)

Kotlin学习笔记(一)