[移动开发]Kotlin学习之路(三)：函数

前言

本篇文章主要介绍kotlin函数，同时对于Kotlin学习之路(一)：变量，常量，空安全变量的应用。

一.基础函数

1.1 一般用法

// 无参也无返回值的函数
fun function(){
    println("this is function!")
}

fun main(){
    function() // 调用函数
}

kotlin的函数前面必须要加fun用来表示这是一个函数。而上面的代码则定义了一个即无参数也无返回值的函数，可以说是最简单的一种，接下来，我们要让函数带上信息。

有参数有返回值函数

// function
fun function(param: Int): Int {
    return param + 1
}

fun main(){
    val result = function(0)
    println(result)
}

输出：

1

上面代码中param: Int就是函数的参数，: Int就是函数的返回值，如果将返回值: Int去掉，则代表该函数是无返回值的函数。

1.2 多参函数

和Java一样函数的参数不止一个，kotlin的函数也可以设置多参数函数。

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

fun main(){
    val result = add(2, 3)
    println(result)
}

上面的add函数，通过传入两个Int类型的参数来完成相加运算，如果你愿意你可以继续添加参数，fun function(参数1: 类型, 参数2: 类型, 参数3:类型, ...): Int.

当然，在实际项目开发中如果出现太多的参数，那么你可能需要考虑优化一下，比如将这些参数封装成一个类，关于kotlin类的介绍，可以参考我的下一篇文章：Kotlin学习之路(四)：类，构造函数，对象

1.3 函数重载和默认参数

Java允许参数个数，参数类型不同的函数重名存在，kotlin也有这个概念存在：

// 一个参数
fun function(param: Int) {
    println("param is $param")
}

//两个参数的函数重载
fun function(param0: Int, param1: Int) {
    println("param0 is $param0 param1 is $param1")
}

fun main() {
    function(0)
    function(0, 1)
}

输出：

param is 0
param0 is 0 param1 is 1

然而在实际开发中可能会增加参数，来满足业务需求，这个时候可以考虑默认参数。

fun function(param0: Int, param1: Int = 0, param2: Int = 0, param3: Int = 0) {
    println("param0 is $param0 param1 is $param1 param2 is $param2 param3 is $param3")
}

fun main() {
    function(1)
    function(1, 2)
    function(1, 2, 3)
    function(1, 2, 3, 4)
}

输出：

param0 is 1 param1 is 0 param2 is 0 param3 is 0
param0 is 1 param1 is 2 param2 is 0 param3 is 0
param0 is 1 param1 is 2 param2 is 3 param3 is 0
param0 is 1 param1 is 2 param2 is 3 param3 is 4

param1: Int = 0，如果param不赋值，那么默认值就是0，通过默认参数，直接就完成了四个重载函数的功能。

二.main函数

kotlin和java一样也有程序入口，那就是main函数

// 无参数的main函数
fun main() {
	println("hello world !")
}

// 带参数的main函数
fun main(args: Array<String>) {
	println("hello world !")
}

三.单表达式函数

kotlin函数的一般写法：

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

上面的kotlin函数可以简化为下面的形式：

// a+b相当于返回值
fun function(a: Int, b: Int): Int = a + b

fun main() {
    val result = function(2, 3) // 单表达式函数
    println(result)
}

输出：

5

四.高阶函数

高阶函数是kotlin相对于Java所独有的，所谓的高阶函数就是以另一个函数作为参数或返回值的函数。

4.1 函数类型

// 无参数，无返回值
() -> Unit

// 单个参数且参数类型是T，无返回值
(T) -> Unit

// 两个参数且参数类型是T0，T1，无返回值
(T0, T1) -> Unit

// 单个参数且参数类型是T，有返回值且类型是R
(T) -> R

// 两个参数且参数类型是T0，T1，有返回值且类型是R
(T0, T1) -> R

// 较复杂的类型，将A,B看成Y类型
(T,(A,B) -> C) -> R

// 三个参数且参数类型是T0，T1，T2，有返回值且类型是R
(T0, T1, T2) -> R
......

4.2 一般使用

var sum0: (Int, Int) -> Int = { a, b -> a + b }

var sum1 = { a: Int, b: Int -> a + b }

fun main() {
    println(sum0(1, 2))
    println(sum1(3, 4))
}

输出：

3
7

4.3 使用高阶函数(做为普通变量)

在上面的代码中sum0和sum1可以做为普通变量，代码如下：

var sum: (Int, Int) -> Int = { a, b -> a + b }

fun main() {
	// sum被当作变量赋值给test
    val test: (Int, Int) -> Int = sum
    var result = test(2, 3) 
    println(result)
}

输出：

5

上面的sum本质上等价于val 变量名:变量类型 = 值，所以高阶函数本质上也不是非常复杂的东西，其实就是函数类型的变量。

4.4 使用高阶函数(做为函数参数)

// 这里将function做为函数参数
fun test(a: Int, b: Int, function: (Int, Int) -> Int): Int {
    return function(a, b)
}

fun main() {
    val function: (Int, Int) -> Int = { x, y ->
        x + y
    }
    val result = test(2, 3, function)
    println(result)
}

test函数这样写有些麻烦，我们可以简化一下

	val result = test(2, 3, { x, y ->
        x + y
    })

上面的还可以再简化一下：

	val result = test(2, 3) { x, y ->
        x + y
    }

上面的代码就是最简洁的写法。

4.5 使用高阶函数(做为函数返回值)

// 返回值是一个函数
fun test(): (Int, Int) -> Int {
    return { x, y ->
        x + y
    }
}

fun main() {
	// resultFunction就是test返回的参数
    val resultFunction = test()
    
    // 调用resultFunction函数
    val result = resultFunction(2, 3)
    println(result)
}

输出：

5

总结一下，上面的高阶函数无论做为函数参数，函数返回值，都可以看成函数类型的变量来使用。

五.闭包

闭包主要是在函数式编程语言中，比如JavaScript，简单来说就是"函数可以访问由函数内部定义的变量"，Java也有类似的不完整的使用：

5.1 Java闭包

下面是用Java编写的Android代码：

	protected void onCreate(Bundle savedInstanceState) {
        ......省略代码
        int var = 0; // 需要加上final
        button.setOnClickListener(v -> {
            var ++;//报错
        });
    }

上面会直接报错，var必须是一个final修饰的变量，这里var变量之所以必须是final，是因为var是栈空间的局部变量，一旦出栈，var空间就被释放掉，用final修饰后，该变量就被存储在方法区中，这样var的生命周期是整个程序的生命周期。
但是用final修饰后，var也不能自增，所以可以有下面的解决办法，用一个数组代替var：

	protected void onCreate(Bundle savedInstanceState) {
        ......省略代码
        int[] varArray = new int[]{1};
        button.setOnClickListener(v -> {
            varArray[0]++;//正确
        });
    }

这个时候varArray是分配在堆空间上，自然也就没有上面代码的问题了。

5.2 Kotlin闭包

	override fun onCreate(savedInstanceState: Bundle?) {
        ......省略代码
        var variable = 0;
        button.setOnClickListener {
            variable++ //正确
        }
    }

上面的闭包不需要做任何的修改，就可以正常运行。

总结

以上就是Kotlin函数的知识，下一章我们将开启Kotlin类的学习之路，感兴趣的朋友请看下一章：Kotlin学习之路(四)：类，构造函数，对象