文章目录
前言
本篇文章主要介绍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学习之路(四):类,构造函数,对象