前言

高阶函数系列文章：

Kotlin 高阶函数从未如此清晰（上）
Kotlin 高阶函数从未如此清晰（中）
Kotlin 高阶函数从未如此清晰（下） let/also/with/run/apply/repeat 一看就会

上篇讲到了Kotlin 高阶函数定义以及如何使用Lambda进行简化调用，本篇接着来分析未尽事项。
通过本篇文章，你将了解到：

1、Kotlin 泛型初探
2、Kotlin 扩展函数的原理与使用
3、Koltin 内联函数的原理与使用

1、Kotlin 泛型初探

Java 泛型

我们知道Java 泛型是为了在编译时期做类型安全检查，本质上就是参数化类型。
以熟知的List为例，List<T> 是泛型接口，ArrayList<T> 是泛型类，若是没有使用泛型时：

    private void test1() {
        List nameList = new ArrayList();
        //添加字符串
        nameList.add("fish");
        //添加数字
        nameList.add(3);
    }

本意是构建了一个存储名字的List，也就是说该List里的元素是字符串，而上述添加Int 类型的元素却是没报错，因此编译器认为里面的元素都是Object类型，当我们需要取出元素时，就需要强转Object为对应的类型：

        String ss = (String)nameList.get(0);
        int age = (int)nameList.get(1);

强转在类型错误在编译时期是不会被发现的，只能在运行期间才会暴露。
再看看引入了泛型的List:

    private void test2() {
        List<String> nameList = new ArrayList();
        //添加字符串
        nameList.add("fish");
        //添加数字
        nameList.add("forest");
        //编译器不允许
//        nameList.add(3);
        
        //无需强转
        String name1 = nameList.get(0);
        String name2 = nameList.get(1);
    }

可以看出，在编译时期就进行了类型检测，提取元素时无需强转，同时也避免了一些自动拆装箱操作。

Kotlin 泛型

Kotlin 里的泛型和Java 里的泛型功能类似：

//泛型类
class A<T> {}

//泛型接口
interface B<T>{}

//泛型方法
fun <T> pick(a : T) {}

来看个实例：

class Fruit<T> {
    var quality:T? = null

    get() {
        println("$field")
        return field
    }

    fun setValue(t:T) {
        this.quality = t
    }
}

fun main(args: Array<String>) {
    var fruit:Fruit<String> = Fruit()
    fruit.setValue("jj")
    //编译不通过
//    fruit.setValue(33)
    fruit.quality
}

Fruit里的quality 可以是任何类型。
此处仅仅只是简单阐述Kotlin 泛型的写法及使用（为方便下一个小结理解常用的高阶函数），协变、逆变、星号等以及与Java 上下界通配符比对后续会单独开一篇分析。

2、Kotlin 扩展函数的原理与使用

扩展函数原理

先看简单例子：

class Student {
    //来自省份
    var province:String?= null
    //学生名字
    var name:String? = null
    init {
        name = "fish"
        province = "beijing"
    }
    fun printStudent() {
        println("$name")
    }
}

fun main(args: Array<String>) {
    var student = Student()
    student.printStudent()
}

Student类里有个printStudent()函数，打印学生的信息。现在有个需求想要打印名字的同时还打印省份。
你可能会说：直接在printStudent()加入打印省份信息不就得了？
如果是第三方的文件呢？咱们没权限修改源文件，在Java 里我们一般通过包装Student类，再提供打印学生姓名和省份的方法。
而Koltin里更简洁，可以直接对这个类进行函数扩展。

fun main(args: Array<String>) {
    var student = Student()
    student.printStudent1()
}
//扩展函数
fun Student.printStudent1() {
    println("name:$name province:$province")
}

以后在任何一个地方，只要想要打印姓名和省份都可以使用printStudent1()方法。
通过反编译结果，来看看扩展函数的原理：

public static final void printStudent1(@NotNull Student $this$printStudent1) {
    Intrinsics.checkNotNullParameter($this$printStudent1, "$this$printStudent1");
    String var1 = "name:" + $this$printStudent1.getName() + " province:" + $this$printStudent1.getProvince();
    boolean var2 = false;
    System.out.println(var1);
}

当扩展一个类的函数时，实际上传入了该类的对象，通过对象拿到属性/函数并操作。

因此，其本质上还是通过类的对象实例来组合各种操作。

假若现在将"province" 访问权限修改为"private"，那么printStudent1 将无法访问到该属性。

扩展函数使用

扩展函数在扩展第三方库时非常有效，从原理上看我们知道它是没有任何副作用的。
假若我们来扩展String类，希望新增一个函数：判断String 首字母是否是大小。

fun String.isFirstUpper():Boolean {
    if (isNotEmpty()) {
        //判断字符范围
        return get(0).code in 65..97
    }
    return false
}

在Kotlin里调用：

fun main(args: Array<String>) {
    var student = Student()
    student.printStudent1()

    var b1 = "Fish".isFirstUpper()
    var b2 = "1Fish".isFirstUpper();
    println("$b1 $b2")
}

在Java里调用：

    private void testExpand() {
        //需要传入扩展类的对象实例
        boolean b1 = ExpandFunKt.isFirstUpper("Fish");
        boolean b2 = ExpandFunKt.isFirstUpper("1fish");
    }

扩展函数与成员函数异同

1、扩展函数不能访问"private" 修饰的函数和属性。
2、扩展函数不会影响原有类的构成（不属于类本身，不能被子类继承）。
3、扩展函数调用方式与成员函数调用方式类似，都可以通过对象调用。

3、Koltin 内联函数的原理与使用

内联函数原理

//普通函数
fun normalFun1() {
    println("normal fun")
}
//内联函数
inline fun inlineFun2() {
    println("inline fun")
}
fun main(args: Array<String>) {
    normalFun1()
    inlineFun2()
}

输出结果都很正常，看不出来啥。从写法上看，fun2比fun1 多了"inline"修饰。
接着看看反编译结果：

    public static final void main(@NotNull String[] args) {
        Intrinsics.checkNotNullParameter(args, "args");
        //函数调用
        normalFun1();
        int $i$f$inlineFun2 = false;
        //函数体替换
        String var2 = "inline fun";
        boolean var3 = false;
        System.out.println(var2);
    }

可以看出，当使用"inline" 修饰时，整个函数体被调用方直接复制过去了，而没有使用"inline"修饰时，则是正常的函数调用，这期间会经过：

函数局部变量、返回值等入栈，函数执行完成后出栈，继续从调用处往下执行。

压栈、出栈过程有一定的开销。

内联函数的使用

虽然使用内联可以减少一定的开销，但是不是每个地方都适合用内联修饰的。试想，若是都是内联函数，那么调用内联函数的时候会将整个函数体（实现）拷贝到调用处，如果是多次调用呢？岂不是重复的代码很多？
因此，在Kotlin 里普通函数是无需使用内联修饰的，我们上面的代码编译器会提示：

image.png
意思是：此种场景下使用内联对性能是没有提升的。
什么场景下使用呢？答案是函数参数是函数类型时使用。
定义高阶函数：

fun inlineFun3(block: (Int) -> String): String {
    println("execute fun3")
    return block(3)
}

其参数block 即为函数类型的变量，此处用Lambda表示。
调用inlineFun3：

fun main(args: Array<String>) {
    var str = inlineFun3 {
        if (it > 3) {
            ">3"
        } else {
            "<=3"
        }
    }
    println("str $str")
}

看反编译结果：

   public static final void main(@NotNull String[] args) {
      String str = inlineFun3((Function1)null.INSTANCE);
      String var2 = "str " + str;
      boolean var3 = false;
      System.out.println(var2);
   }

可以看出上面的block 变为了Function1，当调用一个高阶函数时，其函数类型的参数最终都会编译为FunctionX 接口。
也就是说当调用inlineFun3()时，内部是生成了一个FunctionX的对象。
而当我们用inline 修饰inlineFun3()时，最终的反编译如下：

inline fun inlineFun3(block: (Int) -> String): String {
    println("execute fun3")
    return block(3)
}

public static final void main(@NotNull String[] args) {
        String var3 = "execute fun3";
        System.out.println(var3);
        int it = 3;
        String str = it > 3 ? ">3" : "<=3";
        String var7 = "str " + str;
        System.out.println(var7);
    }

总结来说，使用inline 修饰高阶函数有两个好处：

1、当调用高阶函数时，可以避免生成对象，减少开销。
2、同时减少了函数调用的压栈出栈开销。

内联函数规则

参数传递规则

inline fun inlineFun4(block: (Int) -> String): String {
    println("execute fun4")
    //编译错误
    return inlineFun5(block)
}
fun inlineFun5(block: (Int) -> String): String {
    return block(3)
}

如上写法编译器会报错：内联函数的函数类型参数不能作为实参传递给另一个非内联函数。
inlineFun4 是内联函数，其形参为block，inlineFun5 是非内联函数，要想编译通过有两种方式：

1、inlineFun5 加上inline 修饰。
2、block 加上 noinline（禁止内联）修饰。

第二点对应如下：

inline fun inlineFun4(noinline block: (Int) -> String): String {
    println("execute fun4")
    return inlineFun5(block)
}

Return 规则

在上一篇中有说过：Lambda使用最后一条语句作为返回值，在Lambda里不能显示调用return。

fun inlineFun6(block: (Int) -> String): String {
    println("execute fun6")
    return block(3)
}

fun testReturn(): String {
    var str = inlineFun6 {
        if (it > 3) {
            ">3"
        } else {
            "<=3"
        }
        //编译错误
        return "fish"
    }
    println("execute inlineFun6 str:$str")
    return "fish"
}

此时的return 是不被允许的。
当然，也可以改造为如下：

fun testReturn(): String {
    var str = inlineFun6 {
        if (it > 3) {
            ">3"
        } else {
            "<=3"
        }
        //编译错误
        return@inlineFun6 "fish"
    }
    println("execute inlineFun6 str:$str")
    return "fish"
}

运行后发现，return 退出了inlineFun6函数的执行，但还是执行到了"println("execute inlineFun6 str:$str")"，说明该return 函数并没有退出testReturn。此时给inlineFun6函数加上inline 修饰：

inline fun inlineFun6(block: (Int) -> String): String {
    println("execute fun6")
    return block(3)
}
fun testReturn(): String {
    var str = inlineFun6 {
        if (it > 3) {
            ">3"
        } else {
            "<=3"
        }
        //直接return
        return "fish"
    }
    println("execute inlineFun6 str:$str")
    return "fish"
}

Lambda里可以使用return函数，并且return 后退出了testReturn()函数。
由此可见：

当inline 修饰带有函数类型参数的函数时，在Lambda里可以使用return，并且执行到该return 语句时可以退出外层函数。

了解了泛型、扩展函数、内联函数，下篇将会分析常用的一些高阶函数：let/also/with/run/apply/repeat 的原理及其应用场景。

本文基于Kotlin 1.5.3，文中Demo请点击

您若喜欢，请点赞、关注，您的鼓励是我前进的动力

持续更新中，和我一起步步为营系统、深入学习Android/Kotlin

1、Android各种Context的前世今生
2、Android DecorView 必知必会
3、Window/WindowManager 不可不知之事
4、View Measure/Layout/Draw 真明白了
5、Android事件分发全套服务
6、Android invalidate/postInvalidate/requestLayout 彻底厘清
7、Android Window 如何确定大小/onMeasure()多次执行原因
8、Android事件驱动Handler-Message-Looper解析
9、Android 键盘一招搞定
10、Android 各种坐标彻底明了
11、Android Activity/Window/View 的background
12、Android Activity创建到View的显示过
13、Android IPC 系列
14、Android 存储系列
15、Java 并发系列不再疑惑
16、Java 线程池系列
17、Android Jetpack 前置基础系列
18、Android Jetpack 易懂易学系列