关于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)
    }
}