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

一、前言

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

这一节咱们来讲一下 Kotlin 中的办法和 Lambda 表达式这两个知识点。

二、Kotlin 办法

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

2.1、办法申明

Kotlin 中一个办法的根本格局如下所示：

具体代码实现

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

2.1.1、类的成员办法

类的成员办法的写法

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

成员办法的调用形式

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

2.1.2、类办法（静态方法）

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

静态方法的写法

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

静态方法的调用

 Person.test2()

2.1.3、静态方法

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

object 润饰的类的写法

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

静态方法的调用

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

2.1.4、单表达式办法

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

单表达式办法的写法

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

2.2、办法参数

2.2.1、默认参数

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

默认参数写法

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

2.2.2、可变数量的参数

在 Java 中利用 ...(比方 String...) 来设置可变类型的参数，在 Kotlin 中是通过 vararg 修饰符标记参数来实现可变参数的。

可变参数写法

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

可变参数办法的调用

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

2.3、办法作用域

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

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

2.3.1、部分办法

部分办法写法

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

部分办法的调用

println(rand())

三、Lambda 表达式

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

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

点击事件，未用 Lambda 表达式

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

点击事件，应用 Lambda 表达式

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

3.1、Lambda 表达式语法

无参数状况

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

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

有参数状况

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

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

单个参数的隐式名称

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

3.2、在 Lambda 表达式中应用_

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

当遍历 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)    }}