Kotlin的Android广播、高阶函数探究（三）

1、repeat函数
2、扩展函数
3、运算符重载 operator
4、动态注册一个广播
5、高阶函数
6、内联函数 inline
7、oninline、crossinline

• 1、repeat函数

定义： repeat定义传入int参数，传入几。被包裹的内容就循环几次。

fun getRepeat(string: String) {
    val intRange = (1..20).random()
    val stringBuilder = StringBuilder()
    //定义 参数是几就循环几次
    repeat(intRange) {
        stringBuilder.append(string + "\n")
    }
    println(stringBuilder.toString())
}

• 2、扩展函数

定义 ：可以对对象进行扩展，扩展后可直接调用。举个例子吧
假设 一个字符串 “ABC123xyz11zzz1!@#”，我们想知道它的字母数量。用代码写的话，可以通过isLetter来判定。
常用写法：

fun main() {
    val sss = "ABC123xyz11zzz1!@#"
    val letterCount = getLetterCount(sss)
    println(sss)
}

fun getLetterCount(string: String): Int {
    var count = 0
    for (char in string) {
        if (char.isLetter()) {
            count++
        }
    }
    return count
}

我们知道sss是String类型， 接下来对String进行扩展。
扩展方法如下：

fun main() {
    val sss = "ABC123xyz11zzz1!@#".letterCount()
    println(sss)
}

fun String.letterCount(): Int {
    var count = 0
    for (char in this) {
        if (char.isLetter()) {
            count++
        }
    }
    return count
}

扩展之后不用传入参数了，可直接通过扩展的对象类型去获取该方法。this表示传入的参数值

更深入的了解可以看“鸿洋”发的https://mp.weixin.qq.com/s/CSlQHKZRdhAChbPrXsKLXA

• 3、运算符重载 operator

运算符重载使用的是operator关键字，只要在制定函数的前面加上operator关键字就可以实验运算符重载的功能了。

先来看看语法糖表达式和实际调用函数对照表

语法糖表达式和实际调用函数对照表.png

比如说是contains函数可以这么写：

    if ("hello".contains("he")) {
        println("111")
    }

因为语法糖表达式可以对上述进行简写：

    val b = "he" in "hello"
    println(b)

这两种写法的效果是一样的。明白语法糖了吗？

• 接下来对（1、repeat）的方法进行运算符的重载

fun getRepeat(string: String) {
    val intRange = (1..20).random()
    val stringBuilder = StringBuilder()
    //定义 参数是几就循环几次
    repeat(intRange) {
        stringBuilder.append(string + "\n")
    }
    println(stringBuilder.toString())
}

repeat我们知道将传入的字符重复n次，如果能把这个重复写成 str * n来表示Str重复n次，这种语法相对来说就更舒适~

operator fun String.times(n: Int): String {
    val stringBuilder = StringBuilder()
    repeat(n) {
        stringBuilder.append(this)
    }
    return stringBuilder.toString()
}

val s = "hello" * (1..20).random()
    println(s)

这样就跟最开始的写法一样，是不是更简便呢。而a.times也表示了乘。

• 4、动态注册一个广播

class RecevierActivity : AppCompatActivity() {

    private lateinit var myReceiver1: MyReceiver

    override fun onCreate(savedInstanceState: Bundle?) {
        super.onCreate(savedInstanceState)
        setContentView(R.layout.activity_recevier)

        ///Volumes/personal/androidsdk/platforms/android-28/data/broadcast_actions.txt
        val intentFilter = IntentFilter()
        intentFilter.addAction("android.intent.action.TIME_TICK")
        myReceiver1 = MyReceiver()
        registerReceiver(myReceiver1, intentFilter)

    }

    inner class MyReceiver : BroadcastReceiver() {
        override fun onReceive(context: Context?, intent: Intent?) {
            ToastUtils.show(this@RecevierActivity, "this receiver")
        }
    }

    override fun onDestroy() {
        super.onDestroy()
        unregisterReceiver(myReceiver1)
    }
}

广播的类别形式跟Java还是一样的， 书写的方式如上。别的广播就不写了，大同小异。
我这里只是监听了一下 系统时间发生变化的 action，更多的action可以在sdk的platforms/android-28/data/broadcast_actions.txt文件里看到。
涉及到的一些版本差异，权限此处不过多讲解。有兴趣可自己看看

• 5、高阶函数

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

(String , Int) -> Unit

fun example1(fune: (String, Int) -> Unit) {
    fune("hello", 1)
}

这就代表了一个简单的高阶函数， fune这个函数作为参数， 而Unit则代表的是无返回类型，就跟void一个意思。

• 接下来更深入一些：

fun example(n1: Int, n2: Int, opear: (Int, Int) -> Int): Int {
    val opear1 = opear(n1, n2)
    return opear1
}

n1，n2传入俩Int参数 ， 可以看到把n1n2给了opear这个方法，来操作执行。opear的执行是可以自定义的。 假设如下：

fun plus(i: Int, i1: Int): Int {
    return i + i1
}

fun minus(i: Int, i1: Int): Int {
    val i2 = i - i1
    return i2
}

显而易见minus 和plus执行的逻辑不一样，我们传入上述的方法里

    val n1 = 100
    val n2 = 50
    val gaoji = example(n1, n2, ::plus)
    println(gaoji)

可以发现这个执行结果是可以自定义的，这就是高阶函数。
更高级的写法，定义个专属StringBuilder的apply

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

    val build = StringBuilder().build {
        append("this")
        append("this")
    }
    println(build.toString())

功能跟apply一样，只不过没有涉及到泛型的概念。

• 也可以用lambda来写：

    val n1 = 100
    val n2 = 50
    val example = example(n1, n2) { n1, n2 ->
        n1 + n2
    }
    println(example)

• 6、内联函数

    val n1 = 100
    val n2 = 50
    val example = example(n1, n2) { n1, n2 ->
        n1 + n2
    }
    println(example)

我们都知道，Kotlin代码最终还是要编译成Java字节码的，而Java中并没有高阶函数的概念。那究竟怎么做的呢？

上面的代码最终会被转换：
Lambda表达式会变成Function接口的匿名类实现，然后在invoke()函数中调用n1 + n2的逻辑，并将结果返回。我们一直使用的Lambda表达式在底层被转换成了匿名类的实现方式，这表明我们每调用一次Lambda表达式，都会创建一个新的匿名类实例，当然也会造成额外的内存和性能开销。为了解决这个问题，Kotlin提供了内联函数的功能，可以把开销完全消除~

inline fun example(n1: Int, n2: Int, opear: (Int, Int) -> Int): Int {
    val opear1 = opear(n1, n2)
    return opear1
}

Kotlin编译器会将内联函数中的代码在编译的时候自动替换到调用它的地方，这样也就不存在运行时的开销了。 上述的方法加了内联后，在编译时等于下面代码

    val n1 = 100
    val n2 = 50
    val example = n1 + n2 
    println(example)

val example = n1 + n2

• noline

如果一个高阶函数接收了两个或者更多的函数类型参数，这时如果我们加上了inline的话，Kotlin会把所有引用lambda的都进行内联，但如果我只是想内联其中的某一个Lambda呢。

inline fun printString(ss: String, bolck: (String) -> Unit, noinline bolck2: (String) -> Unit) {
}

加上noinline修饰就可以了~

内联和非内联除了上述之外，还有个重要的点就是内联是可以通过return来返回的，来非内联只能局部返回。
比如非内联：

    val str = "main start"
    printString(str) { string ->
        println("lambda1111")
        return@printString
        println("lambda2222")
    }

//
fun printString(ss: String, bolck: (String) -> Unit) {
    println("printString111")
    bolck(ss)
    println("printString222")
}

log->
printString111
lambda1111
printString222

这里使用了@printString，用来表示局部返回。

内联函数：

    val str = "main start"
    printString(str) { string ->
        println("lambda1111")
        return
        println("lambda2222")
    }

inline fun printString(ss: String, bolck: (String) -> Unit) {
    println("printString111")
    bolck(ss)
    println("printString222")
}

log->
printString111
lambda1111

对比非内联可以发现，内联的可以直接使用return，并且返回出当前函数

• crossinline
  将高阶函数声明成内联函数来讲是个好的编码习惯，绝大部分都是可以的，但也存在例外：

fun runRunable(bolck: () -> Unit) {
    val runnable = Runnable {
        bolck()
    }
    runnable.run()
}

如果将上述代码声明成内联会报错

inline fun runRunable(bolck: () -> Unit) {
    val runnable = Runnable {
        bolck()
    }
    runnable.run()
}

Can't inline 'bolck' here: it may contain non-local returns. Add 'crossinline' modifier to parameter declaration 'bolck'

这块报错的意思就是说，
Lambda表达式在编译的时候会被转换成匿名类的实现方式， 而上述代码实际上 就是在匿名类中调用传入的函数类型参数。 而内联所引用的Lambda表达式允许使用return关键字进行函数返回，但是由于我们是在匿名类中调用函数参数，此时是不可能进行外层调用函数返回的，最多只能对匿名类中的函数调用进行返回，因此报错。
也就是说，如果我们在高阶函数中创建了另外的Lambda或者匿名类的实现，并且在这些实现中调用函数类型参数，此时再将高阶函数声明成内联函数，就一定会提示错误。

这种情况下不是不能使用内联了，只需要在函数类型参数上修饰 crossinline就可以解决这个问题。

inline fun runRunable(crossinline bolck: () -> Unit) {
    val runnable = Runnable {
        bolck()
    }
    runnable.run()
}

crossinline的作用就像是一种保证，保证在内联函数的Lambda表达式中一定不会使用return关键字，这样冲突就不存在了。~