Android知识体系之Kotlin

Android知识体系 kotlin

return跳转

fun fun5() {
    listOf(1, 2, 3, 4, 5).forEach(fun(value: Int) {
        if (value == 3) {
            return
        }
        println("value is $value")
    })
    println("function end")
}
fun fun6() {
    listOf(1, 2, 3, 4, 5).forEach {
        if (it == 3) {
            return
        }
        println("value is $it")
    }
    println("function end")
}
// 结果
// =====fun5======
// value is 1
// value is 2
// value is 4
// value is 5
// function end
// =====fun6=====
// value is 1
// value is 2

数据类

data class Person(val name: String, val age: Int)
class Point(val x : Int, val y : Int) {
    operator fun component1() = x
    operator fun component2() = y
}

对于数据类来说，其自动生成了 componentN() 函数，而对非数据类，为了使用解构声明，需要我们自己来手动声明函数

var person1 = Person("xiaoming", 18)
var person2 = Person(age = 18, name = "xiaoming")
val (name, age) = person2
println("$name : $age") // xiaoming:18
val (age1, name1) = person2
println("$name1 : $age1")// 18:xiaoming
var(x, y) = Point(100, 200)
println("$x , $y")// 100, 200

扩展函数

• 扩展函数不能访问"private" 修饰的函数和属性。
• 扩展函数不会影响原有类的构成（不属于类本身，不能被子类继承）。
• 扩展函数调用方式与成员函数调用方式类似，都可以通过对象调用。

class Student {
    //来自省份
    var province:String?= null
    //学生名字
    var name:String? = null
    init {
        name = "fish"
        province = "beijing"
    }
    fun printStudent() {
        println("$name")
    }
}
fun main(args: Array<String>) {
    var student = Student()
    student.printStudent()
}

现在有个需求想要打印名字的同时还打印省份。
你可能会说：直接在printStudent()加入打印省份信息不就得了？
如果是第三方的文件呢？咱们没权限修改源文件，在Java 里我们一般通过包装Student类，再提供打印学生姓名和省份的方法。
而Koltin里更简洁，可以直接对这个类进行函数扩展。

fun main(args: Array<String>) {
    var student = Student()
    student.printStudent1()
}
//扩展函数
fun Student.printStudent1() {
    println("name:$name province:$province")
}
反编译Java代码
public static final void printStudent1(@NotNull Student $this$printStudent1) {
    Intrinsics.checkNotNullParameter($this$printStudent1, "$this$printStudent1");
    String var1 = "name:" + $this$printStudent1.getName() + " province:" + $this$printStudent1.getProvince();
    boolean var2 = false;
    System.out.println(var1);
}

当扩展一个类的函数时，实际上传入了该类的对象，通过对象拿到属性/函数并操作。其本质上还是通过类的对象实例来组合各种操作。
假若现在将"province" 访问权限修改为"private"，那么printStudent1 将无法访问到该属性。

属性委托 by

by lazy by viewModels by activityViewModes本质上都是属性委托。
lazy是函数，viewModels是函数，activityViewModels也是函数，他们返回了Delegate 对象，且这个对象必须要有 operator fun getValue operator fun setValue ，用val声明不需要 setValue.

Kotlin中属性在声明的同时也要求要被初始化，否则会报错。
例如以下代码:

private var name0: String //报错
private var name1: String = "xiaoming" //不报错
private var name2: String? = null //不报错

可是有的时候，我并不想声明一个类型可空的对象，而且我也没办法在对象一声明的时候就为它初始化，那么这时就需要用到Kotlin提供的延迟初始化。

Kotlin中有两种延迟初始化的方式。一种是lateinit var，一种是by lazy。

lateinit var
private lateinit var name: String

• 只能用来修饰类属性，不能用来修饰局部变量
• 只能用来修饰对象，不能用来修饰基本类型(因为基本类型的属性在类加载后的准备阶段都会被初始化为默认值)。

lateinit var的作用也比较简单，就是让编译期在检查时不要因为属性变量未被初始化而报错。

by lazy
//用于属性延迟初始化
val name: Int by lazy { 1 }
//用于局部变量延迟初始化
public fun foo() {
    val bar by lazy { "hello" }
    println(bar)
}

• by lazy要求属性声明为val，即不可变变量，在java中相当于被final修饰。
  这意味着该变量一旦初始化后就不允许再被修改值了(基本类型是值不能被修改，对象类型是引用不能被修改)。{}内的操作就是返回唯一一次初始化的结果。
• by lazy可以使用于类属性或者局部变量。

总结一下，当一个属性name需要by lazy时，具体是怎么实现的:

1. 生成一个该属性的附加属性:name?delegate；
2. 在构造器中，将使用lazy(()->T)创建的Lazy实例对象赋值给name?delegate；
3. 当该属性被调用，即其getter方法被调用时返回name?delegate.getVaule()，而name?delegate.getVaule()方法的返回结果是对象name?delegate内部的_value属性值，在getVaule()第一次被调用时会将_value进行初始化，往后都是直接将_value的值返回，从而实现属性值的唯一一次初始化。

内联

内联函数的本质是：把函数体复制粘贴到函数调用处

inline fun test() {
    println("I'm a inline function")
}
fun run() { 
    test() 
}

在 run() 函数中调用了内联函数 test()。反编译查看对应的 java 代码：

public static final void test() {
    String var1 = "I'm a inline function";
    System.out.println(var1);
}
public static final void run() {
    String var1 = "I'm a inline function";
    System.out.println(var1);
}

可以看到 run() 函数中并没有直接调用 test() 函数，而是把 test() 函数的代码直接放入自己的函数体中。这就是 inline 的功效。
高阶函数里面会详细讲到inline的使用。

noinline

当一个 inline 函数中，有多个 lambda 作为参数时，可以在不想内联的 lambda 前使用 noinline 声明.

inline fun sum(a: Int, b: Int, lambda: (result: Int) -> Unit, noinline lambda2: (result: Int) -> Unit): Int {
    val r = a + b
    lambda.invoke(r)
    lambda2.invoke(r)
    return r
}
fun main(args: Array<String>) {
    sum(1, 2,
            { println("Result is: $it") },
            { println("Invoke lambda2: $it") }
    )
}

反编译 Java:

public static final int sum(int a, int b, @NotNull Function1 lambda, @NotNull Function1 lambda2) {
   int r = a + b;
   lambda.invoke(r);
   lambda2.invoke(r);
   return r;
}
public static final void main(@NotNull String[] args) {
   byte a$iv = 1;
   byte b$iv = 2;
   Function1 lambda2$iv = (Function1)null.INSTANCE;
   int r$iv = a$iv + b$iv;
   String var8 = "Result is: " + r$iv;
   System.out.println(var8);
   lambda2$iv.invoke(r$iv);
}

第一个 lambda 内联到了调用处，而第二个使用 noinline 声明的 lambda 没有。

crossinline

我们先看一个例子：

fun main() {
    println("1111")
    sayHello {
        println("2222")
        return
    }
    println("4444")
}
private inline fun sayHello(block: () -> Unit) {
    println("3333")
    block()
}

你猜，结果是什么呢？

1111
3333
2222

4444并没有打印，为什么会这样啊？这其实不就是inline的特性吗？看反编译代码：

public static final void main() {
   String var0 = "1111";
   System.out.println(var0);
   int $i$f$sayHello = false;
   String var1 = "3333";
   System.out.println(var1);
   int var2 = false;
   String var3 = "2222";
   System.out.println(var3);
   // 下面这三行是我添加的，其实并没有，因为在return后面，编译器直接就给忽略了
   //return;
   //String var4 = "4444";
   //System.out.println(var4);
}
// 没用
private static final void sayHello(Function0 block) {
   int $i$f$sayHello = 0;
   String var2 = "3333";
   System.out.println(var2);
   block.invoke();
}

声明一个 lambda 不能有 return 语句(可以有 return@label 语句)。这样可以避免使用 inline 时，lambda 中的 return 影响程序流程。

inline fun sum(a: Int, b: Int, crossinline lambda: (result: Int) -> Unit): Int {
    val r = a + b
    lambda.invoke(r)
    return r
}
fun main(args: Array<String>) {
    sum(1, 2) {
        println("Result is: $it")
        return  // 编译错误: return is not allowed here
    }
}

小结

• 使用 inline，内联函数到调用的地方，能减少函数调用造成的额外开销，在循环中尤其有效
• 使用 inline 能避免函数的 lambda 形参额外创建 Function 对象
• 使用 noinline 可以拒绝形参 lambda 内联
• 使用 crossinline 显示声明 inline 函数的形参 lambda 不能有 return 语句，避免lambda 中的 return 影响外部程序流程

JvmField&JvmStatic

• JvmField 注解可以消除 get / set 方法
• JvmField 注解是的属性以 public 的形式对外暴露

JvmStatic只能在object类或者伴生对象companion object中使用

• JvmStatic作用于属性时，会把 get / set方法变成静态的
• JvmStatic作用于方法时，会把该方法变成静态的

Objec关键字

Kotlin 的 object 关键字有三种用法：

• 对象声明 ，一般用来实现单例
• 伴生对象 ，类似 Java 的 static 关键字，也可以用于工厂方法模式
• 对象表达式 ，一般用来代替 Java 的匿名内部类

对象声明

对象声明，可以直接用来实现单例模式：

object Singleton{
    fun xxx(){}
}

直接 Decompile 看 Java 代码：

public final class Singleton {
   @NotNull
   public static final Singleton INSTANCE;
   public final void xxx() {
   }
   private Singleton() {
   }
   static {
      Singleton var0 = new Singleton();
      INSTANCE = var0;
   }
}

从 Java 代码中可以看出来，显然这是一个单例模式。

• 私有构造函数
• 通过静态字段对外提供实例
• 静态代码块中直接初始化，线程安全 。

这在实际的业务场景是有一定限制的：对于需要携带参数的单例类，object 就有点力不从心了。
当然也不难解决，模仿 Java 的写法就行了，这里以 DCL 模式为例。

class Singleton private constructor(private val param: Int) {
    companion object {
        @Volatile
        private var instance: Singleton? = null
        fun getInstance(property: Int) =
            instance ?: synchronized(this) {
                instance ?: Singleton(property).also { instance = it }
            }
    }
}

伴生对象

伴生对象，顾名思义，就是伴随着类而存在的对象，在类加载的时候初始化。

class Book {
    fun test() {
        setApp(this)
    }
    companion object {
        var a = 1
        var b = "xiaoming"
        lateinit var instance: Book
            private set
        fun setApp(app: Book) {
            instance = app
        }
    }
}
// 外面使用
Book.setApp(xx);
Book.a;

转换成Java代码，我们看下

public final class Book {
   private static int a = 1;
   @NotNull
   private static String b = "xiaoming";
   private static Book instance;
   @NotNull
   public static final Book.Companion Companion = new Book.Companion((DefaultConstructorMarker)null);
   public final void test() {
      Companion.setApp(this);
   }
   public static final class Companion {
      public final int getA() {
         return Book.a;
      }
      public final void setA(int var1) {
         Book.a = var1;
      }
      @NotNull
      public final String getB() {
         return Book.b;
      }
      public final void setB(@NotNull String var1) {
         Intrinsics.checkNotNullParameter(var1, "<set-?>");
         Book.b = var1;
      }
      @NotNull
      public final Book getInstance() {
         Book var10000 = Book.instance;
         if (var10000 == null) {
            Intrinsics.throwUninitializedPropertyAccessException("instance");
         }
         return var10000;
      }
      private final void setInstance(Book var1) {
         Book.instance = var1;
      }
      public final void setApp(Book app) {
         ((Book.Companion)this).setInstance(app);
      }
      private Companion() {
      }
      // $FF: synthetic method
      public Companion(DefaultConstructorMarker $constructor_marker) {
         this();
      }
   }
}
// 外面使用
Book.Companion.setApp(xx);
Book.Companion.a;

可以看出来：

• companion object是Book的静态内部类，在Book里面会new一个静态内部类的对象
• 外部类Book调用companion object的方法，其实就是通过上一步new出来对象
• companion object里面定义的变量，都是Book的静态变量

了解了伴生对象的本质之后，再来说两个它的其他用法。

创建静态工厂方法

enum class CarType {
    AUDI,BMW
}
interface Car {
    val brand: String
    companion object {
        operator fun invoke(type: CarType): Car {
            return when (type) {
                CarType.AUDI -> Audi()
                CarType.BMW -> BMW()
            }
        }
    }
}
class Audi : Car {
    override val brand: String = "audi"
}
class BMW : Car {
    override val brand: String = "bmw"
}
// 使用
fun testCar() {
    Car(CarType.BMW)
}

这里重载了 invoke() 方法，调用时直接 Car(CarType.BMW) 即可。
反编译之后，我们看下：

// Car.java
package com.arcfox.n61manual;
import kotlin.Metadata;
import org.jetbrains.annotations.NotNull;
public interface Car {
   @NotNull
   Car.Companion Companion = Car.Companion.$$INSTANCE;
   @NotNull
   String getBrand();
   public static final class Companion {
      // $FF: synthetic field
      static final Car.Companion $$INSTANCE;
      @NotNull
      public final Car invoke(@NotNull CarType type) {
         // $FF: Couldn't be decompiled
      }
      private Companion() {
      }
      static {
         Car.Companion var0 = new Car.Companion();
         $$INSTANCE = var0;
      }
   }
}
// TestKt.java
package com.arcfox.n61manual;
import kotlin.Metadata;
public final class TestKt {
   public static final void testCar() {
      Car.Companion.invoke(CarType.BMW);
   }
}

伴生对象扩展方法

伴生对象也是支持扩展方法的。还是以上面的 Car 为例，定义一个根据汽车品牌获取汽车类型的扩展方法。

fun Car.Companion.getCarType(brand:String) :CarType { ...... }

虽然是在 Car.Companion 上定义的扩展函数，但实际上相当于给 Car 增加了一个静态方法，使用方式如下：

Car.getCarType("BMW")

对象表达式

对象表达式最经典的用法就是用来 代替 Java 的匿名内部类 。例如常见的点击事件：

xxx.setOnClickListener(object : View.OnClickListener{
        override fun onClick(v: View) {
        }
})

这和 Java 的匿名内部类是等价的。只不过像上面的单方法接口，我们很少用 object 写，而是用 lambda 代替，显得更加简洁。

xxx.setOnClickListener { view ->  ...... }

当匿名对象需要重写多个方法时，就只能选择对象表达式了。
和 Java 的匿名内部类一样，对象声明中也可以访问外部变量。
对象表达式应该是 object 最朴实无华的使用方式了。

匿名函数

fun a(funParam: (Int) -> String): String {
    return funParam(1)
}

要传一个函数类型的参数，或者把一个函数类型的对象赋值给变量，除了用双冒号来拿现成的函数使用，你还可以直接把这个函数挪过来写：

a(fun b(param: Int): String {
    return param.toString()
});
val d = fun b(param: Int): String {
    return param.toString()
}

另外，这种写法的话，函数的名字其实就没用了，所以你可以把它省掉：

a(fun(param: Int): String {
    return param.toString()
});
val d = fun(param: Int): String {
    return param.toString()
}

这种写法叫做匿名函数。为什么叫匿名函数？很简单，因为它没有名字呗，对吧。等号左边的不是函数的名字啊，它是变量的名字。这个变量的类型是一种函数类型，具体到我们的示例代码来说是一种只有一个参数、参数类型是 Int、并且返回值类型为 String 的函数类型。
另外呢，其实刚才那种左边右边都有名字的写法，Kotlin 是不允许的。右边的函数既然要名字也没有用，Kotlin 干脆就不许它有名字了。

所以，如果你在 Java 里设计一个回调的时候是这么设计的：

public interface OnClickListener {
    void onClick(View v);
}
public void setOnClickListener(OnClickListener listener) {
    this.listener = listener;
}

使用的时候是这么用的：

view.setOnClickListener(new OnClickListener() {
    @Override
    void onClick(View v) {
        switchToNextPage();
    }
});

到了 Kotlin 里就可以改成这么写了：

fun setOnClickListener(onClick: (View) -> Unit) {
    this.onClick = onClick
}
view.setOnClickListener(fun(v: View): Unit) {
    switchToNextPage()
})

简单一点哈？另外大多数（几乎所有）情况下，匿名函数还能更简化一点，写成 Lambda 表达式的形式：

view.setOnClickListener({ v: View -> 
    switchToNextPage()
})
// 当然可以继续简化
view.setOnClickListener { v: View -> 
    switchToNextPage()
}
// 继续简化
view.setOnClickListener {
    switchToNextPage()
}

终于讲到 Lambda 了。

Lambda

Lambda 表达式本质上就是可以传递给其它函数的一小段代码，通过 Lambda 表达式可以把通用的代码结构抽取成库函数，也可以把 Lambda 表达式存储在一个变量中，把这个变量当做普通函数对待
//由于存在类型推导，所以以下三种声明方式都是完全相同的

val plus1: (Int, Int) -> Int = { x: Int, y: Int -> x + y }
val plus2: (Int, Int) -> Int = { x, y -> x + y }
val plus3 = { x: Int, y: Int -> x + y }
println(plus3(1, 2))

1. 一个 Lambda 表达式始终用花括号包围，通过箭头把实参列表和函数体分开
2. 如果 Lambda 声明了函数类型，那么就可以省略函数体的类型声明
3. 如果 Lambda 声明了参数类型，且返回值支持类型推导，那么就可以省略函数类型声明

Lambda 表达式最常见的用途就是和集合一起工作，看以下例子
要从一个人员列表中取出年龄最大的一位

data class Person(val name: String, val age: Int)
fun main() {
    val people = listOf(Person("leavesC", 24), Person("Ye", 22))
    println(people.maxBy { it.age }) //Person(name=leavesC, age=24)
}

当中，库函数 maxBy 可以在任何集合上调用，其需要一个实参：一个函数，用于指定要用来进行比较的函数。花括号中的代码 { it.age } 就是实现了这个逻辑的 Lambda 表达式

上述 maxBy 函数的实参是简化后的写法，这里来看下 maxBy 函数的简化过程

- 最原始的语法声明应该是这样的，用括号包裹着 Lambda 表达式
println(people.maxBy({ p: Person -> p.age }))
- kotlin 有一种语法约定，如果 Lambda 表达式是函数调用的最后一个实参，可以将之放到括号的外边
println(people.maxBy() { p: Person -> p.age })
- 当 Lamdba 表达式是函数唯一的实参时，可以去掉调用代码中的空括号对
println(people.maxBy { p: Person -> p.age })
- 当 Lambda 表达式的参数类型是可以被推导出来时就可以省略声明参数类型
println(people.maxBy { p -> p.age })
- 如果当前上下文期待的是只有一个参数的 Lambda 表达式且参数类型可以被推断出来，就会为该参数生成一个默认名称：it
println(people.maxBy { it.age })

匿名函数和Lambda的本质

• 函数并不能传递，传递的是对象
• 匿名函数和 Lambda 表达式其实都是对象

泛型

https://juejin.cn/post/6935322686943920159

//泛型类
class A<T> {}
class Plate<T : Fruit>(val t: T)
class Plate<T>(val t: T) where T : Fruit, T : Soft
//泛型接口
interface B<T>{}
//泛型方法
fun <T> pick(a : T) {}

Java 的类型通配符 ? 对应 Kotlin 中的概念就是 *

高阶函数

定义

首先来看一下高阶函数的定义。如果一个函数接收另一个函数作为参数，或者返回值的类型是另一个函数，那么该函数就称为高阶函数。
这个定义可能有点不太好理解，一个函数怎么能接收另一个函数作为参数呢？这就涉及另外一个概念了：函数类型。我们知道，编程语言中有整型、布尔型等字段类型，而 Kotlin 又增加了一个函数类型的概念。如果我们将这种函数类型添加到一个函数的参数声明或者返回值声明当中，那么这就是一个高阶函数了。

函数类型的语法规则如下：

(String, Int) -> Unit

• -> 左边的部分就是用来声明该函数接收什么参数的，多个参数之间使用逗号隔开，如果不接收任何参数，写一对空括号就可以了。
• -> 右边的部分用于声明该函数的返回值是什么类型，如果没有返回值就使用 Unit，它大致相当于 Java 中的 void。

fun example(func: (String, Int) -> Unit) {
    func("xiaoming", 18)
}
fun main() {
    example({name: String, age: Int ->
        println("=====")
        println("name: $name, age: $age")
    })
    example { name, age ->
        println("=====")
        println("name: $name, age: $age")
    }
}

使用

那高阶函数具体有什么用途呢？由于高阶函数的用途实在是太广泛了，这里如果要让我简单概括一下的话，那就是高阶函数允许让函数类型的参数来决定函数的执行逻辑。
即使是同一个高阶函数，只要传入不同的函数类型参数，那么它的执行逻辑和最终的返回结果就可能是完全不同的。
咱们再看一个例子

fun num1AndNum2(num1: Int, num2: Int, operation: (Int, Int) -> Int): Int {
    return operation(num1, num2)
}

定义了一个函数，三个参数，两个int类型，一个函数类型（参数为两个int，返回值为int）；
对传入的两个整型参数进行某种运算，并返回最终的运算结果，但是具体进行什么运算是由传入的函数类型参数决定的。

fun plus(num1: Int, num2: Int): Int {
    return num1 + num2
}
fun minus(num1: Int, num2: Int): Int {
    return num1 - num2
}
fun main() {
    val num1 = 100
    val num2 = 80
    val result1 = num1AndNum2(num1, num2, ::plus)
    val result2 = num1AndNum2(num1, num2, ::minus)
    println("result1 is $result1")
    println("result2 is $result2")
}

::plus 和 ::minus 这种写法，是函数引用方式的写法，表示将 plus() 和 minus() 函数作为参数传递给 num1AndNum2() 函数。

使用这种函数引用的写法虽然能够正常工作，但是如果每次调用任何高阶函数的时候都还得先定义一个与其函数类型参数相匹配的函数，这是不是有些太复杂了？
没错，因此 Kotlin 还支持其他多种方式来调用高阶函数，比如 Lambda 表达式、匿名函数、成员引用等。其中，Lambda 表达式是最常见也是最普遍的高阶函数调用方式，也是我们接下来要重点学习的内容。
上述代码如果使用 Lambda 表达式的写法来实现的话，代码如下所示：

fun main() {
    println(num1AndNum2(10, 20, ::plus))
    val result = num1AndNum2(10, 6) { num1, num2 ->
        num1 - num2
    }
    println(result)
}

为什么系统的高阶函数都需要加上inline?

kotlin在Standard.kt标准库中提供了一些便捷的内置高阶函数( let、also、with、run、apply )，可以帮助我们写出更简洁优雅的 Kotlin 代码，提高开发效率，但是我们看这些高阶函数的时候，会发现他们都被inline修饰。

public inline fun <R> run(block: () -> R): R {
    contract {
        callsInPlace(block, InvocationKind.EXACTLY_ONCE)
    }
    return block()
}
@kotlin.internal.InlineOnly
public inline fun <T, R> T.run(block: T.() -> R): R {
    contract {
        callsInPlace(block, InvocationKind.EXACTLY_ONCE)
    }
    return block()
}

为什么这样呢？咱们还以上面的例子来说明：

fun num1AndNum2(num1: Int, num2: Int, operation: (Int, Int) -> Int): Int {
    val result = operation(num1, num2)
    return result
}
fun main() {
    val num1 = 100
    val num2 = 80
    val result = num1AndNum2(num1, num2) { n1, n2 ->
        n1 + n2
    }
}

转换为java代码：

public static int num1AndNum2(int num1, int num2, Function operation) {
    int result = (int) operation.invoke(num1, num2);
    return result;
}
public static void main() {
    int num1 = 100;
    int num2 = 80;
    int result = num1AndNum2(num1, num2, new Function() {
        @Override
        public Integer invoke(Integer n1, Integer n2) {
            return n1 + n2;
        }
    });
}

在这里 num1AndNum2() 函数的第三个参数变成了一个 Function 接口，这是一种 Kotlin 内置的接口，里面有一个待实现的 invoke() 函数。而 num1AndNum2() 函数其实就是调用了 Function 接口的 invoke() 函数，并把 num1 和 num2 参数传了进去。

这就是 Kotlin 高阶函数背后的实现原理。你会发现，原来我们一直使用的 Lambda 表达式在底层被转换成了匿名类的实现方式。这就表明，我们每调用一次 Lambda 表达式，都会创建一个新的匿名类实例，当然也会造成额外的内存和性能开销。

而为了解决这个问题，Kotlin 提供了内联函数的功能，它可以将使用 Lambda 表达式带来的运行时开销完全消除。
内联函数的用法非常简单，只需要在定义高阶函数时加上 inline 关键字的声明即可，如下所示：

inline fun num1AndNum2(num1: Int, num2: Int, operation: (Int, Int) -> Int): Int {
    val result = operation(num1, num2)
    return result
}

那么内联函数的工作原理又是什么呢？其实并不复杂，就是 Kotlin 编译器会将内联函数中的代码在编译的时候自动替换到调用它的地方，这样也就不存在运行时的开销了。

我们用图例来说明一下：
下图是原始写法，我们继续看看编译器都做了什么
[图片]

第一步，将 上图中Lambda 表达式中的代码替换到函数类型参数调用的地方，变成了下图所示的样子
[图片]
第二步，将内联函数中的全部代码替换到函数调用的地方，也就变成了下图的样子
[图片]

也正是如此，内联函数才能完全消除 Lambda 表达式所带来的运行时开销。

Standard.kt

为了方便解释，我们先定义一个Student类

class StudentInfo {
    //姓名
    var name:String? = "Fish"
    var alias:String ? = "小鱼人"
    //省份
    var province:String? = "北京"
    //年龄
    var age:Int ? = 18
    //性别
    var isBoy:Boolean = true
    //分数
    var score:Float = 88f
}

let

public inline fun <T, R> T.let(block: (T) -> R): R {
    //内联函数，扩展函数，定义了泛型，接收一个函数类型参数
    //调用函数，返回执行结果
    return block(this)
}

定义了泛型T，let 作为T的扩展函数，let 的参数为函数类型，接收T对象，返回R，返回值也可以为Unit。

// 不使用let
fun testLet1(studentInfo: StudentInfo) {
    studentInfo?.isBoy = false
    studentInfo?.name = "小鱼人"
    studentInfo?.age = 14
}
// 使用let
fun testLet2(studentInfo: StudentInfo) {
    var letRet = studentInfo?.let {
        it.isBoy = false
        it.name = "小鱼人"
        it.age = 14
        //Lambda结果作为let 返回值
        "111"
    }
    println("$letRet, ${studentInfo.name}")// 111,小鱼人
}
// 也可以没有返回值，就是Unit
fun testLet2(studentInfo: StudentInfo) {
    var letRet = studentInfo?.let {
        it.isBoy = false
        it.name = "小鱼人"
        it.age = 14
    }
    println("$letRet, ${studentInfo.name}")// Kotlin.Unit,小鱼人
}

作用：

• 一是可以约束变量的操作范围
• 二是可以在入口处统一判空。

also

public inline fun <T> T.also(block: (T) -> Unit): T {
    //扩展函数，函数类型入参为T对象，返回T对象
    block(this)
    //返回调用者本身
    return this
}

与let 类似，只是返回值有点差异。

// 不使用also
fun testAlso1(studentInfo: StudentInfo) {
    studentInfo?.isBoy = false
    studentInfo?.name = "小鱼人"
    studentInfo?.age = 14
}
// 使用also
fun testAlso2(studentInfo: StudentInfo) {
    var letRet = studentInfo?.also {
        it.isBoy = false
        it.name = "小鱼人"
        it.age = 14
        //Lambda结果未被使用
        "Fish"
    }
    println("alsoRet:${letRet.name}")
}

also 返回值为调用者本身，也就是studentInfo，因此我们可以继续使用studentInfo进行操作。

fun testAlso3(studentInfo: StudentInfo) {
    studentInfo?.also {
        it.isBoy = false
        it?.name = "小鱼人"
        it?.age = 14
        //Lambda结果作为let 返回值
        "Fish"
    }.let { 
        //继续调用
        it.score = 99f
    }
}

作用：
also 原理、作用与let 类似，因为其返回对象本身，因此可以用在链式调用的场景。

with

public inline fun <T, R> with(receiver: T, block: T.() -> R): R {
    //内联函数，带两个参数，一个是接收者，另一个函数类型
    //T.() 泛型T的扩展函数，函数无参数
    //返回接收者调用结果，也就是Lambda返回值
    return receiver.block()
}

可以理解为，给receiver增加了一个扩展函数block，并且执行了它。
需要注意的是：with 并不是扩展函数，因此无需使用对象访问它。
with 反编译结果：

public static final Object with(Object receiver, @NotNull Function1 block) {
    //传入接收者对象
    return block.invoke(receiver);
}

T.() 表示T的扩展函数，可以表示为：block:T.()->R，可以使用receiver.block() 访问，最终实现block的函数体(Lambda)里持有T的对象，因此内部可以使用this访问T的属性和函数。

// 不使用with
fun testWith1(studentInfo: StudentInfo) {
    studentInfo?.isBoy = false
    studentInfo?.name = "小鱼人"
    studentInfo?.age = 14
}
// 使用with
fun testWith2(studentInfo: StudentInfo) {
    var withRet = with(studentInfo) {
        isBoy = false
        name = "小鱼人"
        age = 14
        "Fish"
    }
    println("withRet:$withRet")
}

可以看出，使用with时只需要传入要操作的对象，而Lambda表达式里即可直接操作属性和函数。
with 本质上是通过扩展接收者函数，内部就可以访问属性和函数(隐藏了this)，通常用在需要多次书写对象调用的场景，比如ViewHolder 访问View。
with 有个弊端：
因为不是扩展函数，因此无法像let/also 一样在调用时通过"?"判空。

run

public inline fun <T, R> T.run(block: T.() -> R): R {
    //扩展函数，函数类型也扩展了T
    return block()
}

run与with 类似，同样的是扩展T.()，因此在block里能够访问属性和函数

// 不使用run
fun testRun1(studentInfo: StudentInfo) {
    studentInfo?.isBoy = false
    studentInfo?.name = "小鱼人"
    studentInfo?.age = 14
}
// 使用run
fun testRun2(studentInfo: StudentInfo) {
    var withRet = studentInfo?.run {
        isBoy = false
        name = "小鱼人"
        age = 14
        "Fish"
    }
    println("withRet:$withRet")
}

可以看出，run 比 with 多了可以判空的功能，并且比let 多了可以省略it访问的功能，因此：
run 结合了let 与 with 的功能，它俩能做的run 也能做。

apply

public inline fun <T> T.apply(block: T.() -> Unit): T {
    //扩展函数
    block()
    //返回调用者本身
    return this
}

和run 相似，只是apply 返回值为对象本身，并且block无返回值。

// 不使用apply
fun testApply1() {
    var studentInfo = StudentInfo()
    studentInfo.isBoy = false
    studentInfo.name = "小鱼人"
    studentInfo.age = 14
}
// 使用apply
fun testApply2() {
    var applyRet = StudentInfo().apply {
        isBoy = false
        name = "小鱼人"
        age = 14
        "Fish"
    }
    println("withRet:${applyRet.name}")
}

apply 返回对象本身，因此我们可以在Lambda里做一些初始化操作。
当Lambda 执行完毕后，返回的对象已经初始化完毕。
apply 多用于对象初始化过程以及链式调用。

repeat

public inline fun repeat(times: Int, action: (Int) -> Unit) {
    //循环调用action，传入参数为当前次数
    for (index in 0 until times) {
        action(index)
    }
}

repeat 不是扩展函数。

fun testRepeat2() {
    var list = mutableListOf<StudentInfo>()
    repeat(10) {
        //重复这个动作10次
        list.add(StudentInfo())
        println("第 $it 个")
    }
}

::

函数类型

我们讲高阶函数的时候，其实用过，如下面例子：

fun plus(num1: Int, num2: Int): Int {
    return num1 + num2
}
fun minus(num1: Int, num2: Int): Int {
    return num1 - num2
}
fun num1AndNum2(num1: Int, num2: Int, operation: (Int, Int) -> Int): Int {
    return operation(num1, num2)
}
fun main() {
    val num1 = 100
    val num2 = 80
    val result1 = num1AndNum2(num1, num2, ::plus)
    val result2 = num1AndNum2(num1, num2, ::minus)
    println("result1 is $result1")
    println("result2 is $result2")
}

表示将 plus() 和 minus() 函数作为参数传递给 num1AndNum2() 函数。
想把一个函数赋值给一个变量，也得使用::，如下所示：

var fun1 = ::plus
val result = fun1(10,20)// 30

加了两个冒号，这个函数才变成了一个对象。

• 在 Kotlin 里，一个函数名的左边加上双冒号，它就不表示这个函数本身了，而表示一个对象，或者说一个指向对象的引用，但，这个对象可不是函数本身，而是一个和这个函数具有相同功能的对象。
• 对象是不能加个括号来调用的，但是函数类型的对象可以。为什么？因为这其实是个假的调用，它是 Kotlin 的语法糖，实际上你对一个函数类型的对象加括号、加参数，它真正调用的是这个对象的 invoke() 函数。fun1(10,20)，实际上会调用 fun1.invoke(10,20)
• 函数不是对象，它也没有类型，函数就是函数，它和对象是两个维度的东西。双冒号加上函数名的这个写法，它是一个指向对象的引用，但并不是指向函数本身，而是指向一个我们在代码里看不见的对象。这个对象复制了原函数的功能，但它并不是原函数，并且这个对象包含了一个invoke的方法。

databinding

比如我定义了响应点击事件的函数：

//注意保持参数类型的一致
fun onClick(v: View) {
    ...
}

在 xml 中绑定该事件，以往我们的做法一般是：

<Button...onClick="@{(v) -> data.onClick(v)}"/>

使用 :: 来绑定可以更加简洁：

<Button...onClick="@{data::onClick}"/>

反射

直接使用泛型 T:: 即可反射获得其内部属性，如 class，constructor 等。

// kotlin
Student::class
// java
Student.class

reified

https://juejin.cn/post/6844903833596854279
https://www.jianshu.com/p/f64c8de76375

reified：使抽象的东西更加具体或真实，非常推荐 Android 开发使用这个关键字。
用关键字 inline 标记的函数就称为内联函数，再用 reified 关键字修饰内联函数中的泛型形参，编译器在进行编译的时候便会将内联函数的字节码插入到每一个调用的地方，当中就包括泛型的类型实参。而内联函数的类型形参能够被实化，就意味着我们可以在运行时引用实际的类型实参了。

不再需要传参数 clazz

大部分的文章讲解 reified 的使用，都有提到这个点，比如我们定义实现一个扩展函数启动 Activity，一般都需要传 Class 参数：

// Function
private fun <T : Activity> Activity.startActivity(context: Context, clazz: Class<T>) {
    startActivity(Intent(context, clazz))
}
// Caller
startActivity(context, NewActivity::class.java)

reified 方式

使用 reified，通过添加类型传递简化泛型参数

// Function
inline fun <reified T : Activity> Activity.startActivity(context: Context) {
    startActivity(Intent(context, T::class.java))
}
// Caller
startActivity<NewActivity>(context)

不安全的转换

Kotlin 中， 使用安全转换操作符 as?，它可以在失败时返回 null。实现如下函数，我们认为会安全地获取数据或返回 null

// Function
fun <T> Bundle.getDataOrNull(): T? {
    return getSerializable(DATA_KEY) as? T
}
// Caller
val bundle: Bundle? = Bundle()
bundle?.putSerializable(DATA_KEY, "Testing")
val strData: String? = bundle?.getDataOrNull()
val intData: Int? = bundle?.getDataOrNull() // Crash

然而，如果获得的数据不是它期望的类型，这个函数会出现 crash。 因此为了安全获取数据，修改之前的函数如下：

// Function
fun <T> Bundle.getDataOrNull(clazz: Class<T>): T? {
    val data = getSerializable(DATA_KEY)
    return if (clazz.isInstance(data)) {
        data as T
    } else {
        null
    }
}
// Caller
val bundle: Bundle? = Bundle()
bundle?.putSerializable(DATA_KEY, "Testing")
val strData: String? = bundle?.getDataOrNull(String::class.java)
val intData: Int? = bundle?.getDataOrNull(String::class.java) // Null

这种写法不太友好，不仅在实现函数的方式上，而且还需要传递额外的 clazz 参数。

reified 方式

使用 reified，简化泛型参数和保证 as? 类型转换安全性

// Function
private inline fun <reified T> Bundle.getDataOrNull(): T? {
    return getSerializable(DATA_KEY) as? T
}
// Caller
val bundle: Bundle? = Bundle()
bundle?.putSerializable(DATA_KEY, "Testing")
val strData: String? = bundle?.getDataOrNull()
val intData: Int? = bundle?.getDataOrNull() // Null

不同的返回类型函数重载

实现一个函数计算 DP 到像素，并返回一个 Int 或 Float。这种情况就会想到函数重载，如下所示：

fun Resources.dpToPx(value: Int): Float {
    return TypedValue.applyDimension(
        TypedValue.COMPLEX_UNIT_DIP,
        value.toFloat(), displayMetrics)
}
fun Resources.dpToPx(value: Int): Int {
    val floatValue: Float = dpToPx(value)
    return floatValue.toInt()
}

但是，这将导致编译时出错。原因是，函数重载方式只能根据参数计数和类型不同，而不能根据返回类型。

reified 方式

使用 reified，可以实现不同的返回类型函数重载

inline fun <reified T> Resources.dpToPx(value: Int): T {
    val result = TypedValue.applyDimension(
        TypedValue.COMPLEX_UNIT_DIP,
        value.toFloat(), displayMetrics)
    return when (T::class) {
        Float::class -> result as TInt::class -> result.toInt() as T
        else -> throw IllegalStateException("Type not supported")
    }
}
// Caller
val intValue: Int = resource.dpToPx(64)
val floatValue: Float = resource.dpToPx(64)

协程

https://juejin.cn/post/6908271959381901325
https://rengwuxian.com/kotlin-coroutines-2/
https://juejin.cn/post/6987724340775108622
Kotlin Jetpack 实战 | 09. 图解协程原理
Kotlin:玩转协程

查询用户信息 --> 查找该用户的好友列表 -->拿到好友列表后，查找该好友的动态

getUserInfo(new CallBack() {
    @Override
    public void onSuccess(String user) {
        if (user != null) {
            System.out.println(user);
            getFriendList(user, new CallBack() {
                @Override
                public void onSuccess(String friendList) {
                    if (friendList != null) {
                        System.out.println(friendList);
                        getFeedList(friendList, new CallBack() {
                            @Override
                            public void onSuccess(String feed) {
                                if (feed != null) {
                                    System.out.println(feed);
                                }
                            }
                        });
                    }
                }
            });
        }
    }
});

有点恶心了，是不是？这还是仅包含 onSuccess 的情况，实际情况会更复杂，因为我们还要处理异常，处理重试，处理线程调度，甚至还可能涉及多线程同步。
上面的代码用协程应该写？很简单，核心就是三行代码：

val user = getUserInfo()
val friendList = getFriendList(user)
val feedList = getFeedList(friendList)

是不是简洁到了极致？这就是 Kotlin 协程的魅力：以同步的方式完成异步任务。

https://blog.csdn.net/sange77/article/details/102536792

DSL

https://juejin.cn/post/6844903861610627079

retrofit

https://juejin.cn/post/6844904148521992205
https://juejin.cn/post/6844903861610610696

工具

Kotlin转Java

这个很重要，通过这个Android studio 自带的工具，我们可以轻松掌握 Kotlin 各种语法的本质。
[图片]
[图片]
[图片]

参考

https://developer.android.com/kotlin/learn?hl=zh-cn
https://juejin.cn/post/6880602489297895438
https://juejin.cn/post/6844904201353429006
https://juejin.cn/post/6844904184911757325
https://juejin.cn/post/6844904179505299469
https://juejin.cn/post/6844904038589267982
https://juejin.cn/post/6844903607817469966
https://segmentfault.com/a/1190000040402706
https://blog.csdn.net/wekajava/article/details/124917198
https://juejin.cn/post/6844903506420187149
https://rengwuxian.com/kotlin-lambda/
https://rengwuxian.com/kotlin-source-noinline-crossinline/
https://rengwuxian.com/kotlin-coroutines-2/