Android Kotlin 高阶详解

@NotNull
Set<@NotNull String> toSet(@NotNull Collection<@NotNull String> elements) {
    ...
}

在kotlin中如下：

fun toSet(elements: (Mutable)Collection<String>) : (Mutable)Set { ... }

fun toSet(elements: (Mutable)Collection<String!>) : (Mutable)Set { ... }

(Mutable)Collection! 代表 “元素类型为 T 的Java 集合, 
内容可能可变, 也可能不可变,
值可能允许为 null, 也可能不允许为null”,
Array<(out) T>! 代表 “元素类型为 T (或 T 的子类型)的 Java 数组,
值可能允许为 null, 也可能不允许为 null”

if (a is List<Int>) // 错误: 无法判断它是不是 Int 构成的 List
// 但是
if (a is List<*>) // OK: 这里的判断不保证 List 内容的数据类型

1.1.6 获得java类

要在kotlin中，获取java类，有两种写法：

 val clazz = javaTest::class.java
 val clazz1 = javaTest.javaClass

1.2 在java中调用kotlin代码

kotlin.jvm.JvmClassMappingKt.getKotlinClass(MainView.class)

MyClassKt.test();

@file:JvmName("Test")
package com.yuanzhen.kotlinstudy
 
fun test1(){
    println("测试JvmName")
}

Test.test1();

interface Animal{
    fun bark()
}
 
class Dog : Animal{
    override fun bark() {
        println("Wang")
    }
 
 
class Duck : Animal{
    override fun bark() {
        println("Ga ga")
    }
}
 
class Zoo(animal : Animal) : Animal by animal
 
fun main(){
    Zoo(Dog()).bark()
    Zoo(Duck()).bark()
}

sealed class Fruit{
    abstract var name:String
}
 
class Apple:Fruit(){
    override var name: String = "Apple not good"
}
 
class Pear:Fruit(){
    override var name: String = "Pear good"
}
 
fun echoFruitName(fruit:Fruit){
    when(fruit){
        is Apple -> println(fruit.name)
        is Pear -> println(fruit.name)
    }
}
 
fun main() {
    echoFruitName(Pear())
    echoFruitName(Apple())
 
}

5，init代码块

init代码块会在类每次实例化时都执行一次，执行顺序为 主构造>init代码块>次级构造，因此可以在init代码块中执行一部分主构造中无法执行的逻辑代码。

class People(var name:String){
 
    constructor(name:String, age:Int):this(name){
        println("in constructor")
    }
 
    init {
        name = name + "00"
        println("in init block name = $name")
    }
}
 
fun main(){
    People("zhangsan", 123)
}

结果：
in init block name = zhangsan00
in constructor 

6，lateinit 修饰符

Kotlin中类的属性必须初始化，否则编译器会报错。为了让大家更适应类似Java中的写法，Kotlin提供了一个关键字lateinit，可以告诉编译器稍后我会初始化这个字段。但是需要注意：如果这个属性没有初始化就使用的话，会报空指针异常

7，扩展函数，扩展属性

Kotlin中可以给一个类扩展它的成员方法或成员变量，常用于扩展系统内置库、三方SDK等不受控的类

无论是Kotlin中的类，还是Java中的类，kotlin都可以对他们的成员方法进行扩展

fun 被扩展方法的类名.扩展方法名(参数列表)：返回值 = 实现{ 函数体 }

class TestKtClass{
 
}
 
fun TestKtClass.echoMsg(str:String) = println(str)
 
fun TestKtClass.getStrValue(str1:String, str2:String):Int{
    return (str1+str2).length
}
 
fun main(){
    TestKtClass().echoMsg("12345")
    println(TestKtClass().getStrValue("12345", "000"))
}

注意点：

1.扩展函数时静态的给一个类添加成员方法，不具备运行时多态效应

2.扩展函数和类内部定义的成员函数重名时，执行的是类的成员函数

扩展属性和扩展函数类似，

var 类名.属性名称:类型
    get(){
        
    }
    set(value){
        
    }

var StringBuilder.firstLetter:Char
    get(){
        return get(0)
    }
    set(value){
        this.setCharAt(0, value)
    }
 
fun main(){
    println(StringBuilder("123456").firstLetter)
}

8，静态对象

使用关键字object定义的对象是静态对象，此对象类似于静态对象仅能被实例化一次，相当于单例并且线程安全

object类不能有构造函数 

object TestObj{
    fun echoName(){
 
    }
}
 
fun main(){
    TestObj.echoName()
}

在kotlin中调用object对象的方法，使用类名.方法名调用

在Java中调用object对象的方法，使用类名.INSTANCE.方法名调用

TestObj.INSTANCE.echoName();

9，伴生对象

伴生对象使用companion object关键字定义，并且仅能在一个类的内部使用，因此才叫伴生对象，伴生对象中的方法和属性都是相当于静态（并不是真正的静态，而是包含在一个静态实例中）的。

class TestCompanionObj{
    companion object{
        fun echoMsg(){
            println("111111111111111111")
        }
    }
}

与object类似，在kotlin中使用类名.方法名调用， 在Java中使用类名.Companion.方法名调用

//kotlin
TestCompanionObj.echoMsg()
 
 
//java
TestCompanionObj.Companion.echoMsg();

10，幕后字段

幕后字段用关键字field表示，仅能用在get和set方法中使用。在Kotlin中，field这个字段代表这个属性本身，与class中的this相似。

需要注意的是：在get和set方法中，一定不要使用属性本身。因为一旦使用属性本身会被再次展开为get和set方法，造成无限递归，最终引发stack over flow。如果要使用属性（无论读或者写），一定使用幕后字段。

class Test{
    var name = ""
    set(value) {
        //错误的示范，在set使用了name属性本身，应该使用field
        name = value
    }
}

class Test{
    var name = ""
    private set(value) {
        field = value
    }
}

11，常用的集合操作符

**元素操作类**
 
- contains :判断是否有指定元素
- elementAt：返回对应元素，越界会抛出IndexOutOfBoundsException
- firstOrNull：返回符合条件的第一个元素，没有返回null
- lastOrNull：返回符合提交的最后一个元素，没有返回null
- indexOf：返回指定元素的下标，没有返回-1
- singleOrNull：返回符合条件的单个元素，如果没有符合或超过1个，返回Null
 
**判断类**
 
- any：判断集合中是否有满足条件的元素
- all：判断集合中的元素是否都满足条件
- none：判断集合中是否都不满足条件
- count：查询集合中满足条件的个数
- reduce：从第一项累加到最后一项
 
**过滤类**
 
- filter：过滤所有满足条件的元素
- filterOrNot：过滤所有不满足条件的元素
- filterNotNull：过滤NULL元素
- take：返回前N个元素
 
**转换类**
 
- map：转换成另外一个集合
- mapIndexed：转换成另外一个集合，还可以拿下标
- mapNotNull：执行转换前先过滤掉为NULL的元素
- flatMap：自定义逻辑合并两个集合
- groupBy：按照某个条件分组，返回map
 
**排序类**
 
- reversed：反序
 
- sorted：升序
 
- sortedBy：自定义排序
- sortedDescending：降序

12，运算符重载与中缀表达式

运算符重载要使用关键字operator，重载运算符有一个要求：只能重载Kotlin中定义好的运算符。

operator 将一个函数标记为重载一个操作符或者实现一个约定。运算符重载就是对已有的运算符赋予他们新的含义。

Kotlin中的 && 、 || 、 ?: 、 === 、 !== 是不能被重载的

data class Person(var name: String, var age: Int)
 
operator fun Int.plus(b: Person): Int {
    return this - b.age
}
 
fun main() {
 
    val person1 = Person("A", 3)
 
    val testInt = 5
 
    println("testInt+person1=${testInt +person1}")
}

输出结果
testInt+person1=2

运算符在Kotlin中是有数量上限的，当kotlin中已有的运算符不能满足我们使用的时候，我们需要对运算符进行扩展，这里就用到了中缀表达式（如step)，定义中缀表达式使用关键字：infix

infix 类型.函数() 是中缀函数的声明形式，就是扩展函数前面使用了indfix关键字，函数签名的类型，称为函数的接收者类型，换言之只有该类型才能调用这个函数。

中缀也可以被通过正常的函数调用来使用：类对象.中缀函数（）

sealed class CompareResult{
    object More : CompareResult(){
        override fun toString(): String {
            return "大于"
        }
    }
 
    object Less : CompareResult(){
        override fun toString(): String {
            return "小于"
        }
    }
 
    object Equal : CompareResult(){
        override fun toString(): String {
            return "等于"
        }
    }
}
 
infix fun Int.vs(value : Int) : CompareResult =
        if(this - value > 0){
            CompareResult.More
        }else if(this - value < 0){
            CompareResult.Less
        }else{
            CompareResult.Equal
        }
 
fun main(){
    println(5 vs 6)
    println(8.vs(7))
}

需要注意一点是，如果在一个类中重载了别的类的运算符，那么这个重载运算符仅能在这个类及其子类中使用，在这个类的外部、派生类、object修饰的类均不能使用

13，解构

kotlin允许将一个类拆解，并分别赋值。

class User(var name:String, var age:Int){
    operator fun component1() = name    //这里的operator是约定的意思，就是约定name是component1()
    operator fun component2() = age
}
 
fun main(){
    var(name, age) = User("111",2)
    println("name = $name, age = $age")
}

解构常用于遍历MAP和List中，能够一次性拿到所有值

val map = mapOf("key1" to "value1", "key2" to "value2", 3 to "value3")
for((key, value) in map){
    println("$key----------------$value")
}
 
//使用map的话可以直接拿 index和value，使用list必须使用withIndex()
val list = arrayListOf("1", "2", "3", "4")    
for((index, value) in list.withIndex()){
    println("index = $index, value = $value")
}

14，typealias

这个类似于C/C++上面的typedef，将一个类映射到另一个类上，不同点C/C++是宏定义展开，在Kotlin中是完全映射。用于在跨平台上有一个更好的兼容性

Android JNI1--C语言基础_袁震的博客-CSDN博客

public typealias 别名 = 映射到的对象
 
//给File类创建了一个别明类TestFile, 使用TestFile与使用File是完全一样的
public typealias TestFile = File   

这个特性被广泛运用在各种集合的定义中，比如Kotlin的HashMap其实就是映射的java的HashMap

@SinceKotlin("1.1") public actual typealias HashMap = java.util.HashMap

15，Callback

public interface JavaCallback {
 
    void show(String info);
 
}

public class JavaManager {
 
    public void setCallback(JavaCallback javaCallback) {
        javaCallback.show("yuanzhenjava");
    }
 
}

interface KTCallback {
 
    fun show(name: String)
 
}

class KtManager {
 
    fun setCallback(callback: KTCallback) {
        callback.show("yuanzhen")
    }
 
}

kotlin调用java CallBack:

//第一种写法
JavaManager().setCallback(JavaCallback {
    println(it)
})
// 第二种写法
JavaManager().setCallback(object : JavaCal
    override fun show(info: String?) {
        println(info)
    }
})
// 第三种写法
val callback = JavaCallback {
    println(it)
}
JavaManager().setCallback(callback)
// 第四种写法
val callback2 = object : JavaCallback{
    override fun show(info: String?) {
        println(info)
    }
}
JavaManager().setCallback(callback2)

kotlin调用kotlin CallBack

//第一种写法
KtManager().setCallback(object : KTCallback{
    override fun show(name: String) {
    }
})
// 第二种写法
val c = object : KTCallback{
    override fun show(name: String) {  }
}
KtManager().setCallback(c)

16，Lambda表达式

最基本的lambda表达式格式：

val lambda表达式名称 : (参数类型,...) -> （返回值类型）={参数名称,... -> 函数实现（返回值）}
val lambda闭包名称 = { 参数名称：类型 -> 函数实现（返回值） }

调用：

闭包名称.invoke(参数列表)
闭包名称(参数列表)

下面来看使用：

这种情况不能调用，因为没有具体的实现，但是可以定义

再来看这种情况：

val method2 :(Int, Int)-> Int
method2(1,2)

这种情况可以调用吗？ 

答案是不能，因为它虽然有入参和返回值，但是依然没有具体实现

再来看下面的例子：

val method : (Int,Int) ->Int ={a,b->a+b}
println("${method(1,2)}")

这种情况是可以调用的，并且输出3

因为它有具体的实现

下面来看一下lambda表达式的第二种写法：

val method3 ={a:Int ,b:Int ->a+b}
println("${method3.invoke(1,2)}")
println("${method3(2,3)}")

输出3  5

这种写法还可以自动转型：

val method4 ={a:Int ,b:Int ->a.toDouble()+b.toDouble()}
println("${method4(2,3)}")

输出5.0

：格式返回空的写法：

val method5 : (String,String) ->Unit ={a,b-> println("a:$a,b:$b") }
method5("yuan","zhen")

输出：a:yuan,b:zhen
再来看一个例子：

val method6 : (Int) ->String ={
    when(it){
        in 1 ..200 ->"在1到200 之间"
        in 201 ..300 ->"在201到300之间"
        else ->"在300以上"
    }
}
println(method6(120))

输出：在1到200 之间

再来看一个最简洁的使用：

val method7 ={ println("method7") }
method7()

lambda表达式可以进行覆盖操作：

var method8 ={a:Int, b:Int -> println("$a,$b") }
method8 ={ a:Int, b:Int ->println("覆盖了") }
method8(1,2)

输出：覆盖了

如果想要打印，并且想要返回值，怎么操作？

var method9 ={a:Int -> println("$a")
    a
}
println("结果：${method9(10)}")

输出：10  结果：10

会返回最后一行的结果，如果是空，返回Unit

 Lambda闭包三原则：

①，如果lamdba闭包没有参数，可以省略箭头符号（仅写实现部分）；如果lamdba仅有一个参数，可以省略声明，并在使用时使用`it`来代替

②，如果lambda闭包是函数的最后一个参数，则可以将大括号放到小括号(函数名称的小括号）外

③，如果函数只有一个参数并且这个参数是lambda，则可以省略小括号

下面来看一个例子：

val txt = findViewById(R.id.txt)
txt.setOnClickListener(object :View.OnClickListener {
    override fun onClick(v: View?) {
       println("${v?.id}")
    }
})

如果我们用lambda表达式来写的话：

txt.setOnClickListener({v->println("${v?.id}")})

如果使用原则①的话：

txt.setOnClickListener({println("${it?.id}")})

如果使用原则②的话：

txt.setOnClickListener(){println("${it?.id}")}

如果使用原则③的话：

txt.setOnClickListener{println("${it?.id}")}

17，高阶函数

函数的参数或者函数返回值是Lamdba闭包的函数，我们称之为高阶函数

Kotlin的高阶函数有点类似于C++的函数指针

光说字面意思，我们可能会有点懵，下面我们就来看一个简单的高阶函数用法：

拿一个简单的登录操作来说，正常写法是：

fun login(name:String,pwd :String):Boolean{
    if (name == "yuanzhen" && pwd == "123") {
        println("登陆成功")
        return   true
    } else {
        println("登录失败")
        return  false
    }
}
 
val result =login("yuanzhen","123")
println(result)

输出登录成功 true

如果用高阶函数怎么来写呢？

fun login1(name: String,pwd: String, yy: (String,String)->Boolean){
    yy(name,pwd)
}

login1("yuanzhen","123",{name,pwd ->
    if (name == "yuanzhen" && pwd == "123") {
        println("登陆成功")
        true
    } else {
        println("登录失败")
        false
    }
})

输出：登录成功

这样使用起来比较麻烦，我们可以使用typealias来定义lambda参数名称

typealias LambdaMethod =(String,String)->Boolean
 
fun login2(name:String,pwd:String){
    login1(name,pwd){name,pwd->
        if (name == "yuanzhen" && pwd == "123") {
            println("登陆成功")
            true
        } else {
            println("登录失败")
            false
        }
    }
}
 
fun login1(name: String,pwd: String, yy: LambdaMethod){
    yy(name,pwd)
}

调用：

login2("yuanzhen","123")

下面我们来给一个万能的类型增加一个扩展函数

fun  T.outMethod(yy: T.() ->T){
    println(yy())
}

val name ="yuanzhen"
val age =30
 
fun main() {
    name.outMethod {
        if(this =="yuanzhen"){
            "22222"
        }else{
            "33333"
        }
    }
    age.outMethod {
        if(this ==30){
            30
        }else{
            20
        }
    }
}

输出：22222  30 

是不是有点懵？

下面我们来解释一下：

T.outMethod() 是一个扩展函数，yy: T.() ->T 是一个lambda表达式，作为参数，就是高阶函数了

T.()是一个匿名函数，就相当于this

println(yy())就相当于调用了参数yy

因为T是任意类型的，所以name和age都可以调用。

this在name中，就是"yuanzhen" 在age中，就是30。

再来看一个升级版的用法：

fun  T.outMethod1(yy: T.() ->R):R = yy()

val name1 =name.outMethod1 {
    if(this=="yuanzhen"){
        80
    }else{
        10
    }
}
println("name1:$name1")

输出：name1:80
这个相当于给方法outMethod1增加了一个返回值，返回值与yy一样

下面继续升级：

fun  T.outMethode2(yy: T.(T) -> R):R =yy(this)
 
val  name2 =name.outMethode2 {
    println(this)
    println(it)
    200
}
println(name2)

输出： 

yuanzhen
yuanzhen
200

所以，我们可以看到，在这里，this和it是一样的

上面的高阶函数，我们还可以链式调用

val  name2 =name.outMethode2 {
    println(this)
    println(it)
    200
}.outMethode2 {
    100
}.outMethode2 {
    "1111"
}
println(name2)

输出：

yuanzhen
yuanzhen
1111

下面我们来一个实战： 自定义一个线程

fun myThread(yy:() ->Unit) :Thread{
    val thread =object :Thread(){
        override fun run() {
            super.run()
            yy()
        }
    }
    thread.start()
    return thread
}

myThread {
    name.outMethode2 {
        println(this)
        println(it)
        200
    }
}

关于高阶函数，就讲这么多，更多的是自己去敲，去想怎么使用，光看的话很容易蒙圈。

总结

kotlin的高阶用法差不多就是上面这些，关于协程，可以查看文章

Android Kotlin 协程详解_袁震的博客-CSDN博客