文章目录
前言
本篇文章主要介绍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就是函数的参数，这里需要注意的一点是：对于kotlin的函数的参数默认是 val 类型。: 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
上面的例子，你可以将var sum0: (Int, Int) -> Int = { a, b -> a + b }看成一个被赋值的变量。其中sum0就是变量名，后面的(Int, Int) -> Int是变量类型，=后面的 { a, b -> a + b }则可以看成是赋给变量sum0的值。理解了这点，你就可以更加明白的看懂下面的论述。
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学习之路(四)：类，构造函数，对象