全民 Kotlin：你没有玩过的全新玩法

第一篇：全民 Kotlin：Java我们不一样
当前篇：全民 Kotlin：你没有玩过的全新玩法
第三篇：全民 Kotlin：协程特别篇

本文章已授权鸿洋微信公众号转载

空安全

在 Java 不用强制我们处理空对象，所以常常会导致 NullPointerException 空指针出现，现在 Kotlin 对空对象进行了限定，必须在编译时处理对象是否为空的情况，不然会导致编译不通过
在对象不可空的情况下，可以直接使用这个对象

fun getText() : String {
    return "text"
}
复制代码

val text = getText()
print(text.length)
复制代码

在对象可空的情况下，必须要判断对象是否为空

fun getText() : String? {
    return null
}
复制代码

val text = getText()
if (text != null) {
    print(text.length)
}
复制代码

// 如果不想判断是否为空，可以直接这样，如果 text 对象为空，则会报空指针异常，一般情况下不推荐这样使用
val text = getText()
print(text!!.length)
复制代码

// 还有一种更好的处理方式，如果 text 对象为空则不会报错，但是 text.length 的结果会等于 null
val text = getText()
print(text?.length)
复制代码

方法支持添加默认参数

在 Java 方法上，我们可能会为了扩展某个方法而进行多次重载

public void toast(String text) {
    toast(this, text, Toast.LENGTH_SHORT);
}

public void toast(Context context, String text) {
    toast(context, text, Toast.LENGTH_SHORT);
}

public void toast(Context context, String text, int time) {
    Toast.makeText(context, text, time).show();
}
复制代码

toast("弹个吐司");
toast(this, "弹个吐司");
toast(this, "弹个吐司", Toast.LENGTH_LONG);
复制代码

但是在 Kotlin 上面，我们无需进行重载，可以直接在方法上面直接定义参数的默认值

fun toast(context : Context = this, text : String, time : Int = Toast.LENGTH_SHORT) {
    Toast.makeText(context, text, time).show()
}
复制代码

toast(text = "弹个吐司")
toast(this, "弹个吐司")
toast(this, "弹个吐司", Toast.LENGTH_LONG)
复制代码

方法上面的参数不可变

在 Java 方法上面，我们可以随意修改方法上面参数的赋值，但是到了 Kotlin 这里是不行的，Kotlin 方法参数上面的变量是 val （对应 Java 的 final）类型的，那么这个时候我们有两种解决方案：
第一种，在方法里面定义一个一模一样的变量，具体写法如下：

class XxxView : View {

    override fun onMeasure(widthMeasureSpec: Int, heightMeasureSpec: Int) {
        var widthMeasureSpec: Int = widthMeasureSpec
        var heightMeasureSpec: Int = heightMeasureSpec
        
        if (MeasureSpec.getMode(widthMeasureSpec) == MeasureSpec.AT_MOST) {
            widthMeasureSpec = MeasureSpec.makeMeasureSpec(30, MeasureSpec.EXACTLY)
        }

        if (MeasureSpec.getMode(heightMeasureSpec) == MeasureSpec.AT_MOST) {
            heightMeasureSpec = MeasureSpec.makeMeasureSpec(30, MeasureSpec.EXACTLY)
        }
        
        setMeasuredDimension(widthMeasureSpec, heightMeasureSpec)
    }
}
复制代码

但是编译器会报警告，提示我们出现了重复变量，但是仍可正常编译和运行，所以不推荐这种写法
第二种，在方法里面定义一个不同名称的变量，具体写法如下：

class XxxView : View {

    override fun onMeasure(widthMeasureSpec: Int, heightMeasureSpec: Int) {
        var finalWidthMeasureSpec: Int = widthMeasureSpec
        var finalHeightMeasureSpec: Int = heightMeasureSpec

        if (MeasureSpec.getMode(finalWidthMeasureSpec) == MeasureSpec.AT_MOST) {
            finalWidthMeasureSpec = MeasureSpec.makeMeasureSpec(30, MeasureSpec.EXACTLY)
        }

        if (MeasureSpec.getMode(finalHeightMeasureSpec) == MeasureSpec.AT_MOST) {
            finalHeightMeasureSpec = MeasureSpec.makeMeasureSpec(30, MeasureSpec.EXACTLY)
        }
        
        setMeasuredDimension(widthMeasureSpec, heightMeasureSpec)
    }
}
复制代码

其实就在原来的基础上加一个 final 前缀，这样不仅解决了编译器警告的问题，还解决了我们还要重新想一个名称来给变量命名的烦恼。
那么肯定有人会问了，有没有办法像 Java 一样改呢？关于这个问题我也纠结了一阵子，但是查阅了很多文档和资料，最终发现并没有办法，所以只能妥协了，毕竟这个世界上没有什么事物是完美的。

类方法扩展

可以在不用继承的情况下对扩展原有类的方法，例如对 String 类进行扩展方法

fun String.handle() : String {
    return this + "Android轮子哥"
}
复制代码

// 需要注意，handle 方法在哪个类中被定义，这种扩展只能在那个类里面才能使用
print("HJQ = ".handle())
复制代码

HJQ = Android轮子哥
复制代码

函数变量

在 Kotlin 语法中函数是可以作为变量进行传递的

var result = fun(number1 : Int, number2 : Int) : Int {
    return number1 + number2
}
复制代码

使用这个函数变量

println(result(1, 2))
复制代码

内联函数

有人可能会问了，内联函数是虾米？我举个栗子，用 Kotlin 编写以下代码

class Demo {

    fun test() {
        showToast("666666")
    }

    /**
     * 这个就是我们今天的主角：内联函数了，用 inline 关键字来修饰
     */
    private inline fun showToast(message: String) {
        ToastUtils.show(message)
    }
}
复制代码

经过反编译之后，会变成以下代码：

/* compiled from: Demo.kt */
public final class Demo {

    public final void test() {
        ToastUtils.show("666666");
    }
}
复制代码

看到这里相信大家应该知道内联函数的用法和作用了，内联函数就是在编译的时候将所有调用 inline 函数的代码直接替换成方法里面的代码，那么大家可能有疑问了，这样做有什么实际好处呢？它其实提升了代码的性能，这跟基本数据类型的常量会在编译的过程中被优化一样，但是如果 inline 函数被许多处地方调用，并且 inline 函数的实现代码比较多的情况下，也会相应导致代码量增加。
另外上面的代码示例中，编译器在 inline 关键字上面有一个代码警告，原话是这样的：

Expected performance impact from inlining is insignificant. Inlining works best for functions with parameters of functional types

内联对性能的预期影响是微不足道的。内联最适用于参数为函数类型的函数

大致的意思是，上面的代码示例中，内联函数能起到的性能优化是微不足道的，它比较适合带有 lambda 参数的函数，根据这个提示，将上面的代码示例修改成下面这样就不会报代码警告了：

class Demo {

    fun test() {
    
        showToast({
            println("测试输出了")
        }, "7777777")
    }

    private inline fun showToast(function: () -> Unit, message: String) {
        function.invoke()
        ToastUtils.show(message)
    }
}
复制代码

有人可能会好奇了，这样就能有很大的性能提升？有什么判断依据呢？接下来让我们做一组实验，加 inline 和不加 inline 反编译出来的代码有什么区别，先来看加 inline 之后反编译出来的代码长啥样

/* compiled from: Demo.kt */
public final class Demo {

    public final void test() {
        System.out.println("\u6d4b\u8bd5\u8f93\u51fa\u4e86");
        ToastUtils.show("7777777");
    }
}
复制代码

一切都在预料之中，那么不加 inline 反编译出来又是什么效果呢？

/* compiled from: Demo.kt */
public final class Demo {

    public final void test() {
        showToast(1.INSTANCE, "7777777");
    }

    private final void showToast(Function0<Unit> function, String message) {
        function.invoke();
        ToastUtils.show(message);
    }
}
复制代码

/* compiled from: Demo.kt */
final class Demo$test$1 extends Lambda implements Function0<Unit> {
    public static final Demo$test$1 INSTANCE = new Demo$test$1();

    Demo$test$1() {
        super(0);
    }

    public final void invoke() {
        System.out.println("\u6d4b\u8bd5\u8f93\u51fa\u4e86");
    }
}
复制代码

很明显，不加 inline 会导致多生成一个内部类，这个是 lambda 函数多出来的类，并且里面的示例还是静态，这无疑会增加内存消耗，另外这样还有另外一个好处，就是能少一层方法栈的调用。
除了 inline （内联）这个关键字，还有另外一个关键字：noinline（禁止内联），大家可能到这里就摸不着头脑了，这个有啥用？我不在方法上面写 inline 不就是不会内联了么？那么这个关键字是有什么作用呢？其实这个关键字不是修饰在方法上面的，而是修饰在 lambda 参数上面的，假设一个 inline 函数上面有多个 lambda 参数，那么我只想对某个 lambda 参数内联，其他 lambda 参数不内联的情况下，就可以使用这个关键字来对不需要进行内联的 lambda 参数进行修饰，大体用法如下：

private inline fun showToast(function1: () -> Unit, noinline function2: () -> Unit, message: String) {
    function1.invoke()
    function2.invoke()
    ToastUtils.show(message)
}
复制代码

委托机制

类委托

先让我们来看一段代码

// 定义日志策略接口
interface ILogStrategy {

    fun log(message: String)
}
复制代码

// 实现一个默认的日志策略类
class LogStrategyImpl : ILogStrategy {

    override fun log(message: String) {
        Log.i("测试输出", message)
    }
}
复制代码

// 创建一个日志代理类
class LogStrategyProxy(strategy: ILogStrategy) : ILogStrategy by strategy
复制代码

看到这里大家可能有一些疑惑
- ILogStrategy by strategy 是虾米操作？
- LogStrategyProxy 这个类不去实现接口方法难道不会导致编译不通过么？
关于这两个问题，我觉得都可以用同一个解释，LogStrategyProxy 之所以不用实现 ILogStrategy 的 log 方法，是因为在 ILogStrategy 接口后面加了 by strategy，而 strategy 对象就是 LogStrategyProxy 构造函数中的变量，意思是让这个接口的具体实现由 strategy 对象帮我实现就可以了，我（LogStrategyProxy 类）不需要再实现一遍了，这样是不是跟 Java 中的静态代理很像？只不过在 Kotlin 类委托特性上面编译器帮我们自动生成接口方法的代码，你可以把它想象下面这样的代码：

class LogStrategyProxy(val strategy: ILogStrategy) : ILogStrategy {

    override fun log(message: String) {
        strategy.log(message)
    }
}
复制代码

有人肯定会问了：口说无凭，我凭什么相信你就是这样的代码？
这是个好问题，我提供一下反编译之后的代码，大家看一下就能明白了：

public final class LogStrategyProxy implements ILogStrategy {

    private final /* synthetic */ ILogStrategy $$delegate_0;
    
    public LogStrategyProxy(@NotNull ILogStrategy strategy) {
        Intrinsics.checkNotNullParameter(strategy, "strategy");
        this.$$delegate_0 = strategy;
    }

    public void log(@NotNull String message) {
        Intrinsics.checkNotNullParameter(message, "message");
        this.$$delegate_0.log(message);
    }
}
复制代码

是不是就立马顿悟了？调用的话也很简单，代码如下：

val logStrategyImpl = LogStrategyImpl()

LogStrategyProxy(logStrategyImpl).log("666666")
复制代码

最后让我们看看输出的日志：

测试输出: 666666
复制代码

这个我突然有一个大胆的想法，在使用类委托的情况下，再去重写它的接口方法呢？例如下面的：

class LogStrategyProxy(strategy: ILogStrategy) : ILogStrategy by strategy {

    override fun log(message: String) {
        println("测试输出 " + message)
    }
}
复制代码

关于这个问题我已经做过实践了，是木有问题的，大家放心大胆搞。

属性委托

看过了上面的类委托，想必大家对委托有一定的了解了，那么属性委托是什么呢？简单来讲，类委托是为了帮我们减少一些实现代码，而属性委托是为了帮我们控制变量的 Get、Set 的操作了，废话不多说，下面演示一下用法，下面先创建一个委托类

class XxxDelegate {

    // 先给它一个默认值
    private var currentValue: String = "666666"

    operator fun getValue(thisRef: Any?, property: KProperty<*>): String {
        println("测试字段名为 ${property.name} 的变量被访问了，当前值为 $currentValue")
        return currentValue
    }

    operator fun setValue(thisRef: Any?, property: KProperty<*>, newValue: String) {
        currentValue = newValue
        println("测试字段名为 ${property.name} 的变量被赋值了，当前值为 $currentValue" + "，新的值 $newValue")
    }
}
复制代码

使用代码示例如下：

var temp: String by XxxDelegate()
println("测试输出 " + temp)
temp = "55555"
println("测试输出 " + temp)
复制代码

具体日志输出如下：

System.out: 测试字段名为 temp 的变量被访问了，当前值为 666666
System.out: 测试输出 666666
System.out: 测试字段名为 temp 的变量被赋值了，当前值为 55555，新的值 55555
System.out: 测试字段名为 temp 的变量被访问了，当前值为 55555
System.out: 测试输出 55555
复制代码

看到这里你是否明白了，这个 XxxDelegate 类里面只有两个方法，一个是 getValue，另外一个是 setValue，从方法命名上我们已经能大致得出它的作用了，这里就不再多讲解了，var temp: String by XxxDelegate() 表示这个 temp 对象的创建会全权委托给 XxxDelegate 这个类来做。

懒委托

什么是懒委托呢？大家知道单例模式中的懒汉式吧？这个跟它差不多，只不过我们不需要写静态方法和锁机制了，只需要像下面这样写：

val temp: String by lazy {
    println("测试变量初始化了")
    return@lazy "666666"
}
复制代码

调用代码如下：

println("测试开始")
println("测试第一次输出 " + temp)
println("测试第二次输出 " + temp)
println("测试结束")
复制代码

输出日志如下：

System.out: 测试开始
System.out: 测试变量初始化了
System.out: 测试第一次输出 666666
System.out: 测试第二次输出 666666
System.out: 测试结束
复制代码

是不是真的跟懒汉式差不多？只不过这种写法简化了很多，另外在日常开发中我们可以用它来做 findViewById 是最适合不过的。

private val viewPager: ViewPager? by lazy { findViewById(R.id.vp_home_pager) }
复制代码

另外懒委托还提供了几种懒加载模式供我们选择，
- LazyThreadSafetyMode.SYNCHRONIZED：同步模式，确保只有单个线程可以初始化实例，这种模式下初始化时线程安全的，当 by lazy 没有指定模式的时候，就是默认用的这种模式。
- LazyThreadSafetyMode.PUBLICATION：并发模式，在多线程下允许并发初始化，但是只有第一个返回的值作为实例，这种模式下是线程安全的，和 LazyThreadSafetyMode.SYNCHRONIZED 最大区别是，这种模式在多线程并发访问下初始化效率是最高的，本质上面是用空间换时间，哪个的线程执行快就让哪个先返回结果，其他线程执行的结果抛弃掉。
- LazyThreadSafetyMode.NONE：普通模式，这种模式不会使用锁来限制多线程访问，所以是线程不安全的，所以请勿在多线程并发的情况下使用。
具体使用的方式也很简单，如下：

val temp: String by lazy(LazyThreadSafetyMode.NONE) {
    println("测试变量初始化了")
    return@lazy "666666"
}
复制代码

另外有一点需要注意，使用懒委托的变量必须声明为 val（不可变的），因为它只能被赋值一次。

扩展函数

扩展函数是 Kotlin 用于简化一些代码的书写产生的，其中有 let、with、run、apply、also 五个函数

let 函数

在函数块内可以通过 it 指代该对象。返回值为函数块的最后一行或指定 return 表达式
一般写法

fun main() {
    val text = "Android轮子哥"
    println(text.length)
    val result = 1000
    println(result)
}
复制代码

let 写法

fun main() {
    val result = "Android轮子哥".let {
        println(it.length)
        1000
    }
    println(result)
}
复制代码

最常用的场景就是使用let函数处理需要针对一个可 null 的对象统一做判空处理

videoPlayer?.setVideoView(activity.course_video_view)
videoPlayer?.setControllerView(activity.course_video_controller_view)
videoPlayer?.setCurtainView(activity.course_video_curtain_view)
复制代码

videoPlayer?.let {
   it.setVideoView(activity.course_video_view)
   it.setControllerView(activity.course_video_controller_view)
   it.setCurtainView(activity.course_video_curtain_view)
}
复制代码

又或者是需要去明确一个变量所处特定的作用域范围内可以使用

with 函数

前面的几个函数使用方式略有不同，因为它不是以扩展的形式存在的。它是将某对象作为函数的参数，在函数块内可以通过 this 指代该对象，返回值为函数块的最后一行或指定 return 表达式
定义 Person 类

class Person(var name : String, var age : Int)
复制代码

一般写法

fun main() {
    var person = Person("Android轮子哥", 100)
    println(person.name + person.age)
    var result = 1000
    println(result)
}
复制代码

with 写法

fun main() {
    var result = with(Person("Android轮子哥", 100)) {
        println(name + age)
        1000
    }
    println(result)
}
复制代码

适用于调用同一个类的多个方法时，可以省去类名重复，直接调用类的方法即可，经常用于 Android 中 RecyclerView.onBinderViewHolder 中，数据 model 的属性映射到 UI 上

override fun onBindViewHolder(holder: ViewHolder, position: Int){
    val item = getItem(position)?: return
    holder.nameView.text = "姓名：${item.name}"
    holder.ageView.text = "年龄：${item.age}"
}
复制代码

override fun onBindViewHolder(holder: ViewHolder, position: Int){
    val item = getItem(position)?: return
    with(item){
        holder.nameView.text = "姓名：$name"
        holder.ageView.text = "年龄：$age"
    }
}
复制代码

run 函数

实际上可以说是 let 和 with 两个函数的结合体，run 函数只接收一个 lambda 函数为参数，以闭包形式返回，返回值为最后一行的值或者指定的 return 的表达式
一般写法

var person = Person("Android轮子哥", 100)
println(person.name + "+" + person.age)
var result = 1000
println(result)
复制代码

run 写法

var person = Person("Android轮子哥", 100)
var result = person.run {
    println("$name + $age")
    1000
}
println(result)
复制代码

适用于 let，with 函数任何场景。因为 run 函数是let，with两个函数结合体，准确来说它弥补了 let 函数在函数体内必须使用 it 参数替代对象，在 run 函数中可以像 with 函数一样可以省略，直接访问实例的公有属性和方法，另一方面它弥补了 with 函数传入对象判空问题，在 run 函数中可以像l et 函数一样做判空处理，这里还是借助 onBindViewHolder 案例进行简化

override fun onBindViewHolder(holder: ViewHolder, position: Int){
    val item = getItem(position)?: return
    holder.nameView.text = "姓名：${item.name}"
    holder.ageView.text = "年龄：${item.age}"
}
复制代码

override fun onBindViewHolder(holder: ViewHolder, position: Int){
    val item = getItem(position)?: return
    item?.run {
        holder.nameView.text = "姓名：$name"
        holder.ageView.text = "年龄：$age"
    }
}
复制代码

apply 函数

从结构上来看 apply 函数和 run 函数很像，唯一不同点就是它们各自返回的值不一样，run 函数是以闭包形式返回最后一行代码的值，而 apply 函数的返回的是传入对象的本身
一般写法

val person = Person("Android轮子哥", 100)
person.name = "HJQ"
person.age = 50
复制代码

apply 写法

val person = Person("Android轮子哥", 100).apply {
    name = "HJQ"
    age = 50
}
复制代码

整体作用功能和 run 函数很像，唯一不同点就是它返回的值是对象本身，而 run 函数是一个闭包形式返回，返回的是最后一行的值。正是基于这一点差异它的适用场景稍微与 run 函数有点不一样。apply 一般用于一个对象实例初始化的时候，需要对对象中的属性进行赋值。或者动态 inflate 出一个 XML 的 View 的时候需要给 View 绑定数据也会用到，这种情景非常常见。特别是在我们开发中会有一些数据 model 向 View model 转化实例化的过程中需要用到

mRootView = View.inflate(activity, R.layout.example_view, null)
mRootView.tv_cancel.paint.isFakeBoldText = true
mRootView.tv_confirm.paint.isFakeBoldText = true
mRootView.seek_bar.max = 10
mRootView.seek_bar.progress = 0
复制代码

使用 apply 函数后的代码是这样的

mRootView = View.inflate(activity, R.layout.example_view, null).apply {
   tv_cancel.paint.isFakeBoldText = true
   tv_confirm.paint.isFakeBoldText = true
   seek_bar.max = 10
   seek_bar.progress = 0
}
复制代码

多层级判空问题

if (sectionMetaData == null || sectionMetaData.questionnaire == null || sectionMetaData.section == null) {
    return;
}
if (sectionMetaData.questionnaire.userProject != null) {
    renderAnalysis();
    return;
}
if (sectionMetaData.section != null && !sectionMetaData.section.sectionArticles.isEmpty()) {
    fetchQuestionData();
    return;
}
复制代码

kotlin 的 apply 函数优化

sectionMetaData?.apply {

	// sectionMetaData 对象不为空的时候操作sectionMetaData

}?.questionnaire?.apply {

	// questionnaire 对象不为空的时候操作questionnaire

}?.section?.apply {

	// section 对象不为空的时候操作section

}?.sectionArticle?.apply {

	// sectionArticle 对象不为空的时候操作sectionArticle

}
复制代码

also 函数

also 函数的结构实际上和 let 很像唯一的区别就是返回值的不一样，let 是以闭包的形式返回，返回函数体内最后一行的值，如果最后一行为空就返回一个 Unit 类型的默认值。而 also 函数返回的则是传入对象的本身

fun main() {
    val result = "Android轮子哥".let {
        println(it.length)
        1000
    }
    println(result) // 打印：1000
}
复制代码

fun main() {
    val result = "Android轮子哥".also {
        println(it.length)
    }
    println(result) // 打印：Android轮子哥
}
复制代码

适用于 let 函数的任何场景，also 函数和 let 很像，只是唯一的不同点就是 let 函数最后的返回值是最后一行的返回值而 also 函数的返回值是返回当前的这个对象。一般可用于多个扩展函数链式调用

运算符重载

在 Kotlin 中使用运算符最终也会调用对象对应的方法，我们可以通过重写这些方法使得这个对象支持运算符，这里不再演示代码

运算符	调用方法
+a	a.unaryPlus()
-a	a.unaryMinus()
!a	a.not()

运算符	调用方法
a++	a.inc()
a--	a.dec()

运算符	调用方法
a + b	a.plus(b)
a - b	a.minus(b)
a * b	a.times(b)
a / b	a.div(b)
a % b	a.rem(b), a.mod(b) (deprecated)
a..b	a.rangeTo(b)

运算符	调用方法
a in b	b.contains(a)
a !in b	!b.contains(a)

运算符	调用方法
a[i]	a.get(i)
a[i, j]	a.get(i, j)
a[i_1, ..., i_n]	a.get(i_1, ..., i_n)
a[i] = b	a.set(i, b)
a[i, j] = b	a.set(i, j, b)
a[i_1, ..., i_n] = b	a.set(i_1, ..., i_n, b)

运算符	调用方法
a()	a.invoke()
a(i)	a.invoke(i)
a(i, j)	a.invoke(i, j)
a(i_1, ..., i_n)	a.invoke(i_1, ..., i_n)

运算符	调用方法
a += b	a.plusAssign(b)
a -= b	a.minusAssign(b)
a *= b	a.timesAssign(b)
a /= b	a.divAssign(b)
a %= b	a.remAssign(b), a.modAssign(b) (deprecated)

运算符	调用方法
a == b	a?.equals(b) ?: (b === null)
a != b	!(a?.equals(b) ?: (b === null))

运算符	调用方法
a > b	a.compareTo(b) > 0
a < b	a.compareTo(b) < 0
a >= b	a.compareTo(b) >= 0
a <= b	a.compareTo(b) <= 0

全民 Kotlin：你没有玩过的全新玩法

本文章已授权鸿洋微信公众号转载

目录

空安全

方法支持添加默认参数

方法上面的参数不可变

类方法扩展

函数变量

内联函数

委托机制

类委托

属性委托

懒委托

扩展函数

let 函数

with 函数

run 函数

apply 函数

also 函数

运算符重载

下一篇：全民 Kotlin：协程特别篇

另外推荐一个 Kotlin 语言编写的开源项目，大家感兴趣可以看看：AndroidProject-Kotlin

Android 技术分享 QQ 群：78797078

Guess you like