Kotlin基础语法 | 青训营笔记

Kotlin要点

这是我参与「第四届青训营 」笔记创作活动的第1天

变量类型

变量：val为不可变变量，var为可变变量

函数

函数：fun 函数名(变量名: 变量类型 (可以加＝赋初值，在构建函数时赋值的变量可以不必传参), 变量名: 变量类型...)(: 返回值)可不加

{

执行逻辑....

}

fun methodName(param1: Int = 0,param2: Int): Int{
    return param2
}
fun methodName(param1: Int = 0,param2: Int) = param2 //可简化为这样子
//调用函数时
val number = methodName(456,123)
val number = methodName(param2 = 123) //可以不必传入param1，param1将为默认值
val number = methodName(param2 = 123,param1 = 456) //如果有前面的变量名，即使顺序颠倒也无所谓

if

if语句：if语句和java差不多，但是本身具有返回值，返回值是if语句每一个条件中最后一行代码的返回值

fun largerNumber(num1: Int,num2: Int) = if(num1 > num2) num1 else num2

when

when语句：when语句允许传入任意类型的参数并进行匹配执行相应的逻辑

fun getScore(name: String) = when(name){
    name.startsWith("Tom") -> 86 //如果这个字符串以Tom开头，则返回值均为86
    "Jim" -> 77
    else -> 0
}
//还可以进行类型匹配
fun checkNumber(num: Number){  //Number是一个与数字相关的抽象类，Int等都是它的子类
    when (num){
        is Int -> println("number is Int")
        ....
    }
}

for

for循环：

for (i in 0..10) //表示为0到10的闭区间
for (i in 0 until 10) //表示0到9的闭区间
for (i in 0..10 step 2)  //表示0到10的闭区间并每次增2
for (i in 10 downTo 1)  //表示从10到1的闭区间降序

继承

继承：默认的类无法被继承，必须加open关键字

open class Person{
    ...
}
// 继承
class Student : Person(){
    ...
}

构造函数

open class Person(val name: String,val age: Int){
    ...
}
​
class Stuent(val sno: String, val grade: Int，name: String age: Int) : Person(name,age){  //在创建对象时必须传入要求的参数,包括父类要求传的参数，但是父类的参数不需要加val或者var
    init{  //在主构造函数执行时，将会init 结构体中的代码
        ....
    }
    constructor(name: String,age: Int) : this("",0,name,age){  //所有的次构造函数都必须调用主构造函数
    }
    constructor() : this("",0){} //这个构造函数通过调用上一个次构造函数进行构造
}
//范例
val student = Student("123",5,"Jack",19)
​
//如果一个类只有次构造函数，没有主构造函数，次构造函数只能调用父类的构造函数
class Stuent: Person{
    constructor(name: String,age: Int) : super(name,age){ 
    }
}

接口

interface Study{
    fun readBooks(){...}
}
​
//调用
class Student(val sno: String, val grade: Int) : Study{
    override fun readBooks(){  //如果接口对应的函数没有执行逻辑就必须要重写，没有重写就默认调用接口的
        ...
    }
}

修饰符

修饰符：public 所有类可见（默认）

private 当前类可见

protected 当前类和子类可见

internal 同一模块的类中可见

数据类：如果两个对象中的数据相同，如cellphone1与cellphone2里的数据一样，则两个对象==时返回为 true，如果没有定义数据类得到的结果为false

data class Cellophone(val brand: String,val price: Double)  //创建数据类

单例类：全局中最多拥有一个实例，避免创建重复的对象

object Singleton{
    fun ...
}

//调用
Singleton.函数名()

集合

val list = listOf("Apple","Banana","Orange","Pear")  //初始化不可变集合
val list = mutableListOf("Apple","Banana","Orange","Pear")  //初始化可变集合
for (fruit in list){...}  //遍历集合并执行相应逻辑

val map = mutableMapOf(1 to "Apple",2 to "Banana",3 to "Orange",4 to "Pear")  //初始化可变Map
for ((number,fruit) in map){...} //遍历map

Lambda表达式

语法结构

{参数名1： 参数类型，参数名2： 参数类型 -> 函数体}
val maxLengthFruit = list.maxBy({ fruit: String -> fruit.length })
//化简规则
//当Lambda参数是函数的最后一个参数时，可以将Lambda表达式移到函数括号外面
val maxLengthFruit = list.maxBy() { fruit: String -> fruit.length }
//如果Lambda参数是函数的唯一一个参数的话，可以将函数的括号省略
val maxLengthFruit = list.maxBy { fruit: String -> fruit.length }
//由于类型推导机制，Lambda表达式中的参数列表大多数情况下不需要写参数类型
val maxLengthFruit = list.maxBy { fruit -> fruit.length }
//Lambda表达式的参数列表如果只有一个参数，不必声明参数名，用it关键字代替
val maxLengthFruit = list.maxBy { it.length }

集合函数API

map

val list = listOf("Apple","Banana","Orange","Pear")
val UpperCaseList = list.map { it.toUpperCase }  //map API可以将集合中的每个元素都映射成另一个值类似数学中x与y对应关系，例子中将集合中的字符全部改成大写

filter

val newList = list.filter { it.length <= 5 }  //filter API可以以某种规则过滤集合里面的参数并形成一个新集合，例子中将list长度≤5的字符放到新集合中



//调用Java方法也可以实现API，但是接口中只有一个待实现的方法时可以使用，例如
Thread{
    ....
}.start()

button.setOnClickListener{
    ....
}

any

val anyResult = list.any { it.length <= 5 }  //any API可以判断集合中是否存在满足的参数，返回真，假

all

val allResult = list.all { it.length <= 5 }  //all API可以判断集合中是否全部元素符合条件，返回真假

with

val result = with(StringBuilder()) {  //with把StringBuilder对象传到Lambda表达式内使用
 	append("Start eating fruits.\n")
 	for (fruit in list) {
 		append(fruit).append("\n")
 		}
 	append("Ate all fruits.")
 	toString()
}

run

val result = StringBuilder().run {  //和with差不多，就改一点点格式
 	append("Start eating fruits.\n")
 	for (fruit in list) {
    	append(fruit).append("\n")
 	}
 	append("Ate all fruits.")
 	toString()
}

apply

val result = StringBuilder().apply {  //apply只能返回StringBuilder对象，没办法返回值
 	append("Start eating fruits.\n")
 	for (fruit in list) {
 		append(fruit).append("\n")
 	}
 	append("Ate all fruits.")
}

空指针

空指针检查：Kotlin默认所有的参数和变量都不可为空，在类型后加？表示该类型可空

val a: Int?
val study: Study?

//判空操作符 ?.   当参数为空时不执行
fun doStudy(study: Study?){
    study?.readBooks()
    study?.doHomework()
}

//判空分支符 ?:
val c = a ?: b   //当a不为空时执行a否则为b

//非空断言符 !!  使用!!，即使编译器报空指针错误也可以通过，但建议最好不用

//let函数
study?.let{  //let函数可以将study对象当作参数传入到Lambda表达式中并且使用
    it.readBooks()
    it.doHomework()
}

字符串内嵌表达式

语法规则

"hello, ${obj.name}. nice to meet you!"

//如果仅有一个变量可以将大括号舍去
"hello, $name. nice to meet you!"

//例子
"brand = $brand , price = $price"

定义静态方法

object，缺点：会将整个类都变成类似静态方法的调用方式

object Util {
 	fun doAction() {
 		println("do action")
 	}
}

companion object，可以只定义某个方法为静态方法，但以上两种都不算真的静态方法

class Util {
 	fun doAction1() {
 		println("do action1")
 	}
 	companion object {
 		fun doAction2() {
 			println("do action2")
 		}
 	}
}

注解，不常用

class Util {
 	fun doAction1() {
 		println("do action1")
 	}
 	companion object {
 		@JvmStatic
 		fun doAction2() {
 			println("do action2")
     	}
 	}
}

顶层方法，在里面写的所有方法都是静态方法，创建一个类型为File的Kotlin的文件

fun doSomething() {
 	println("do something")
}

//在Kotlin中调用
doSomething()
//在Java中调用
文件名Kt.doSomething()

延迟初始化

在定义和使用全局变量时，尽管你保证onCreate方法会在onClick方法之前调用但是还是得加判空判断符

class MainActivity : AppCompatActivity(), View.OnClickListener {
 	private var adapter: MsgAdapter? = null
 	override fun onCreate(savedInstanceState: Bundle?) {
 		...
 		adapter = MsgAdapter(msgList)
 		...
 	}
 	override fun onClick(v: View?) {
 		...
 		adapter?.notifyItemInserted(msgList.size - 1)
 		...
 	}
}

延迟初始化使用的是lateinit关键字，它可以告诉Kotlin编译器，我会在晚些时候对这个变量进行初始化，这样就不用在一开始的时候将它赋值为null了。

class MainActivity : AppCompatActivity(), View.OnClickListener {
 	private lateinit var adapter: MsgAdapter
 	override fun onCreate(savedInstanceState: Bundle?) {
 		...
 		adapter = MsgAdapter(msgList)
 		...
 	}
 	override fun onClick(v: View?) {
 		...
 		adapter.notifyItemInserted(msgList.size - 1)
 		...
 	}
}

另外，还可以通过代码来判断一个全局变量是否已经完成了初始化，这样在某些时候能够有效地避免重复对某一个变量进行初始化操作

	if (!::adapter.isInitialized) {
 		adapter = MsgAdapter(msgList)
 	}

密封类

密封类的关键字是sealed class，新建一个kotlin文件，密封类中包含着所有的分支类

sealed class MsgViewHolder(view: View) : RecyclerView.ViewHolder(view)

class LeftViewHolder(view: View) : MsgViewHolder(view) {
 	val leftMsg: TextView = view.findViewById(R.id.leftMsg)
}

class RightViewHolder(view: View) : MsgViewHolder(view) {
 	val rightMsg: TextView = view.findViewById(R.id.rightMsg)
}

class MsgAdapter(val msgList: List<Msg>) : RecyclerView.Adapter<MsgViewHolder>() {
 	...
 	override fun onBindViewHolder(holder: MsgViewHolder, position: Int) {
 		val msg = msgList[position]
 		when (holder) {
 			is LeftViewHolder -> holder.leftMsg.text = msg.content
 			is RightViewHolder -> holder.rightMsg.text = msg.content
 		}
 	}
 	...
}

扩展函数

相比于定义一个普通的函数，定义扩展函数只需要在函数名的前面加上一个ClassName.的语法结构，就表示将该函数添加到指定类当中了。

语法结构

fun ClassName.methodName(param1: Int, param2: Int): Int {
 	return 0
}

假如想在String类中添加一个扩展函数用来统计字符串内的字母数量，因此需要先创建一个String.kt文件，并编写如下代码

fun String.lettersCount(): Int {
 	var count = 0
    //现在我们将lettersCount()方法定义成了String类的扩展函数，那么函数中就自动拥有了String实例的上下文。因此				lettersCount()函数就不再需要接收一个字符串参数了，而是直接遍历this即可，因为现在this就代表着字符串本身。
 	for (char in this) {
 		if (char.isLetter()) {
 			count++
 		}
 	}
 	return count
}

Kotlin中的String甚至还有reverse()函数用于反转字符串，capitalize()函数用于对首字母进行大写，等等，这都是Kotlin语言自带的一些扩展函数。

运算符重载

创建一个Money类，重载 “+” 号

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

调用

val money1 = Money(5)
val money2 = Money(10)
val money3 = money1 + money2 //15
val money4 = money3 + 20  //35

高阶函数

定义：如果一个函数接收另一个函数作为参数，或者返回值的类型是另一个函数，那么该函数就称为高阶函数。

例子

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

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

Lambda表达式写法

fun main() {
 val num1 = 100
 val num2 = 80
 	val result1 = num1AndNum2(num1, num2) { n1, n2 -> n1 + n2 }
 	val result2 = num1AndNum2(num1, num2) { n1, n2 -> n1 - n2 }
 	println("result1 is $result1")
 	println("result2 is $result2")
}

高阶函数加扩展函数

fun StringBuilder.build(block: StringBuilder.() -> Unit): StringBuilder {
 	block()
 	return this
}

fun main() {
 	val list = listOf("Apple", "Banana", "Orange", "Pear", "Grape")
 	val result = StringBuilder().build {
 		append("Start eating fruits.\n")
 		for (fruit in list) {
 			append(fruit).append("\n")
 		}
 		append("Ate all fruits.")
 	}
 	println(result.toString())
}	

高阶函数转译的字节码

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;
 		}
 	});
}

注意：之前的Lambda表达式在这里变成了Function接口的匿名类实现，然后在invoke()函数中实现了n1 + n2的逻辑，并将结果返回。我们每调用一次Lambda表达式，都会创建一个新的匿名类实例，当然也会造成额外的内存和性能开销。

高阶函数的的进阶运用

SharedPreferences原来的基本用法

val editor = getSharedPreferences("data", Context.MODE_PRIVATE).edit()
editor.putString("name", "Tom")
editor.putInt("age", 28)
editor.putBoolean("married", false)
editor.apply()

val values = ContentValues()
values.put("name", "Game of Thrones")
values.put("author", "George Martin")
values.put("pages", 720)
values.put("price", 20.85)
db.insert("Book", null, values)

进阶运用

//扩展函数
fun SharedPreferences.open(block: SharedPreferences.Editor.() -> Unit) {
 	val editor = edit()
 	editor.block()
 	editor.apply()
}

//使用
getSharedPreferences("data", Context.MODE_PRIVATE).open {
 	putString("name", "Tom")
 	putInt("age", 28)
 	putBoolean("married", false)
}
//谷歌本身就写好了edit函数可以直接使用，用法与上面类似

//vararg对应的就是Java中的可变参数列表，我们允许向这个方法传入0个、1个、2个甚至任意多个Pair类型的参数，这些参数都会被赋值到使用vararg声明的这一个变量上面
fun cvOf(vararg pairs: Pair<String, Any?>) = ContentValues().apply {
    for (pair in pairs) {
        val key = pair.first
        val value = pair.second
        when (value) {
            is Int -> put(key, value)
            is Long -> put(key, value)
            is Short -> put(key, value)
            is Float -> put(key, value)
            is Double -> put(key, value)
            is Boolean -> put(key, value)
            is String -> put(key, value)
            is Byte -> put(key, value)
            is ByteArray -> put(key, value)
            null -> putNull(key)
        }
    }
}

//使用
val values = cvOf("name" to "Game of Thrones", "author" to "George Martin","pages" to 720, "price" to 20.85)
db.insert("Book", null, values)
//谷歌也写好了类似的扩展函数contentValuesOf用法把cvof替换即可

内联函数

inline

为了解决每次创建一个匿名类实例所造成的性能损失

调用方法：在函数的fun前加inline

内联函数的工作原理：Kotlin编译器会将内联函数中的代码在编译的时候自动替换到调用它的地方，这样也就不存在运行时的开销了。约等于在一个地方调用一次就将函数代码插入到调用的地方去执行

第一步

第二步

最终结果

使用内联函数一般满足下列情况

• 参数中带有lanbda函数的高阶函数
• 函数体实现简单，代码量不多
• 可能会被多次调用

如果代码量过多且多次调用，复制粘贴的代码会极大的增大代码的体积

noinline

使用该关键字可以选择不内联的函数

inline fun inlineTest(block1: () -> Unit, noinline block2: () -> Unit) {
}

内联函数的返回

如果不使用内联函数，只能进行局部返回

fun printString(str: String, block: (String) -> Unit) {
 	println("printString begin")
 	block(str)
 	println("printString end")
}
fun main() {
 	println("main start")
 	val str = ""
 	printString(str) { s ->
        println("lambda start")
        if (s.isEmpty()) return@printString //返回时必须要这样子写,相当于在printString函数中返回到main函数
        println(s)
        println("lambda end")
 	}
 	println("main end")
}
//程序运行结果
//main start
//printString begin
//lambda start
//printString end
//main end

使用内联函数时进行返回

inline fun printString(str: String, block: (String) -> Unit) {
 	println("printString begin")
	block(str)
 	println("printString end")
}
fun main() {
 	println("main start")
 	val str = ""
 	printString(str) { s ->
 		println("lambda start")
 		if (s.isEmpty()) return //在内联函数中可以直接写return，不过由于内联函数会将函数代码粘贴复制到调用函数，所以这里返回相当于在main函数中直接返回，程序直接结束
 		println(s)
 		println("lambda end")
 	}
 	println("main end")
}
//程序运行结果
//main start
//printString begin
//lambda start

crossinline

inline fun runRunnable(block: () -> Unit) { //在block前加crossinline，编译就能通过了
 	val runnable = Runnable {
 		block()
 	}
 	runnable.run()
}
//这段代码在没加inline时可以正常运行，但是加了之后就不能了

上述代码实际上是在匿名类中调用了传入的函数类型参数。而内联函数所引用的Lambda表达式允许使用return关键字进行函数返回，但是由于我们是在

匿名类中调用的函数类型参数，此时是不可能进行外层调用函数返回的，最多只能对匿名类中的函数调用进行返回。

crossinline关键字就像一个契约，它用于保证在内联函数的Lambda表达式中一定不会使用return关键字，这样冲突就不存在了，问

题也就巧妙地解决了，如果想return的话就用return@runRunnable的写法进行局部返回

泛型

定义一个泛型

//此时的MyClass就是一个泛型类，MyClass中的方法允许使用T类型的参数和返回值。
class MyClass<T> {
    fun method(param: T): T {
        return param
    }
}

//在调用MyClass的时候，可以指定它的类型，那么用这个泛型的方法将会使用这个类型
val myClass = MyClass<Int>()
val result = myClass.method(123)
//由于kotlin的类型推导机制，在使用该方法的时候，传入什么参数，就会默认该泛型为该参数的类型，所以可以省略泛型的指定
val myClass = MyClass()
val result = myClass.method(123)

泛型的实化

怎么写才能将泛型实化呢？首先，该函数必须是内联函数才行，也就是要用inline关键字来修饰该函数。其次，在声明泛型的地方必须加上reified关键字来表示该泛型要进行实化

inline fun <reified T> getGenericType() = T::class.java
//获取该泛型的实际类型
fun main() {
    val result1 = getGenericType<String>()
    val result2 = getGenericType<Int>()
    println("result1 is $result1")//结果：result1 is String
    println("result2 is $result2")//结果：result1 is Int
}

这种写法在java中是不可能通过的，在java中会实行类型擦除的机制，即为泛型对于类型的约束只在编译时期存在，假设我们创建了一个List集合，虽然在编译时期只能向集合中添加字符串类型的元素，但是在运行时期JVM并不能知道它本来只打算包含哪种类型的元素，只能识别出来它是个List

泛型实化的应用

inline fun <reified T> startActivity(context: Context, block: Intent.() -> Unit) {
    val intent = Intent(context, T::class.java)
    intent.block()
    context.startActivity(intent)
}
//启动别的activity时
startActivity<TestActivity>(context) {
    putExtra("param1", "data")
    putExtra("param2", 123)
}

泛型的协变

一个泛型类或者泛型接口中的方法，它的参数列表是接收数据的地方，因此可以称它为in位置，而它的返回值是输出数据的地方，因此可以称它为out位置，如图所示

泛型协变定义

假如定义了一个MyClass的泛型类，其中A 是B的子类型，同时MyClass又是MyClass的子类型，那么我们就可以称MyClass在T这个泛型上是协变的。

如何才能让MyClass成为MyClass的子类型呢？当且仅当这个泛型类型在数据上是只读的，并且两个类型具有继承关系，否则编译器无法通过并且会出现类型转换的隐患，如果一个泛型类在其泛型类型的数据上是只读的话，那么它是没有类型转换安全隐患的。而要实现这一点，则需要让MyClass类中的所有方法都不能接收T类型的参数。换句话说，T只能出现在out位置上，而不能出现在in位置上

class SimpleData<T> {
    private var data: T? = null
    fun set(t: T?) {
        data = t
    }
    fun get(): T? {
        return data
    }
}

fun main() {
    val student = Student("Tom", 19)
    val data = SimpleData<Student>()
    data.set(student)
    handleSimpleData(data) // 实际上这行代码会报错，这里假设它能编译通过
    val studentData = data.get()
}

fun handleSimpleData(data: SimpleData<Person>) {
    val teacher = Teacher("Jack", 35)
    data.set(teacher)
}

class SimpleData<out T>(val data: T?) {
    fun get(): T? {
        return data
    }
}

fun main() {
    val student = Student("Tom", 19)
    val data = SimpleData<Student>(student)
    handleMyData(data)
    val studentData = data.get()
}
fun handleMyData(data: SimpleData<Person>) {
    val personData = data.get()
}

public interface List<out E> : Collection<E> {
    override val size: Int
    override fun isEmpty(): Boolean
    override fun contains(element: @UnsafeVariance E): Boolean
    override fun iterator(): Iterator<E>
    public operator fun get(index: Int): E
}

###### 泛型逆变的定义

//in说明T只能出现在in的位置上而不是out
interface Transformer<in T> {
    fun transform(t: T): String
}

fun main() {
    val trans = object : Transformer<Person> {
        override fun transform(t: Person): String {
            return "${t.name} ${t.age}"
        }
    }
    handleTransformer(trans)
}

fun handleTransformer(trans: Transformer<Student>) {
    val student = Student("Tom", 19)
    val result = trans.transform(student)
}

interface Comparable<in T> {
    operator fun compareTo(other: T): Int
}

class MySet<T>(val helperSet: HashSet<T>) : Set<T> {
     override val size: Int
     get() = helperSet.size
     override fun contains(element: T) = helperSet.contains(element)
     override fun containsAll(elements: Collection<T>) = helperSet.containsAll(elements)
     override fun isEmpty() = helperSet.isEmpty()
     override fun iterator() = helperSet.iterator()
}

//kotlin的类委托，效果如上，拥有MySet对象的时候可以直接调用helperSet的方法，还可以自己重写helperSet的方法
class MySet<T>(val helperSet: HashSet<T>) : Set<T> by helperSet {
 	fun helloWorld() = println("Hello World")
 	override fun isEmpty() = false
}

//这里使用by关键字连接了左边的p属性和右边的Delegate实例，这种写法就代表着将p属性的具体实现委托给了Delegate类去完成。当调用p属性的时候会自动调用Delegate类的getValue()方法，当给p属性赋值的时候会自动调用Delegate类的setValue()方法。
class MyClass {
 	var p by Delegate()
}

//在Delegate类中我们必须实现getValue()和setValue()这两个方法，并且都要使用operator关键字进行声明。
class Delegate {
    var propValue: Any? = null
    operator fun getValue(myClass: MyClass, prop: KProperty<*>): Any? {
        return propValue
    }
    operator fun setValue(myClass: MyClass, prop: KProperty<*>, value: Any?) {
        propValue = value
    }
}

private val uriMatcher by lazy {
    val matcher = UriMatcher(UriMatcher.NO_MATCH)
    matcher.addURI(authority, "book", bookDir)
    matcher.addURI(authority, "book/#", bookItem)
    matcher.addURI(authority, "category", categoryDir)
    matcher.addURI(authority, "category/#", categoryItem)
    matcher
 }

if ("Hello Kotlin".startsWith("Hello")) {
 // 处理具体的逻辑
}

infix fun String.beginsWith(prefix: String) = startsWith(prefix)

if ("Hello Kotlin" beginsWith "Hello") {
 // 处理具体的逻辑
}

fun foo() {
    a()
    b()
    c()
}
fun bar() {
    x()
    y()
    z()
}
//在没有开启线程的情况下，先后调用foo()和bar()这两个方法，那么理论上结果一定是a()、b()、c()执行完了以后，x()、y()、z()才能够得到执行。而如果使用了协程，在协程A中去调用foo()方法，协程B中去调用bar()方法，虽然它们仍然会运行在同一个线程当中，但是在执行foo()方法时随时都有可能被挂起转而去执行bar()方法，执行bar()方法时也随时都有可能被挂起转而继续执行foo()方法，最终的输出结果也就变得不确定了。

implementation 'org.jetbrains.kotlinx:kotlinx-coroutines-android:1.4.1'
implementation "org.jetbrains.kotlinx:kotlinx-coroutines-core:1.4.2"

fun main() {
    GlobalScope.launch {
        println("codes run in coroutine scope")
        delay(1500)//该函数可以将该协程挂起，并且并不会影响到其他协程，不会像sleep函数一样会阻塞该线程的所有进程
        println("codes run in coroutine scope finished")
    }
    Thread.sleep(1000)//如果不挂起线程，这个协程内的内容将无法输出，因为协程还没执行就已经随着主函数结束而结束
}

fun main() {
    runBlocking {//该函数可以让主函数等待该协程执行完毕之后才会结束，所以可以不需要休眠线程
        println("codes run in coroutine scope")
        delay(1500)
        println("codes run in coroutine scope finished")
    }
}

fun main() {
    runBlocking {
        launch {
            println("launch1")
            delay(1000)
            println("launch1 finished")
        }
        launch {
            println("launch2")
            www.blogss.cn
            delay(1000)
            println("launch2 finished")
        }
    }
}
//结果
//launch1
//launch2
//launch1 finished
//launch2 finished

suspend fun printDot() {
    println(".")
    delay(1000)
}//使用它可以将任意函数声明成挂起函数，而挂起函数之间都是可以互相调用的

suspend fun printDot() = coroutineScope {
    launch {
        println(".")
        delay(1000)
    }
}

val job = GlobalScope.launch {
    // 处理具体的逻辑
}
job.cancel()

val job = Job()
val scope = CoroutineScope(job)
scope.launch {
    // 处理具体的逻辑
}
job.cancel()

fun main() {
    runBlocking {
        val start = System.currentTimeMillis()
        val result1 = async {
            delay(1000)
            5 + 5
        }.await()
        val result2 = async {
            delay(1000)
            4 + 6
        }.await()
        val end = System.currentTimeMillis()
        println(result1)
        println(result2)
        println("cost ${end - start} ms.")
    }
}
//结果
//10
//10
//cost 2032 ms.

fun main() {
    runBlocking {
        val start = System.currentTimeMillis()
        val deferred1 = async {
            delay(1000)
            5 + 5
        }
        val deferred2 = async {
            delay(1000)
            4 + 6
        }
        println(result1.await() + result2.await())
        println("cost ${end - start} ms.")
    }
}
//结果
//20
//cost 1029 ms.

fun main() {
    runBlocking {
        val result = withContext(Dispatchers.Default) {
            5 + 5
        }
        println(result)
    }
}

suspend fun request(address: String): String {
    return suspendCoroutine { continuation ->
                             HttpUtil.sendHttpRequest(address, object : HttpCallbackListener {
                                 override fun onFinish(response: String) {
                                     continuation.resume(response)
                                 }
                                 override fun onError(e: Exception) {
                                     continuation.resumeWithException(e)
                                 }
                             })
                            }
}

suspend fun getBaiduResponse() {
    try {
        val response = request("https://www.baidu.com/")
        // 对服务器响应的数据进行处理
    } catch (e: Exception) {
        // 对异常情况进行处理
    }
}

suspend fun <T> Call<T>.await(): T {
    return suspendCoroutine { continuation ->
                             enqueue(object : Callback<T> {
                                 override fun onResponse(call: Call<T>, response: Response<T>) {
                                     val body = response.body()
                                     if (body != null) continuation.resume(body)
                                     else continuation.resumeWithException(
                                         RuntimeException("response body is null"))
                                 }
                                 override fun onFailure(call: Call<T>, t: Throwable) {
                                     continuation.resumeWithException(t)
                                 }
                             })
                            }
}

//请求写法
suspend fun getAppData() {
    try {
        val appList = ServiceCreator.create<AppService>().getAppData().await()
        // 对服务器响应的数据进行处理
    } catch (e: Exception) {
        // 对异常情况进行处理
    }
}