kotlin 上手很简单，因为可以完美支持 java ，和 java 比较像的缘故，我们熟悉下 kotlin 的语法，1-2天就能写出 java 语法式的 kotlin 代码了，但是我们绝对不能只不如此，kotlin 本身的高级特性代表着语言的发展趋势，本身也是很简单，高效的，我们必须真正熟悉 kotlin 自身的写法，不要抗拒，拥抱 kotlin，零碎东西不少，但是我们总结一下，平时多用用，也就熟悉了
本文包含以下内容：
-
委托
- Lazy / lateinit 延迟加载器
- Delegates 属性观察者
- map / MutableMap 委托构造函数
- 智能转换类型
- this 表达式
- typealias 类型别名
- let / apply / run / with 这几个 kotlin 特有的扩展函数
- in / out
- return / break / continue
Lazy / lateinit
kotlin 对于 null 有着严格的使用限制，处处可见 ？不是，非 null 判断一直是代码的痛点，kotlin 只是把这种 痛点变得对 coder 来说更有好了，但是凡事总有一利一弊不是
kotlin 为了准确定义是不是 null ，要求我们在定义全局变量，时必须显示的赋值
传统 java 中我们这样定义全局变量
public class Car {
public String name ;
}
kotlin 中我们必须赋值，否则会报错
这里 kotlin 提供了2个选择，Lazy / lateinit ，都是延迟加载，但是有区别:
Lazy 只能修饰 val 不可变参数，等同于 java 的 final ，其次 Lazy 后跟一个 {} 复制表达式，本质是在一个工厂函数，只有在第一次调用时生效(既首席创建对象时)，常用于单例模式
val lazyValue: String by lazy {
// println 是对象创建时初始化操作
println("computed!")
// Hello 是返回的对象
"Hello"
}
//调用两次
println(lazyValue)
println(lazyValue)
// 第一次
computed!
Hello
// 第二次
Hello
lazy 方法本质是个 lamber 表达式，在 lazy() 中我们可以传入线程类型参数：
- LazyThreadSafetyMode.SYNCHRONIZED： 初始化属性时会有双重锁检查，保证该值只在一个线程中计算，并且所有线程会得到相同的值
- LazyThreadSafetyMode.PUBLICATION： 多个线程会同时执行，初始化属性的函数会被多次调用，但是只有第一个返回的值被当做委托属性的值
- LazyThreadSafetyMode.NONE： 没有双重锁检查，不应该用在多线程下
lateinit 我们可以在可以修饰任意参数，可以是 var 、 val 的，我们在声明成员变量时可以不指定具体数值，但是 lateinit 修饰的参数必须在合适的地方初始化，否则编译不会通过
我们看个例子，下面我们声明 lateinit 的参数，但是不初始化直接使用
open class News(var room: String) {
lateinit var name: String
lateinit var book: Book
fun speak() {
println(name)
}
fun price() {
println(book)
print(room)
}
}
使用
btn_name.setOnClickListener(View.OnClickListener {
val news = News("book")
news.speak()
news.price()
})
编译会报 UninitializedPropertyAccessException 异常，未初始化的参数不可达
这就是 Lazy 和 lateinit 的区别，lateinit 我们在使用前必须初始化才行，而 Lazy 在我们首席使用的时候才会创建对象，很像 java 中的懒汉式，饿汉式。上面的代码我们即使对 lateinit 的参数加了 !null 的判断也没用
如果在我们的代码场景中会有像 java 那样，成员变量依靠外接传递，那么 kotlin 也提供了相关写法，核心就是抛弃 kotlin 关于 null 的操作，完全还原 java 的环境，还是上面的代码
open class News(var room: String) {
var name: String? = null
var book: Book? = null
fun speak() {
if (name != null) {
println(name!!)
}
}
fun price() {
if (book != null && room != null) {
println(book!!)
print(room!!)
}
}
}
我们就不用 lateinit 来修饰啦，在使用这个参数时添加 !! 后缀表示按照 java 语法进行，注意我们现在得进行 !null 判断啦，要不会报错的哦~
Delegates 属性观察者
Delegates 我是愿意称为属性观察者的，Delegates 下面包含一些列函数，这是 kotlin 独有的特性，允许我们在属性赋值时添加观察者，拦截器操作
我们常用的是 observable / vetoable 这2个函数
- observable 可以观察参数的变化
- vetoable 相当于参数拦截器，可以拦截不符合条件的复制操作
- 但是在这2个函数内我们都不能主动的修改参数值，代码检查会提示我们
我们来看看代码：
open class News(var room: String) {
var title: String by Delegates.observable("title_default") { property, oldValue, newValue ->
Log.d("AAA", "属性变化：属性名：$property 旧值：$oldValue 新值：$newValue")
}
var price: Int by Delegates.vetoable(100, { property, oldValue, newValue ->
if (newValue > 100) {
Log.d("AAA", "属性变化：属性名：$property 旧值：$newValue > 100 不符合需求不能更改数据")
return@vetoable false
}
return@vetoable true
})
}
Delegates 下属函数会提供给我们3个参数，property(参数名) / oldValue(旧值) / newValue(新值)，接收2个参数，前一个是默认值，赋值时注意数据类型；后一个接受一个对象函数用来包裹我们的代码
observable 函数没有返回值，vetoable 函数有返回值，true 表示允许参数修改，false 反之不允许，数据不会变更。这里注意我们要显式的使用 return@vetoable 退出函数，否则会出现代码穿透的问题
下面来试一下，我们给 title 和 price 赋值看看:
val news = News("book")
news.title = "AAA"
news.price = 200
Log.d("AA", "重新对 news 赋值后，news 的值：${news.price}")
属性变化：属性名：property title (Kotlin reflection is not available) 旧值：title_default 新值：AAA
属性变化：属性名：property price (Kotlin reflection is not available) 旧值：200 > 100 不符合需求不能更改数据
重新对 news 赋值后，news 的值：100
map 构造函数委托
kotlin 的这个 map 委托是用与构造函数的，生成数据的，用于 json 解析，我觉得用这个 map 做 json 解析不是好，不如 gson
map：
// map 用在类声明处，传参用
class BookData(map: Map<String, Any>) {
val name: String by map
val price: Int by map
fun speak() {
Log.d("AAA", "BookData: name = $name , price = $price")
}
}
// 使用：
var bookData = BookData(mapOf("name" to "", "price" to 88))
bookData.speak()
map 只能修饰 val 不可变参数，那么相应的就有 MutableMap ，注意 Mutable 可变早 kotlin 已经出现在好几个地方了
MutableMap :
class BookData(map: MutableMap<String, Any>) {
var name: String by map
var price: Int by map
fun speak() {
Log.d("AAA", "BookData: name = $name , price = $price")
}
}
MutableMap 可以操作 var 可变参数了，和 map 就是这点差距
需要注意的是，使用 map 赋值生成数据对象时，比如传入所有的属性值，没有值的也要给，要不会抛出 error，参数类型给错了也会报错
错误赋值，缺少一个属性值：
var bookData = BookData(mapOf("name" to "android"))
bookData.speak()
前面说到有人推荐使用 map 来进行 json 操作，这里我推行各位必须找资料看明白再决定是不是使用 map 这个特性
智能转换类型
kotlin 是弱类型语言，通过 var 大家都了解吧，这点和 java 不同， java 这种强类型设计早早就被时代慢慢淘汰了，到现在 var / val 这种弱类型设计已经是行业准则了，java 在 jdk 10 时也开始支持 var 了
var 的好处是语言可以自定判断数据类型，从而进行无痕式的类型转换，这点对于我们来说体验是很 nice 的，代码少了，也不会打算思路写讨厌重复的代码了，逻辑直接一气呵成，连贯舒服我婆觉得是语言进行的特点
kotlin 强制类型转换
var kkk:Any = "123"
var mmm:String = kkk as String
类型判断
var kkk:Any = "123"
var mmm:String = kkk as String
mmm is String
智能自动转换类型
var kkk:Any = "123"
// 不用我们自己手动写转换了吧，这是因为我们已经做了类型判断了，所以编译器认为类型安全默认给我们转了
if (kkk is String) {
kkk.length
}
当然智能转换不是万能的，机器毕竟不是人不是，适用以下规则：
- val 局部变量——总是可以，局部委托属性除外
- val 属性——如果属性是 private 或 internal，或者该检查在声明属性的同一模块中执行。智能转换不适用于 open 的属性或者具有自定义 getter 的属性
- var 局部变量——如果变量在检查和使用之间没有修改、没有在会修改它的 lambda 中捕获、并且不是局部委托属性
- var 属性——决不可能（因为该变量可以随时被其他代码修改）
this表达式
Koltin 在作用域这块有更宽泛的使用，这点在 this 关键字的使用上可以看的很明白，比 java 的 this 使用更灵活，Kotlin 的 this 关键字可以 + @label 标签 来指定 this 具体的代表对象
class A { // 隐式标签 @A
inner class B { // 隐式标签 @B
fun Int.foo() { // 隐式标签 @foo
val a = this@A // A 的 this
val b = this@B // B 的 this
val c = this // foo() 的接收者，一个 Int
val c1 = this@foo // foo() 的接收者，一个 Int
val funLit = lambda@ fun String.() {
val d = this // funLit 的接收者
}
val funLit2 = { s: String ->
// foo() 的接收者，因为它包含的 lambda 表达式
// 没有任何接收者
val d1 = this
}
}
}
}
typealias
看名字可以猜测带有别名的作用，是的，typealias 我们可以成为类型别名，听起来怪怪的，说起来其实很好理解，可以代理 interface 声明一个单方法类型的接口，不能写在 class 内，打击理解一下，写在 class 内不就成了内部类了，typealias 的有点在于可以非常省事的声明一个类似接口出来
// 在 class 外声明，作用域和平常类一样
typealias Click = (String, String) -> Int
class BookData(map: MutableMap<String, Any>) {
fun my(click: Click) {
click("GG", "AA")
}
fun test2() {
// typealias 填参数时和函数式对象一样
my { name, age ->
Log.d("AA", "my 方法参数传入")
return@my 10
}
}
}
let / apply / run / with
- let 函数 - 可以对指定对象提供一段代码的执行，返回最后一行的对象，可以不是操作的对象
比如下面这段代码，let 接收我们新建的这个 book 对象，然后对 book 对象进行了操作，最后一行返回数据，这里可以不写 return
var book: Book = Book("88").let {
it.name = "-77"
it.sex = "99"
return@let it
}
返回不一样的数据类型，我们接受 Book 类型的数据，最后返回 String 类型的数据
var name: String = Book("88").let {
it.name = "-77"
it.sex = "99"
return@let it.name
}
我么你还可以结合 ？ 进行对 null 数据的操作
Book("88")?.let {
it.name = "-77"
it.sex = "99"
return@let it.name
}
- apply 函数 - 可以对指定对象进行代码扩展，然后返回这个对象，注意是这个对象，意味着不能改变对象类型，然后再配合 let 获取这个对象再进行操作
比如下面这段代码，apply 内的代码好比就是写在 Book 类型里面的，所有属性刚和方法直接掉，不像 let 还得写 let ，这是本质的不同
var book: Book = Book("88")
.apply {
name = "-77"
sex = "99"
}
.let {
it.name = "-77"
it.sex = "99"
return@let it
}
let 好比 rxjava 的 map ，apple 好比 flatmap
- run 函数 - run 和 apple 差不多，区别的是 run 返回的不是这个对象，而是最后一行的对象
var name: String = Book("88")
.run {
name = "-77"
sex = "99"
return@run this
}.let {
it.name = "ABB"
return@let it.name
}
- with 函数 - 和 run 一样，区别是写法不一样
var name: String = with(Book("88"))
{
name = "-77"
sex = "99"
return@with this
}.let {
it.name = "ABB"
return@let it.name
}
in / out
JAVA 里 List<Object> 是不能转换为 List<String> 的，但是在 koltin 中借助 in / out 就能实现
- Kotlin 中的 out A 类似于 Java 中的 ? extends A，即泛型参数类型必须是 A或者 A 的子类，用来确定类型的上限
- Kotlin 中的 in A 类似于 Java 中的 ? super A，即泛型参数类型必须是 B 或者 B 的父类，用来确定类型的下限
fun copy(from: List<out A>, to: List<in A>) {
for (i in from.indices) {
to[i] = from[i]
}
}
return/break/continue
kotlin 的 return/break/continue 和 java 含义一样，但是比 java 扩展的是可以用 @ 标价返回的位置，直接看例子，比说强
// 1. 和Java不同的是，这些表达式都可作为更大表达式的一部分
val s = person.name ?: return
//2. 和Java不同的是，在 Kotlin 中任何表达式都可以用 标签@ 来标记
loop@ for (i in 1..100) {
for (j in 1..100) {
if (……) break@loop // 终止loop标记的循环
if (……) continue@loop // 跳出loop标记的循环，继续下一次loop标记的循环
}
}
// 3. 从外层函数返回
fun foo() {
ints.forEach {
if (it == 0) return // 默认从foo(){}返回
print(it)
}
}
//4. 用显式标签从lambda表达式中返回
fun foo() {
ints.forEach lit@ {
if (it == 0) return@lit // 标记从forEach{}返回
print(it)
}
}
// 5. 用隐式标签(与接收lambda的函数同名)从lambda表达式中返回
fun foo() {
ints.forEach {
if (it == 0) return@forEach // 隐式标签forEach，从forEach{}返回
print(it)
}
}
// 6. 用匿名函数替代lambda表达式:
fun foo() {
ints.forEach(fun(value: Int) {
if (value == 0) return // 从该匿名函数fun返回
print(value)
})
}
网友评论