最近在学习kotlin，记录下自己学习过程中的笔记。因为内容比较多，所以分为几篇文章。那么第一篇主要是以下的内容：

转载地址：https://zhuanlan.zhihu.com/p/417635072
原作者：啥都不懂的小白

变量、常量和类型

声明变量

在Java中声明变量

int a = 1；

在kotlin中声明变量

var a : Int = 1

可以看出在kotlin中声明变量的格式：

var 变量名 : 类型定义 = 赋值

只读变量

除了使用var来声明变量，还可有使用val来声明变量。但这二者的作用是不同的，val是只读变量，使用了val来定义变量后，该变量是不能改变的。其有些类似于Java中的final，但也有不同之处，后面会讲到。

var a : Int = 1
a = 10                      //没问题
val b : Int = 1
b = 10            //报错

类型推断

对于已声明并赋值的变量，允许省略类型定义

var a : Int = 1 
var s : String = "Hello World"
//可以直接写成
var a = 1
var s = "Hello World"

编译时常量

编译时常量只能在函数之外声明，因为编译时常量必须在编译时赋值，而函数都是在运行时才调用，函数内的变量也是在运行时赋值，编译时常量要在这些变量赋值前就已存在。
编译时常量只能是基本的八种数据类型，Int、Double、Float、Long……

可以将Kotlin代码转换成Java的代码来查看

可以发现kotlin中const val MAX其实就等效于java中的final static

数据类型

在Java中有两种数据类型，除了八种基本数据类型，其余的都是引用类型
而在Kotlin中只有引用类型，出于更高性能的需要，Kotlin编译器会自动在Java字节码中改用基本数据类型

其实区别主要是装箱方面不同，拿整数类型的变量解释，java中我们定义一个整型变量可以通过int（基本类型）或者Integer（引用类型）来定义一个整数类型。

//java中
int a = 1;      
Integer b = 2;   //自动装箱

而在Kotlin中，只有Int（引用类型）来定义整数类型。

var a : Int = 10;

但是Kotlin编译器会根据性能需要自动判断是否对该变量进行装箱。

var a: Int = 1 // unbox
var b: Int? = 2 // box
var list: List<Int> = listOf(1, 2) // box

条件语句

if/else if 表达式（和Java一样）
range表达式
in A…B，in关键字用来检查某个值是否在指定范围之内

val money = 10
if(money in 0..5){
    println("cheap")
}else if(money in 5..10){
    println("mid")
}else{
    println("expensive")
}

输出:

mid

when表达式（其实就是java中的switch…case）

val money = 10
when (money) {
    in 0..5 -> {
        println("cheap")
    }
    in 5..10 -> {
        println("mid")
    }
    else -> {
        println("expensive")
    }
}

string模板

模板支持在字符串的引号内放入变量值
还支持字符串里计算表达式的值并插入结果
格式 $变量名 或 ${表达式}

fun main(){
    val a = 10
    println("value = $a")

    val flag = false
    println("答案是${if(flag) "正确的" else "错误的"}")
}

输出

value = 10
答案是错误的

函数

函数头

//格式
private fun 函数名(函数参数):返回类型 {}
fun main(){
    println("value = ${getValue(100)}")
}

private fun getValue(money:Int):String{
    var value = "";
    value = when (money) {
        in 0..5 -> {
            "cheap"
        }
        in 5..10 -> {
            "mid"
        }
        else -> {
            "expensive"
        }
    }
    return value
}

输出

value = expensive

函数参数

默认值参
如果不打算传入值参，可以预先给参数指定默认值

fun main(){
    //如果所调用的方法参数已经给了默认值，可以不传参数
    println("value = ${getValue()}")
}

//可以给参数设置默认值，若调用该方法不穿参数的话，就直接使用该默认值
private fun getValue(money:Int = 100):String{
    var value = "";
    value = when (money) {
        in 0..5 -> {
            "cheap"
        }
        in 5..10 -> {
            "mid"
        }
        else -> {
            "expensive"
        }
    }
    return value
}

具名函数参数
如果使用命名值参，就可以不用管值参的顺序（参数多的时候用起来方便）

fun main(){
    println("value = ${test(f = 20,d = 30,b = 100,a = "hhh",c = 1,e = 21)}")
}

private fun test(a:String,b:Int,c:Int,d:Int,e:Int,f:Int):String{
    return a;
}

输出：

value = hhh

Unit函数

Kotlin中没有返回值的函数叫Unit函数，类似Java中的void。

fun main(){
    getValue()
}

private fun getValue(money:Int = 100):Unit{
    when (money) {
        in 0..5 -> {
            println("cheap")
        }
        in 5..10 -> {
            println("mid")
        }
        else -> {
            println("expensive")
        }
    }
}

输出：

expensive

匿名函数

定义时不取名字的函数，匿名函数通常整体传递给其他函数，或者从其它函数返回。通过匿名函数，能够在Kotlin中根据需要给标准函数指定特殊规则。

fun main(){
    //统计字符个数
    val num1 = "HAHAHAHAHDDC".count()
    //统计字符串中`H`字符的个数
    val numH = "HAHAHAHAHDDC".count({ letter ->
        letter == 'H'
    })
    println("num1 = $num1，numH = $numH")
}

输出

num1 = 12，numH = 5

上面统计字符创中‘H’的个数中，count()就是标准函数，括号中的{变量->函数体}就是匿名函数，是我为count()这个标准函数定义的一个规则，让count()去统计字符串中‘H’的个数。

现在可能会看不太懂为什么这段代码可以这么写，下面会解释。

匿名函数类型与隐式返回

匿名函数也有类型，它可以当做变量进行赋值。

//格式
val 变量名:匿名函数  //变量类型是一个函数

例子：

fun main() {
   //变量a是一个函数类型，该函数无参，返回值为Int类型
    val a : () -> Int = {
        val b = 10
        val c = 20
        b + c
    }

    println(a())
}

和具名函数不一样，匿名函数一般不需要return关键字来返回数据，匿名函数会隐式或自动返回函数体最后一行语句的结果

这里抛出一个问题，正常来讲函数是不能赋值给变量的，如下面这个例子

fun main() {
    val a = add()  //这是函数调用，没有问题
    val fun = add   //这是将函数赋值给fun这个变量，编译会报错
}

fun add() : Int{
    val b = 10
    val c = 20
    return b + c
}

那为什么匿名函数可以赋值给变量呢？匿名函数难道不是「函数」吗？继续往下看就会懂了。

匿名函数参数

和具名函数一样，匿名函数可以不带参数，也可以带一个或多个任何类型的参数，需要带参数时，参数的类型放在匿名函数的类型定义中，参数名则放在函数定义中

fun main() {
    val a : (Int) -> Int = { num->
        num + 20
    }

    println(a(10))
}

输出

it关键字

定义只有一个参数的匿名函数时，可以使用it关键字来表示参数名。但是当传入两个或两个以上的参数时，it关键字就不能用了

fun main() {
    val a : (Int) -> Int = {
        it + 20
    }

    println(a(10))
}

输出

类型推断

匿名函数类型也存在类型推断，当定义一个变量时，如果已把匿名函数作为变量赋值给它时，就不需要显示指明变量类型了

fun main() {
    /*val a : () -> Int = {
        val b = 10        val c = 20        b + c    }*/
    //上面注释这段代码等效下面这段
    val a  = {
        val b = 10
        val c = 20
        b + c
    }

    println(a())
}

输出

类型推断也支持带参数的匿名函数，但为了帮助编译器更准确地推断变量类型，匿名函数的参数名和参数类型必须要写

fun main() {
    /*val a : (Int,Int) -> Int = {a,b ->
        a + b    }*/
   //上面注释这段代码等效下面这段
    val a  = {a:Int,b:Int ->
        a + b
    }

    println(a(10,20))
}

输出

lambda

如果你学过Java，有没有发现上面Kotlin的匿名函数写法似曾相识，很像Java中的Lambda表达式。其实Kotlin中我们也将匿名函数称为lambda，将它定义为lambda表达式。

那Java和Kotlin的lambda有什么区别呢。刚刚上面也说了，在kotlin中，函数是可以作为变量的类型，也就是说函数是可以作为函数的参数来用的（有点绕口，后面详细讲下就明白了）。Java中我们是不能直接传递一个函数/方法的，当然借助接口可以实现类似的效果，但kotlin中直接支持传递函数无疑是方便了许多。

定义参数是函数的函数

在kotlin中支持函数的参数是另外一个函数，也就是说可以调用一个函数其参数可以是另外一个函数。

fun main() {
    //定义一个函数类型的变量
    val calStudentAge = {birYear:Int,year:Int ->
        year - birYear
    }
    //传入的最后一个参数就是我们上面定义的函数类型变量
    showStudentMsg("barry",2001,2021,calStudentAge)

}

//该函数的最后一个参数是一个名为getStudentAge的函数
fun showStudentMsg(name:String,birYear:Int,year:Int,getStudentAge : (Int,Int)->Int){
    println("${name}同学${birYear}年出生，现在是${year}年")
    println("所以${name}同学今年${getStudentAge(birYear,year)}岁了")
}

输出

barry同学2001年出生，现在是2021年
所以barry同学今年20岁了

简略写法

如果一个函数的lambda参数排在最后，或是唯一的参数，那么lambda参数的圆括号可以省略。

上面的调用showStudenMsg代码我可以直接这样改写

showStudentMsg("barry",2001,2021,{birYear:Int,year:Int ->
    year - birYear
})

此时我们的idea就会有以下的提示：

Lambda argument should be moved out of parentheses

也就是提示我们应将 Lambda 参数移出括号，因为此时就符合lambda参数排在最后的条件，所以正确的写法应该是：

showStudentMsg("barry",2001,2021) { birYear: Int, year: Int ->
    year - birYear
}

我们在看回匿名函数这节中最开始的那个例子

val numH = "HAHAHAHAHDDC".count({ letter ->
    letter == 'H'
})

现在可以理解为什么可以这么去写这段代码了吧，这是因为count这个函数参数支持我们传递一个函数。看下count函数的源码：

public inline fun CharSequence.count(predicate: (Char) -> Boolean): Int {
    var count = 0
    for (element in this) if (predicate(element)) ++count
    return count
}

通过源码可以看到count函数中的参数，是一个返回类型为Boolean，传递参数为Char类型，名字为predicate的函数。我把上面的调用改写一下可能会更好理解

val predicate = { letter:Char ->
    letter == 'H'
}

val numH = "HAHAHAHAHDDC".count(predicate)

首先定义一个类型为函数的变量predicate，然后调用count时传入这个predicate变量，count函数就会通过我们这个匿名函数，对字符串进行遍历，如果element == ‘H’，那么count就+1。

上面的调用还可以简写，刚刚说了如果匿名函数中只有一个参数，那么可以用it代替

val predicate = {
    it == 'H'
}
val numH = "HAHAHAHAHDDC".count(predicate)

并且count函数也符合lambda参数是唯一参数，所以可以写成

val numH = "HAHAHAHAHDDC".count{
    it == 'H'
}

函数内联

我们在使用lambda表达式时，它会被正常地编译成一个匿名类。说明每调用一次lambda表达式，一个额外的类就会被创建，并且如果lambda捕捉了某个变量，那么每次调用的时候都会创建一个新的对象，这会带来运行时的额外开销，导致使用lambda比使用一个直接执行相同代码的函数效率更低。

所以kotlin中提供了一种优化机制——内联（inline），有了内联，JVM就不需要使用lambda对象实例了。如果使用inline修饰符标记一个函数，在函数被调用的时候编译器并不会生成函数调用的代码，而是 使用函数实现的真实代码替换每一次的函数调用。

可以来看下使用内联和不使用内联的字节码

未使用内联：

fun main() {
    showStudentMsg("barry",2001,2021) { birYear: Int, year: Int ->
        year - birYear
    }
}

fun showStudentMsg(name:String,birYear:Int,year:Int,getStudentAge : (Int,Int)->Int){
    println("${name}同学${birYear}年出生，现在是${year}年")
    println("所以${name}同学今年${getStudentAge(birYear,year)}岁了")
}

可以main函数里看到未使用内联的是会直接调用showStudentMsg这个函数，调用后会产生一个Function2类的对象getStudentAge，然后通过invoke方法来执行，这会增加额外的生成类和函数调用开销。

使用内联：

现在方法前加上inline修饰符

fun main() {
    showStudentMsg("barry",2001,2021) { birYear: Int, year: Int ->
        year - birYear
    }
}

inline fun showStudentMsg(name:String,birYear:Int,year:Int,getStudentAge : (Int,Int)->Int){
    println("${name}同学${birYear}年出生，现在是${year}年")
    println("所以${name}同学今年${getStudentAge(birYear,year)}岁了")
}

使用了inline修饰后，也就是showStudentMsg成为了内联函数，那么此时我们再看main函数中，这时就不会再去调用showStudentMsg这个函数了，而是直接将showStudentMsg函数中的代码粘贴到了相应调用的位置。就等于是直接用函数的真实代码替换了函数调用，节省了额外的生成类和函数调用开销。

当然内联函数不是万能的，以下情况避免使用内联函数：

像上面使用内联后，会发现字节码数量相比没有内联是大大增多。所以尽量避免对具有大量函数体的函数进行内联，这样会导致过多的字节码数量。
由于JVM对普通函数已经能够根据实际情况智能地判断是否进行内联优化，所以并不需要对其使用Kotlin的inline语法，那只会让字节码变得更加复杂。
使用lambda的递归函数无法内联，因为会导致真实代码复制替换无限循环

在上面的字节码中，我们可以看到showStudent这个函数中最后一个参数是一个Function类的引用，那就说明传递的参数是一个对象。可是我们在kotlin代码里面传递不是一个匿名函数吗，不应该是一个「函数」吗？下面就开始解密了

函数引用

调用带参数类型是函数的函数，除了传lambda表达式，kotlin还提供了其他方法，传递函数引用，函数引用可以把一个具名函数转换成一个值参，使用lambda表达式的地方，都可以使用函数引用。

fun main() {
    //通过::将具名函数转换成一个对象进行传递
    showStudentMsg("barry",2001,2021,::calStudentAge)
}

//将上面的匿名函数改造成一个具名函数
private fun calStudentAge(birYear:Int,year:Int) : Int{
    return year - birYear
}

private fun showStudentMsg(name:String,birYear:Int,year:Int,getStudentAge : (Int,Int)->Int){
    println("${name}同学${birYear}年出生，现在是${year}年")
    println("所以${name}同学今年${getStudentAge(birYear,year)}岁了")
}

kotlin中函数可以作为参数进行传递，实际上传递还是一个对象。也就是说函数在Kotlin 里可以作为对象存在。那我们如何让具名函数变成一个对象呢，其实就是通过::来实现的。只有在函数名前加上两个冒号，该函数才能变成一个对象进行传递。

在 Kotlin 里，一个函数名的前面加上两个冒号，它就不表示这个函数本身了，而表示一个对象，或者说一个指向对象的引用。

我们现在可以回到上面的一个问题，**为什么匿名函数可以赋值给变量，而正常函数不可以呢？**其实根据上面的讲述，大概也知道为什么了吧，现在我把之前的赋值代码换一下

fun main() {
    val a = add()  //这是函数调用，没有问题
    //val fun = add   //这是将函数赋值给fun这个变量，编译会报错
    val fun = ::add   //这是将一个函数类型的对象赋值给fun这个变量，没有问题
}

fun add() : Int{
    val b = 10
    val c = 20
    return b + c
}

匿名函数/lambda 可以赋值给变量或者作为参数进行传递，是因为kotlin中匿名函数其实不是真正意义上的「函数」，而是一个对象，一个函数类型的对象。它和加了::的具名函数是一个东西。

所以java中的lambda和kotlin中的lambda最大的区别就是，java中的lambda只是写法更加便捷，但并没有什么实质的变化。而kotlin中的lambda是实实在在的对象。

函数类型作为返回类型

既然kotlin中函数可以转变为一个对象，那么函数同样可以作为一个函数的返回类型

fun main() {
    val studentMsg = getStudentMsg()
    print(studentMsg("barry"))
}

//返回类型为函数的函数
fun getStudentMsg() : (String) -> String{
    //返回匿名函数，也就是返回一个函数类型的对象
    return {name:String->
        val age = 20
        "${name}同学今年${age}岁了"
    }
}

在main函数中，通过getStudentMsg()获取到一个类型为函数的对象，然后这个studentMsg("barry")这个操作其实是kotlin的一个语法糖，它等效于下面的代码：

studentMsg.invoke("barry")

所以这个studentMsg其实就是一个引用类型，指向了getStudentMsg()这个类型为函数的对象。

闭包

在kotlin中，匿名函数能修改并引用定义在自己的作用域之外的变量。匿名函数引用着定义自身的函数里的变量，一个函数引用着另一个函数声明的变量，这其实就是闭包。

像上面的代码可以改写成这样：

fun main() {
    val studentMsg = getStudentMsg()
    print(studentMsg("barry"))
}

//返回类型为函数的函数
fun getStudentMsg() : (String) -> String{
    //age变量是在getStudentMsg()函数里定义的
    val age = 20
    //返回匿名函数，也就是返回一个函数类型的对象
    return {name:String->
        //在匿名函数里我们引用了getStudentMsg()函数里的age变量
        "${name}同学今年${age}岁了"
    }
}

上面return后面跟着的{ ... }就是一个闭包

什么是闭包？

我们知道，变量分为全局变量和局部变量，全局变量，顾名思义，其作用域是当前文件甚至文件外的所有地方；而局部变量只能在其有限的作用域里获取。

那么，如何在外部调用局部变量呢？就是通过闭包，闭包就是能够读取其他函数内部变量的函数。

那kotlin中使用闭包的意义在哪呢，为什么在Java中好像没怎么听过闭包这个概念？

Java其实也是有闭包的，一般会在匿名内部类才能体现出来，但Java中的闭包是一种有“残缺”的闭包，为什么这么说，可以看下下面这篇文章。

在上面编写kotlin代码中，可以发现和编写Java代码时有些不同。在Java中，我们在编写代码时，必须要有包（Package）和类（Class），就比如一个简单地输出Hello World，在Java中：

public class HelloWorld {
    public static void main(String[] args) {
        System.out.println("Hello World");
    }
}

而在kotlin中：

fun main(){
    println("Hello World")
}

那么Java中有包和类这两个东西，它会给我们带来作用域上的保护。我先拿kotlin举一个例子，比如我现在创建两个kotlin文件，然后在两个文件中都定义一个方法test，这是它就会报错

当然是用private修饰的话可以解决，但在Java中我创建两个Java文件，同样在两个文件中都定义一个方法test并用public进行修饰，是不会报错的。这是因为这两个Java文件虽然在同一个包下，但它们是不同的类，所以并不会影响。

Kotlin中也含有类，但Kotlin也有脚本语言的特性，所以它可以让我们不用使用类也能进行函数的使用，所以一旦使用到了脚本语言的特性，就可能会出现作用域的问题，同名变量或者函数就会产生冲突。所以kotlin中的闭包就是用来解决作用域这问题的。

lambda与匿名内部类

刚刚在上面也有提到一嘴，java中也有方法实现kotlin中传递函数这种类似的效果，通过接口来实现。现在我们用Java代码来复现一下

public class Test {

    public interface StudentAge{
        int getStudentAge(int birYear,int year);
    }

    public static void showStudentAge(String name,int birYear,int year,StudentAge studentAge){
        System.out.println(name + "同学" + birYear + "年出生，现在是" + year + "年");
        System.out.println("所以" + name + "同学今年" + studentAge.getStudentAge(birYear,year) + "岁了");
    }

    public static void main(String[] args) {
        showStudentAge("barry", 2001, 2021, new StudentAge() {
            @Override
            public int getStudentAge(int birYear, int year) {
                return year - birYear;
            }
        });
    }
}

上面在main函数中传递的最后一个参数就是一个匿名内部类，当然用java中的lambda表达式可以进一步的简化代码，如下

showStudentAge("barry", 2001, 2021, (birYear, year) -> year - birYear);

但java里面的lambda只是简化了书写，并没实质的改变，并不像kotlin中是可以实现一个函数类型的对象，在Java中必须借助接口才能实现kotlin中直接传递函数的效果。所以kotlin中的lambda还是要更加方便的。

本文转自 https://zhuanlan.zhihu.com/p/417635072，如有侵权，请联系删除。

在这里为了方便大家系统的学习Kotlin，这里特意联合了阿里P7架构师和谷歌技术团队共同整理了一份Kotlin全家桶学习资料，完整资料扫描下方二维码。

Kotlin入门教程指南，全家桶学习资料（含高级Kotlin强化和Kotlin协程入门进阶实战）

Kotlin 是一种新型的静态类型编程语言，有超过 60% 的专业 Android 开发者在使用，它有助于提高工作效率、开发者满意度和代码安全性。不仅可以减少常见代码错误，还可以轻松集成到现有应用中。

内容概要：Kotlin 入门教程指南、高级Kotlin强化实战和史上最详Android版kotlin协程入门进阶实战。

内容特点：条理清晰，含图像化表示更加易懂。

由于文章内容比较多，篇幅有限，资料已经被整理成了PDF文档，有需要 Android中高级面试必知必会完整文档的可扫描下方免费获取！

《Kotlin入门教程指南》

第一章 Kotlin 入门教程指南

● 前言

第二章概述

● 使用 Kotlin 进行服务器端开发

● 使用 Kotlin 进行 Android 开发

● Kotlin JavaScript 概述

● Kotlin/Native 用于原生开发

● 用于异步编程等场景的协程

● Kotlin 1.1 的新特性

● Kotlin 1.2 的新特性

● Kotlin 1.3 的新特性

第三章开始

● 基本语法

● 习惯用法

● 编码规范

第四章基础

● 基本类型

● 包

● 控制流：if、when、for、while

● 返回和跳转

第五章类与对象

● 类与继承

● 属性与字段

● 接口

● 可见性修饰符

● 扩展

● 数据类

● 密封类

● 泛型

● 嵌套类与内部类

● 枚举类

● 对象表达式与对象声明

● Inline classes

● 委托

委托属性

第六章函数与 Lambda 表达式

● 函数

● 高阶函数与 lambda 表达式

● 内联函数

第七章其他

● 解构声明

● 集合：List、Set、Map

● 区间

● 类型的检查与转换“is”与“as”

● This 表达式

● 相等性

● 操作符重载

● 空安全

● 异常

● 注解

● 反射

● 类型安全的构建器

● 类型别名

● 多平台程序设计

● 关键字与操作符

第八章 Java 互操作与 JavaScript

● 在 Kotlin 中调用 Java 代码

● Java 中调用 Kotlin

● JavaScript 动态类型

● Kotlin 中调用 JavaScript

● JavaScript 中调用 Kotlin

● JavaScript 模块

● JavaScript 反射

● JavaScript DCE

第九章协程

● 协程基础

● 取消与超时

● 通道 (实验性的)

● 组合挂起函数

● 协程上下文与调度器

● 异常处理

● select 表达式（实验性的）

● 共享的可变状态与并发

第十章工具

● 编写 Kotlin 代码文档

● Kotlin 注解处理

● 使用 Gradle

● 使用 Maven

● 使用 Ant

● Kotlin 与 OSGi

● 编译器插件

● 不同组件的稳定性

第十一章常见问题总结

● FAQ

● 与 Java 语言比较

● 与 Scala 比较【官方已删除】

《高级Kotlin强化实战》

第一章 Kotlin 入门教程

● Kotlin 概述

● Kotlin 与 Java 比较

● 巧用 Android Studio

● 认识 Kotlin 基本类型

● 走进 Kotlin 的数组

● 走进 Kotlin 的集合

● 完整代码

● 基础语法

第二章 Kotlin 实战避坑指南

● 方法入参是常量，不可修改

● 不要 Companion、INSTANCE？

● Java 重载，在 Kotlin 中怎么巧妙过渡一下？

● Kotlin 中的判空姿势

● Kotlin 复写 Java 父类中的方法

● Kotlin “狠”起来，连TODO都不放过！

● is、as` 中的坑

● Kotlin 中的 Property 的理解

● also 关键字

● takeIf 关键字

● 单例模式的写法

第三章项目实战《Kotlin Jetpack 实战》

● 从一个膜拜大神的 Demo 开始

● Kotlin 写 Gradle 脚本是一种什么体验？

● Kotlin 编程的三重境界

● Kotlin 高阶函数

● Kotlin 泛型

● Kotlin 扩展

● Kotlin 委托

● 协程“不为人知”的调试技巧

● 图解协程：suspend

《史上最详Android版kotlin协程入门进阶实战》

第一章 Kotlin协程的基础介绍

● 协程是什么

● 什么是Job 、Deferred 、协程作用域

● Kotlin协程的基础用法

[外链图片转存失败,源站可能有防盗链机制,建议将图片保存下来直接上传(img-g14uGeVh-1678177930493)(https://docimg1.docs.qq.com/image/ME6Ygm_vFgAkpKvYo-TGIg.png?w=567&h=303)]

第二章 kotlin协程的关键知识点初步讲解

● 协程调度器

● 协程上下文

● 协程启动模式

● 协程作用域

● 挂起函数

第三章 kotlin协程的异常处理

● 协程异常的产生流程

● 协程的异常处理

第四章 kotlin协程在Android中的基础应用

● Android使用kotlin协程

● 在Activity与Framgent中使用协程

● ViewModel中使用协程

● 其他环境下使用协程

第五章 kotlin协程的网络请求封装

● 协程的常用环境

● 协程在网络请求下的封装及使用

● 高阶函数方式

● 多状态函数返回值方式

第六章深入kotlin协程原理（一）

● suspend的花花肠子

● 藏在身后的-Continuation

● 村里的希望-SuspendLambda

第七章深入kotlin协程原理（二）

● 协程的那些小秘密

● 协程的创建过程

● 协程的挂起与恢复

● 协程的执行与状态机

第八章 Kotlin Jetpack 实战

● 从一个膜拜大神的 Demo 开始

● Kotlin 写 Gradle 脚本是一种什么体验？

● Kotlin 编程的三重境界

● Kotlin 高阶函数

● Kotlin 泛型

● Kotlin 扩展

● Kotlin 委托

● 协程“不为人知”的调试技巧

● 图解协程原理

第九章 Kotlin + 协程 + Retrofit + MVVM优雅的实现网络请求

● 项目配置

● 实现思路

● 协程实现

● 协程 + ViewModel + LiveData实现

● 后续优化

● 异常处理

● 更新Retrofit 2.6.0

由于文章内容比较多，篇幅有限，资料已经被整理成了PDF文档，有需要 Android中高级面试必知必会完整文档的可以扫描二维码获取）

更有更多资料，加微信免费领取

轻轻松松Kotlin快速入门（一）

变量、常量和类型

声明变量

只读变量

类型推断

编译时常量

数据类型

条件语句

string模板

函数

函数头

函数参数

Unit函数

匿名函数

匿名函数类型与隐式返回

匿名函数参数

it关键字

类型推断

lambda

定义参数是函数的函数

简略写法

函数内联

函数引用

函数类型作为返回类型

闭包

lambda与匿名内部类

Kotlin入门教程指南，全家桶学习资料（含高级Kotlin强化和Kotlin协程入门进阶实战）

《Kotlin入门教程指南》

第一章 Kotlin 入门教程指南

第二章 概述

第三章 开始

第四章 基础

第五章 类与对象

第六章 函数与 Lambda 表达式

第七章 其他

第八章 Java 互操作与 JavaScript

第九章 协程

第十章 工具

第十一章 常见问题总结

《高级Kotlin强化实战 》

第一章 Kotlin 入门教程

第二章 Kotlin 实战避坑指南

第三章 项目实战《Kotlin Jetpack 实战》

《史上最详Android版kotlin协程入门进阶实战 》

第一章 Kotlin协程的基础介绍

第二章 kotlin协程的关键知识点初步讲解

第三章 kotlin协程的异常处理

第四章 kotlin协程在Android中的基础应用

第五章 kotlin协程的网络请求封装

第六章 深入kotlin协程原理（一）

第七章 深入kotlin协程原理（二）

第八章 Kotlin Jetpack 实战

第九章 Kotlin + 协程 + Retrofit + MVVM优雅的实现网络请求

猜你喜欢

第二章概述

第三章开始

第四章基础

第五章类与对象

第六章函数与 Lambda 表达式

第七章其他

第九章协程

第十章工具

第十一章常见问题总结

《高级Kotlin强化实战》

第三章项目实战《Kotlin Jetpack 实战》

《史上最详Android版kotlin协程入门进阶实战》

第六章深入kotlin协程原理（一）

第七章深入kotlin协程原理（二）