关于android:给-Android-开发者的-Kotlin-教程三

一、前言

<font face= 黑体>在 给 Android 开发者的 Kotlin 教程（二）中咱们讲了 Kotlin 的必备根底，别离是 Kotlin 中的<font color= red>根本数据类型、数组</font>以及<font color= red>汇合</font>这三大知识点。

<font face= 黑体>这一节咱们来讲一下 Kotlin 中的<font color= red>办法</font>和<font color= red> Lambda 表达式</font>这两个知识点。

二、Kotlin 办法

<font face= 黑体>在 Java 中对象是最重要的，而在 Kotlin 中，办法才是最重要的，Kotlin 中办法是能够间接定义在文件外面的，不须要肯定定义在类外面。

2.1、办法申明

<font face= 黑体>Kotlin 中一个办法的根本格局如下所示：

<font face= 黑体>具体代码实现

fun plus(a: Int, b: Int): Int {
    return a + b
}

2.1.1、类的成员办法

<font face= 黑体>类的成员办法的写法

class Person {
       // 成员办法
    fun test1() {
        println("成员办法")
    }
}

<font face= 黑体>成员办法的调用形式

fun main() {
    Person().test1()
}

2.1.2、类办法（静态方法）

<font face= 黑体>Kotlin 中并没有 static 关键字，不过咱们能够借助companion object(Kotlin 的伴生对象) 来实现类办法的目标。

<font face= 黑体>静态方法的写法

class Person {
    companion object {
        fun test2() {
            println("companion object 实现类办法")
        }
    }
}

<font face= 黑体>静态方法的调用

 Person.test2()

2.1.3、静态方法

<font face= 黑体>在 Kotlin 中如果咱们想实现一个工具类 util 的话，能够借助 object 关键字，用 object 关键字润饰的类中的办法都是”静态方法”。

<font face= 黑体>object 润饰的类的写法

object NumUtil {
    fun double(num: Int): Int {
        return num * 2
    }
}

<font face= 黑体>静态方法的调用

println("umUtil.double(2): ${NumUtil.double(2)}")

2.1.4、单表达式办法

当办法返回单个表达式时，能够省略花括号并且在 = 符号之后指定代码体即可。

<font face= 黑体>单表达式办法的写法

fun double(x: Int): Int = x * 2

2.2、办法参数

2.2.1、默认参数

<font face= 黑体>在 Kotlin 中，能够给办法设置一些默认参数，当省略相应的参数时应用默认参数值。与 Java 相比，这能够缩小重载数量。

<font face= 黑体>默认参数写法

// off 的默认值就是 0， len 的默认值就是 b.size
fun read(b: Array<Byte>, off: Int = 0, len: Int = b.size) {

}

2.2.2、可变数量的参数

<font face= 黑体>在 Java 中利用 …(比方 String…) 来设置可变类型的参数，在 Kotlin 中是通过 vararg 修饰符标记参数来实现可变参数的。

<font face= 黑体>可变参数写法

// 通过 vararg 润饰
fun append(vararg str: Char): String {
    val result = StringBuffer()
    for (char in str) {
        result.append(char)
    }

    return result.toString()
}

<font face= 黑体>可变参数办法的调用

println(append('h', 'e', 'l', 'l', 'o'))

2.3、办法作用域

<font face= 黑体>在 Kotlin 中办法能够在文件顶层申明，这意味着你不须要像 Java 那样须要创立一个类来保留一个办法。

<font face= 黑体>此外除了顶层办法，Kotlin 中办法也能够申明在部分作用域、作为成员办法以及扩大办法。

2.3.1、部分办法

<font face= 黑体>部分办法写法

fun rand(): Int {
    // 部分办法
    fun square(v: Int): Int {
        return v * v
    }
    
    // 生成 0 到 100 的随机数（包含0、100）
    val v1 = (0..100).random()
    return square(v1)
}

<font face= 黑体>部分办法的调用

println(rand())

三、Lambda 表达式

<font face= 黑体>Java 是在 Java 8 的时候开始反对Lambda表达式的，目前 Lambda 语法在 Java 中曾经被宽泛的使用，Lambda 表达式能够了解为是一种语法糖，值得庆幸的是，Kotlin 一经开源就曾经反对这种语法。

<font face= 黑体>Lambda 作为办法式编程的根底，其语法也是相当简略的。这里先通过一段简略的代码演示没来理解一下 Lambda 表达式的简洁之处。

<font face= 黑体>点击事件，未用 Lambda 表达式

view.setOnClickListener(new View.OnClickListener() {
    @Override
    public void onClick(View v) {
        Toast.makeText(context, "Lambda 简洁之道", Toast.LENGTH_LONG).show();
    }
});

<font face= 黑体>点击事件，应用 Lambda 表达式

view.setOnClickListener { v -> Toast.makeText(context, "Lambda简洁之道", Toast.LENGTH_LONG).show() }

3.1、Lambda 表达式语法

<font face= 黑体>无参数状况

val/var 变量名 = { 操作的代码 }

fun test() {
    println("无参数")
}

// 将上述代码革新成应用 Lambda 表达式代码
val test1 = { println("无参数") }

<font face= 黑体>有参数状况

val/var 变量名 : (参数的类型，参数类型，...) -> 返回值类型 = {参数1，参数2，... -> 操作参数的代码 }

// 此种写法：即表达式的返回值类型会依据操作的代码自推导进去。
val/var 变量名 = { 参数1 ： 类型，参数2 : 类型, ... -> 操作参数的代码 }

fun test2(a: Int, b: Int): Int {
    return a + b
}

// 将上述代码革新成应用 Lambda 表达式代码
val test3: (Int, Int) -> Int = { a, b -> a + b }
// Lambda 表达式代码简化
val test4 = { a: Int, b: Int -> a + b }

3.2、意识Kotlin 中的 it

<font face= 黑体>it 并不是 Kotlin 中的一个关键字，it是在当一个高阶办法中 Lambda 表达式的参数只有一个的时候能够应用 it 来应用此参数，it 可示意为单个参数的隐式名称，是 Kotlin 语言约定的。

<font face= 黑体>单个参数的隐式名称

// 过滤掉数组中小于 5 的元素，这里的 it 就示意每一个元素
fun test5() {
    val arr = arrayOf(1, 2, 3, 4, 5)
    println("test5${arr.filter { it < 5 }}")
}

3.2、在 Lambda 表达式中应用_

<font face= 黑体>在应用 Lambda 表达式的时候，能够用下划线(_)示意未应用的参数，示意不解决这个参数。

<font face= 黑体>当遍历 Map 汇合的时候，用途非常明显

fun test6() {
    val map = mapOf("key1" to "value1", "key2" to "value2", "key3" to "value3")
    
    map.forEach { (key, value) ->
        println("$key \t $value")
    }

    // 不须要key的时候
    map.forEach { (_, value) ->
        println(value)
    }
}

四、残缺代码

fun main() {
    println("functionLearn: ${functionLearn(101)}")
    Person().test1()
    Person.test2()
    println("umUtil.double(2): ${NumUtil.double(2)}")
    println("double(2): ${double(2)}")
    println(append('a', 'b', 'c'))
    println(magic())

    // lambda
    test1()
    println(test3(1, 3))
    test5()
    test6()
}

fun plus(a: Int, b: Int): Int {
    return a + b
}

fun functionLearn(days: Int): Boolean {
    return days > 100
}

class Person {
    /**
     * 成员办法
     */
    fun test1() {
        println("成员办法")
    }

    companion object {
        fun test2() {
            println("companion object 实现类办法")
        }
    }
}

/**
 * 整个动态类
 */
object NumUtil {
    fun double(num: Int): Int {
        return num * 2
    }
}

/**
 * 单表达式办法，当办法当个表达式时，能够省略花括号并且在 = 符号之后指定代码体即可
 */
fun double(x: Int): Int = x * 2


/**
 * 默认值，办法参数能够由默认值，当省略相应的参数时应用默认值。与Java相比，这能够缩小重载数量
 */
fun read(b: Array<Byte>, off: Int = 0, len: Int = b.size) {

}

/**
 * 可变数量参数
 */
fun append(vararg str: Char): String {
    val result = StringBuffer()
    for (char in str) {
        result.append(char)
    }

    return result.toString()
}

/**
 * 部分办法
 */
fun magic(): Int {
    fun foo(v: Int): Int {
        return v * v
    }

    val v1 = (0..100).random()
    return foo(v1)
}


/**
 * 无参数状况
 */
fun test() {
    println("无参数")
}

val test1 = { println("无参数") }// lambda代码


/**
 * 有参数
 */
fun test2(a: Int, b: Int): Int {
    return a + b
}

val test3: (Int, Int) -> Int = { a, b -> a + b }// lambda代码
val test4 = { a: Int, b: Int -> a + b }// lambda代码简化

fun test5() {
    val arr = arrayOf(1, 2, 3, 4, 5)
    println("test5${arr.filter { it < 5 }}")
}

fun test6() {
    val map = mapOf("key1" to "value1", "key2" to "value2", "key3" to "value3")
    map.forEach { (key, value) ->
        println("$key \t $value")
    }

    // 不须要key的时候
    map.forEach { (_, value) ->
        println(value)
    }
}