Kotlin学习笔记

写在前面

---

相关基础

变量

lateinit var test1:Int
val name: String by lazy { "sherlbon" }
// lateinit 与 by lazy 的区别：lateinit可以在任何位置初始化并且可以初始化多次。而lazy在第一次被调用时就被初始化，想要被改变只能重新定义

var test1:Int? = null

//
var test1: Int
    set(value) {
    }
    get() {
        return 1;
    }

// 惰性
val test2: Int by lazy {
    val a = 10
    val b = 10
    a + b 
}

常量

你认为下面的写法是常量么？不是，我之前也认为是(只要加了val都是常量)，每次访问currentTimeMillis得到的值是变化的，因而不是常量！！！是不是蒙蔽了.
因为var的变量会 生成(字节码) get,set的方法，val会 生成(字节码) get的方法；

val currentTimeMillis: Long
    get() {return System.currentTimeMillis()}

每次输出我使用 Thread.sleep，看最终打印：

那如何才能写真正的常量呢？一种是使用 const，另一种使用 @JvmField注解
正确的写法：

const val TRANSLATION_ZERO_VALUE = 0f
private const val ROTATION_Y_PROPERTY = "rotationY"
@JvmField val FIELD_CONST_TEST = 250

循环

// 输出 1~10, 可使用 setp 设置步长
for (i in 1..10) {} 

// 输出 1~9
for (i in 1 until 10) {} 

// 输出 0~9
repeat(10) { 
	println("$it")
}

// 输出 10~1
for (i in 10 downTo 1) {
	println("$i")
}

// 循环-列表，输出 a, b, c, d
val list = arrayListOf("a", "b", "c", "d")
for (str in list) {
	println("$str")
}
for ((index,str) in list.withIndex()) {
        println("index:$index，str:$str")
}
输出：
index:0，str:a
index:1，str:b
index:2，str:c
index:3，str:d

---

函数/方法

构造函数

Kotlin 自定义 View 的构造函数 的几种 写法

class TestView : View {
  constructor(context: Context):this(context, null){
  }
  constructor(context: Context, attributeSet: AttributeSet?):this(context, attributeSet, 0){
  }
  constructor(context: Context, attributeSet: AttributeSet?, defStyleAttr: Int):super(context, attributeSet, defStyleAttr) {
  }
}

这种方式类似以前的Java写法

public class TestView extends View {
    public TestView(Context context) {
        this(context, null);
    }
    public TestView(Context context, AttributeSet attrs) {
        this(context, attrs, R.attr.TVUIRoundButtonStyle);
    }
    public TestView(Context context, AttributeSet attrs, int defStyleAttr) {
        super(context, attrs, defStyleAttr);
    }
}

另一种方式

// 类增加open，TestView2 就可以被继承了
open class TestView2 constructor(context: Context?, attrs: AttributeSet? = null, defStyleAttr: Int = 0) :
    View(context, attrs, defStyleAttr) {

    val rootRelativeLayout: RelativeLayout by lazy { RelativeLayout(context) }

    init {
        setupRootRelativeLayout()
    }

    private fun setupRootRelativeLayout() {
        rootRelativeLayout.apply {
            id = ViewCompat.generateViewId()
            layoutParams = ViewGroup.LayoutParams(
                LayoutParams.MATCH_PARENT,
                LayoutParams.MATCH_PARENT
            )
        }
    }
}

静态方法

object TestView {
    fun staticMethodTest() {
    }
}

// java中调用就会变成
PowerUtils.INSTANCE.staticMethodTest
// 添加 @JvmStatic 再函数上面，java调用
PowerUtils.staticMethodTest

// 也可以这么写
class TestView {
  companion object {
    fun staticMethodTest() {

    }
  }
}

// 全局静态方法
fun staticMethodTest() {

}

参考资料：https://stackoverflow.com/questions/40352684/what-is-the-equivalent-of-java-static-methods-in-kotlin

扩展函数

目录命名 extensions

@JvmName("releaseFunction")
internal fun View.testFunction():String {
    return "testFunction"
}

// 扩展函数栗子

public inline fun <T, R> T.letTest(block: (T) -> R): R {
	return block(this)
}
// 使用 单表达式函数 简写
inline fun <T, R> T.letTest(block: (T) -> R): R = block(this)

val str:String="Android"
val value:Int = str.letTest{
	it + " Dev"
	520
}
// letTest 接收一个lambda参数，有两个范型：T和R，在这里 T 是String，R 是Unit，有返回值就是 Int
// 结合这里的具体情形，去掉范型：
// public inline fun String.let(block: (String) -> Unit) = block(this)

扩展函数个接收者对象

fun buildString(test:StringBuilder.()->Unit):String {
    val sb = StringBuilder()
    sb.test()
    return sb.toString()
}

println(buildString { append("I love Kotlin") })

// 比如常见的的 apply，也是使用了上面类似的方式
val sb = StringBuilder()
sb.apply {
	append("I")
	append("123")
}

// 看 apply 的源码
@kotlin.internal.InlineOnly
public inline fun <T> T.apply(block: T.() -> Unit): T {
    contract {
        callsInPlace(block, InvocationKind.EXACTLY_ONCE)
    }
    block()
    return this
}

Kotlin 实战 11.2.1 带接收者的 lmbda 和 扩展函数类型 章节有详细讲解

特殊函数

kotlin 中的 run()，apply()，let()，also()，with() 等5个特殊函数

let 与 run 都会返回闭包的执行结果，区别在于let有闭包参数，run没有.

data class User(var name:String)
val user = User("冰雪情缘")
val letRes = user.let { user:User-> "let::${user.javaClass}" }
println(letRes)
val runRes = user.run { "let::${this.javaClass}" }
println(runRes)

输出信息：
let::class com.open.demo.kotlin.User
let::class com.open.demo.kotlin.User

also 与 apply 都不返回闭包的执行结果，区别在于 also 有闭包参数，apply没有；

user.also { block:User-> block.name }
user.also { println("also::${it.javaClass}") }
// takeIf 的闭包返回一个判断结果，为false时，takeIf函数返回空
user.takeIf { it.name.length > 0 }?.also { println("姓名为${it.name}") }
// takeUnless 与 takeIf 相反，闭包的判断结果，为 true 时，函数返回空
user.takeUnless { it.name.length > 0 }?.also { println("姓名为${it.name}") }

user.appply{ println("also::${this.javaClass}") }

with比较特殊，不是与扩展的方式存在，而是一个顶级函数

with(user) {
	this.name = "with"
}

多参数

testVararg(1, 2, 3, 4, 5)
fun testVararg(vararg v:Int) {
}

---

单例？！

class Singleton private constructor() {

    private object HOLDER {
        val INSTANCE = Singleton()
    }

    companion object {
        val instance:Singleton by lazy {
            HOLDER.INSTANCE
        }
    }

    public fun testFunc2() {
    }

}

另一种写法：

open class SingletonHolder<out T: Any, in A>(creator: (A) -> T) {
    private var creator: ((A) -> T)? = creator
    @Volatile private var instance: T? = null

    fun getInstance(arg: A): T {
        val checkInstance = instance
        if (checkInstance != null) {
            return checkInstance
        }

        return synchronized(this) {
            val checkInstanceAgain = instance
            if (checkInstanceAgain != null) {
                checkInstanceAgain
            } else {
                val created = creator!!(arg)
                instance = created
                creator = null
                created
            }
        }
    }
}

使用方式：

class SingletonArgument private constructor(context: Context) {

    init {
    }

    companion object : SingletonHolder<SingletonArgument, Context>(::SingletonArgument)

    public fun testFunc2() {
    }

}

// 调用方式
SingletonArgument.getInstance(getContext()).testFunc2()

---

类

可见修饰符 private 、 protected 、 internal(相同模块内随处可见) 和 public

泛型 in & out 怎么记？

Out (协变)**
如果你的类是将泛型作为内部方法的返回，那么可以用 out：

interface Production<out T> {
    fun produce(): T
}

In(逆变)
如果你的类是将泛型对象作为函数的参数，那么可以用 in：

interface Consumer<in T> {
    fun consume(item: T)
}

Invariant(不变)
如果既将泛型作为函数参数，又将泛型作为函数的输出，那就既不用 in 或 out。

interface ProductionConsumer<T> {
    fun produce(): T
    fun consume(item: T)
}

inline fun <reified T> Gson.fromJson(json: String) = 
        fromJson(json, T::class.java)
val user: User = Gson().fromJson(json)

---

高阶函数，Lambda，匿名函数，闭包？…

高阶函数

高阶函数 就是 以另外一个函数 作为 参数 或者 返回值 的函数
任何以 lambda 或 函数引用，匿名函数 作为 参数 或 返回值 的都是高阶函数
高阶函数建议前面 加 inline，起到优化作用！！

// 高阶函数：函数作为 参数
private fun initArgvFun(result:(Int, Int)->Int):Int {
    return result(1,2)
}
// 看懂了么？函数作为参数，显示写法
val result: (Int, Int) -> Int = { x: Int, y: Int -> x + y }
initArgvFun(result)
// 变化下，缩减下 类型推导，隐示写法
val result = { x: Int, y: Int -> x + y }
initArgvFun(result)
// 再转换下
initArgvFun({ x: Int, y: Int -> x + y })
initArgvFun({ x, y -> x + y })

// 高阶函数：函数作为 返回值
private fun initResultFunCal(): (Int, Int)->Int {
    return { a, b ->
        a + b
    }
}
// 调用方式
val callFunResult = initResultFunCal()
val s = callFunResult(3, 4)
println("callFunResult 返回值: $s")

匿名函数

匿名函数与普通函数基本相似，只是将普通函数的函数名去掉而已。

// 函数
fun test(x: Int, y: Int): Int {
    return x + y
}
// 使用函数引用的方式 调用 函数
val d = ::test
d(3,4) // 相当于 d.invoke(3, 4)

// 需要传入 函数参数的 函数
inline fun test2(value:Int, block:(Int,Int)->Int) {
    val result = block(3, 4)
    println("返回值：$result")
}

// 直接传递，因为 test函数无法当做参数传递，所以需要使用 :: 变成 函数类型对象；
test2(3, ::test)
// 使用上面的 变量 d 传入，它这里其实是一个 函数类型的 对象
test2(3, d)

// 正常的函数
fun test(x: Int, y: Int): Int { return x + y }
// 去掉 test 名称，就是匿名函数了！！
fun(x: Int, y: Int): Int { return x + y }


// 变量赋值
val testFun = fun(x: Int, y: Int): Int { return x + y }
// 还可以这么写
val testFun = fun(x: Int, y: Int): Int =  x + y

// 调用使用:将 匿名函数 作为参数传入，这就是前面高阶函数所说的一致；
test2(3, testFun)

// 还可以去掉变量，这样省略去写
test2(3, fun(x: Int, y: Int): Int { return x + y })
test2(3, fun(x: Int, y: Int): Int =  x + y)

Lambda

// 看看 匿名函数
val testFun = fun(x: Int, y: Int): Int { return x + y }
val testFun = fun(x: Int, y: Int): Int =  x + y

// lambda 的 写法
val testlambda: (x: Int, y: Int) -> Int = { x: Int, y: Int -> x + y }
// 也可以这么写，隐式
val testlambda = { x: Int, y: Int -> x + y }
// 要么就是这种写法，隐式
val testlambda :(x: Int, y: Int)->Int = { x,y-> x + y }
// 这种写法是错误的，没有办法推导出类型
val testlambda = { x,y-> x + y }

// 调用方式:将lambda作为参数传入，这就是前面高阶函数所说的一致；
test2(3, testlambda)
// 将值去掉，简写
test2(3, { x:Int, y:Int -> x + y })
// 再简化，其实这么一看 Lambda 还是很简单的
test2(3, { x, y -> x + y })

// 如果 test2 修改为 test3 只有一个参数
inline fun test3(block:(Int,Int)->Int) {
    val result = block(3, 4)
    println("返回值：$result")
}
// 调用方式：
test3( { x, y -> x + y })
// 如果 只有 一个参数，可以按照下面写法，
// 看到下面的代码是不是似曾相识，对的，单击事件 setOnClickListener {  }
test3 { x, y -> x+y }
// 单个参数的省略(改为下面的代码)
inline fun testHigherOrderFunctionsSignle(block: (String) -> String):String {
    return block("单参数测试")
}
// 传入方式：
println(testHigherOrderFunctionsSignle {
	// it 不是kotlin关键字，只是kotlin语言预定.
	// it 表示单个参数的隐式名称，Lambda表达式只有一个参数的时候可使用
	"高阶函数 Lambda 单个参数($it)"
})

inline: 优化调用，lambda 表达式会被正常地编译成匿名类，那每次调用都会创建新的对象. 
所以加了 inline的标识， 编译器 将 将内联函数的函数体复制到调用处；

被内联的函数非常大，则可能就会造成堆栈空间溢出 所以往往都建议针对小函数进行内联;

参考 Kotlin 程序开发入门精要，Kotin实战，揭秘Kotlin编程原理——7.1.2章节

kotlin 本身是不可以将函数作为参数传递的；那么 ::(双冒号::b)，lambda 与 匿名函数 是什么？
它们是 函数类型 的 对象；只有对象才可以传递；

闭包

---

协程(Coroutine)的装逼玩意

导入方式：

dependencies {
  ...
  implementation "org.jetbrains.kotlinx:kotlinx-coroutines-core:x.x.x"
  implementation "org.jetbrains.kotlinx:kotlinx-coroutines-android:x.x.x"
}

名称	作用
runBlocking:T	最高级的协程/主协程，用于执行协程任务，通常启动最外层的协程
launch:Job	协程，能在runBlocking中运行，反过来不行
suspend	修饰函数可以调用协程的一些函数，比如函数内部调用delay
async/await:Deferred	async 相当于创建了一个子协程，会与其它子协程并行工作，await 的暂停函数返回结果
@Synchronized	锁模式
Actor	有状态的并行计算单元
withContext	Dispatchers.Main(主线程)，Dispatchers.IO，Dispatchers.Default(主线程之外执行占用大量 CPU 资源的工作，比如列表排序，JSON解析)
coroutineScope	启动一个或多个协程，跟踪它使用 launch 或 async 创建的所有协程，随时调用 scope.cancel() 以取消正在工作的协程

---

Gradle 的使用

object Libs {
    const val junit = "junit:junit:4.13"
    ... ...

    object Kotlin {
        private const val version = "1.4.0"
        const val stdlib = "org.jetbrains.kotlin:kotlin-stdlib-jdk8:$version"
        const val gradlePlugin = "org.jetbrains.kotlin:kotlin-gradle-plugin:$version"
        const val extensions = "org.jetbrains.kotlin:kotlin-android-extensions:$version"
    }

    object Coroutines {
        private const val version = "1.3.9"
        const val core = "org.jetbrains.kotlinx:kotlinx-coroutines-core:$version"
        const val android = "org.jetbrains.kotlinx:kotlinx-coroutines-android:$version"
        const val test = "org.jetbrains.kotlinx:kotlinx-coroutines-test:$version"
    }

    object AndroidX {
        const val appcompat = "androidx.appcompat:appcompat:1.2.0-rc01"
        const val coreKtx = "androidx.core:core-ktx:1.5.0-alpha01"

        object Compose {
            const val version = "1.0.0-alpha01"
            const val core = "androidx.compose.ui:ui:$version"
        }
        ... ...

---

设计模式与架构

设计模式

创建型模式

单例模式

工厂模式

行为型模式

策略模式

使用 高阶函数 简化策略模式

class Encrypt(val alg:()->Unit) {
	fun compute() {
		alg()
	}
}

val encrypt = Encrypt(::MD5)
encrypt.compute()

结构型模式

装饰者模式

“组合优于继承” 的设计原则。
用类委托减少模板代码，可优雅的使用 Kotlin 的 by 关键字。

class XXX ... {
  ... getAge() = 18
  ... getHeight() = 160
  ... getWidget() = 45
}
class ByXXXTest ... by XXX {
	... getWidget() = xxx.getWidget() * 2
}

借助Kotlin的扩展函数 替代 装饰者

fun XXX.getWidgetX() {
	return getWidget() * 2
}

架构

单向数据流架构的最大优势在于整个应用中的数据流以单向流动的方式，从而使得拥
有更好的可预测性与可控性，这样可以保证应用各个模块之间的松搁合性。

单向数据流，Redux(Flux思想产生)起源于 Web 端
https://github.com/ReKotlin/ReKotlin

参考资料：《Kotlin核心编程》

---

相关库

Jetpack

androidX，
LifeCycle
Navigation，深层链接DeepinLink
ViewModel(与 AndroidViewModel，与 onSaveInstanceState)
LiveData，ViewModel+LiveData实现Fragment间通信
Room(与LiveData,ViewModel结合使用，数据库升级，预填充数据库createFromAsset)
WorkManager(应用程序不需要及时完成的任务提供一个统一的解决方案:1.不需要及时完成的任务；2.保证任务一定会被执行；3.兼容范围广)

Paging(3个核心类 PagedListAdapter，PagedList，DataSource[PositionalDataSource，PageKeyedDataSource，ItemKeyedDataSource])
Paging+BoundaryCallback

Jetpack Compose

// build.gradle 配置
android {
    defaultConfig {
        ...
        minSdkVersion 21
    }

    buildFeatures {
        // Enables Jetpack Compose for this module
        compose true
    }
    ...

    // Set both the Java and Kotlin compilers to target Java 8.

    compileOptions {
        sourceCompatibility JavaVersion.VERSION_1_8
        targetCompatibility JavaVersion.VERSION_1_8
    }

    kotlinOptions {
        jvmTarget = "1.8"
    }

    composeOptions {
        kotlinCompilerExtensionVersion "0.1.0-dev13"
    }
}

implementation 'androidx.ui:ui-core:0.1.0-dev13'
implementation 'androidx.ui:ui-tooling:0.1.0-dev13'
implementation 'androidx.ui:ui-layout:0.1.0-dev13'
implementation 'androidx.ui:ui-material:0.1.0-dev13'

  override fun onCreate(savedInstanceState: Bundle?) {
        super.onCreate(savedInstanceState)
        setContent {
            Greeting("测试")
        }
    }

    @Composable
    fun Greeting(name: String) {
        Column(
            modifier = Modifier.padding(16.dp)
        ) {
            Text (text = "Column Text1 $name!")
            Text (text = "Column Text2 $name!")
            Text (text = "Column Text3 $name!")
        }
        Row(verticalGravity = Alignment.CenterVertically) {
            Column {
                Text("Row Column Text1 $name!")
                Text("Row Column Text2 $name!")
            }
        }
    }

    @Preview
    @Composable
    fun PreviewGreeting() {
        Greeting("Android")
    }

优秀的开源库(学习案例)

名称	描述
igorwojda/android-showcase	showcase工具库，但是里面有很多Kotlin/Android开发的最佳实践和范例，值得学习
skydoves/Pokedex	Pokedex一个学习Android的Best Practice项目，使用了Dagger Hilt, Motion, Coroutines, Flow, Jetpack (Room, ViewModel, LiveData)等各种新技术
android10/Android-CleanArchitecture-Kotlin	在Kotlin/Android中实践 Clean Architecture 的 Demo App，边学语言边学架构设计
sanogueralorenzo/Android-Kotlin-Clean-Architecture	这也是 kotlin/android的Clean Architecture库
babylonhealth/orbit-mvi	MVI 用于Kotlin/Android的Model-View-Intent （MVI）框架。它的灵感来自Jake Wharton，RxFeedback和Mosby的“Managing State with RxJava"
ReKotlin	单向数据流，Redux(Flux思想产生)起源于 Web 端
square/leakcanary	方块公司出品，内存泄露工具
square/okhttp	okhttp 方块公司出品的http请求库， 4.0与3.0功能完全一致，只是用Kotlin重写了一遍，适合Kotlin与Java对照学习
square/retrofit	okhttp 虽然不错，但是更多的是使用retrofit。源码里面的 优秀的 设计模式，非常值得学习
retrofit-adapter-flow	https://github.com/chenxyu/retrofit-adapter-flow
Fuel	网络库，Fuel代码很简洁，类似IOS的 moya；最简单的HTTP网络库，使用kt的lambda语法处理各种回调
permissions-dispatcher/PermissionsDispatcher	通过使用注解用来管理 Android6.0之后引入了动态权限申请， 兼容kapt的使用
coil	图片加载库(coil)，kotlin版本的图片加载库，使用coroutine处理异步任务
JakeWharton/RxBinding	J大神的RxBinding，已经用Kt重写过了，不太喜欢Rxjava，如果能用Kotlin的协程+flow重写感觉更完美一些
InsertKoinIO/koin	发挥 Kotlin语法优势，配合DSL、reified等特性实现的依赖注入框架（更准确的说是个服务发现框架）
zetbaitsu/Compressor	Kotlin版本的图片压缩库，通过使用DSL接口更加易用，同时支持在协程(Coroutine) 总 处理 异步任务，值得学习借鉴
android/android-ktx	官方的kotlin扩展库，基本上是Kotlin/Android项目的必备工具
Shopify/livedata-ktx	Livedata的Kotlin扩展，像RxJava一样增加了一些链式操作符
square/wire	可用于Kotlin的gRPC库，方块出品必属精品
anvil-ui/anvil	基于React思想的Kotlin/Android的响应式UI框架
airbnb/MvRx	用于Kotlin/Android的Redux框架，充分发挥Kotlin的语法优势，例如通过by关键字创建ViewModel，比Jetpack出现更早
airbnb/epoxy	Kotlin版本的列表库，配合上面的MvRx可以打造响应式的列表页面，节省大量模板代码
spekframework/spek	Kotlin版本的单元测试框架，用DLS的方式写UT
mikepenz/FastAdapter	快速的方便的 使用 FastAdapter(字面意思就是快) 创建和配置 RecyclerView的Adapter，核心代码基于Kotlin实现
arrow-kt/arrow	使用Kotlin的函数式的编程库
airbnb/paris	代码动态控件的Style，不需要使用烦人的xml，有点类似现在的Jetpack Compose的思路
google/flexbox-layout	Kotlin版本的 Flaxbox布局的控件(用于TV开发还是不错，代码可以借鉴学习下)
Foso/Jetpack-Compose-Playground	帮助我们学习Jetpack Compose的优秀项目，助力Kotlin进步，哈哈
skydoves/ColorPickerPreference	Kotlin版本的的颜色选取库
ReactiveCircus/FlowBinding	协程Coroutine + Flow版的RxBinding，我就非常讨厌Rxjava，这个库值得学习
参考:https://blog.csdn.net/vitaviva/article/details/108165190

---

参考资料

Kotlin：
Kotlin官方网站
Kotlin语言中文站
Singleton class in Kotlin
How to create a Singleton class in Kotlin?
Coding conventions
Kotlin 样式指南

[译][5k+] Kotlin 的性能优化那些事
kotlin flow

Kotlin 相关资料：
掌握Kotlin Coroutine之 Job&Deferred http://blog.chengyunfeng.com/?p=1087#ixzz6jzZa2BeT
https://github.com/fengzhizi715/Kotlin-Coroutines-Utils
https://github.com/fengzhizi715/Lifecycle-Coroutines-Extension 协程生命周期监听
https://www.jianshu.com/p/10358883455c kotlin中的函数引用详解
https://juejin.cn/post/6913429237147893774 Kotlin协程场景化学习
https://cloud.tencent.com/developer/article/1376764 AAC 的 Lifecycle 结合 Kotlin Coroutines 进行使用一. Lifecycle二. 创建 LifecycleObserver 的实现类三. 列举使用场景四. 总结
https://juejin.cn/post/6914802148614242312 抽丝剥茧Kotlin - 协程中绕不过的Flow
https://aisia.moe/2020/07/16/kotlin-internal-annotations/ Kotlin标准库里的那些internal注解

Jetpack Compose：
Jetpack Compose Alpha 版现已发布！
Jetpack Compose 更新速递-哔哩哔哩
Jetpack Compose谷歌官方文档
Android Studio 与 Jetpack Compose 配合使用
compose-samples

Kotlin Coroutine：
Use coroutines in common Android use cases

相关资料推荐：
揭秘Kotlin编程原理(提取码：pa7f )
Kotlin核心编程(提取码：4kup )
Kotlin实战(提取码：s10f )
Kotlin程序开发入门精要(提取码：1xe0)