想要声明一个函数需要使用fun
关键字
kotlin
fun hello() {
return println("Hello, world!")
}
fun main() {
hello()
// Hello, world!
}
格式:
kotlin
fun 方法名(参数1: 参数1类型, 参数2 : 参数2类型, ...): 返回值类型 {
方法体
return 返回值
}
fun 方法名(参数1: 参数1类型, 参数2 : 参数2类型, ...){
方法体
}
参数可以有一个或者多个,也可以没有参数。
举例
kotlin
fun sum(x: Int, y: Int): Int {
return x + y
}
fun main() {
println(sum(1, 2))
// 3
}
kotlin
fun printMessageWithPrefix(message: String, prefix: String) {
println("[$prefix] $message")
}
fun main() {
printMessageWithPrefix(prefix = "Log", message = "Hello")
// [Log] Hello
}
建议使用小驼峰命名法
默认参数值
kotlin
fun printMessageWithPrefix(message: String, prefix: String = "Info") {
println("[$prefix] $message")
}
fun main() {
printMessageWithPrefix("Hello", "Log")
// [Log] Hello
printMessageWithPrefix("Hello")
// [Info] Hello
printMessageWithPrefix(prefix = "Log", message = "Hello")
// [Log] Hello
}
如果跳过某一个参数,若果有后续的参数,必须指定参数名字
单一表达式方法
kotlin
fun sum(x: Int, y: Int): Int {
return x + y
}
fun main() {
println(sum(1, 2))
// 3
}
对单表达式函数,可以进行一下简化
- 去除返回值类型
- 去除
return
关键字 - 去除
{}
- 用
=
连接方法体
kotlin
fun sum(x: Int, y: Int) = x + y
fun main() {
println(sum(1, 2))
// 3
}
Lambda 表达式
如下方法
kotlin
fun uppercaseString(str: String): String {
return str.uppercase()
}
fun main() {
println(uppercaseString("hello"))
// HELLO
}
可写为
kotlin
fun main() {
println({ str: String -> str.uppercase() }("hello"))
// HELLO
}
- 方法定义在
{}
内 - 参数后边跟着
->
->
后边跟着方法体str
是参数名字String
是参数类型- 返回值为
.uppercase()
方法的返回值类型
固定格式,没什么可研究的
如果是无参数的Lambda
方法
kotlin
fun main() {
{ println("hello") }() // hello
}
Lambda表达式可以以多种方式使用
- 将lambda分配给稍后可以调用的变量
- 将lambda表达式作为参数传递给另一个函数
- 从函数返回lambda表达式
- 单独调用lambda表达式
赋值给变量
kotlin
fun main() {
val upperCaseString = { string: String -> string.uppercase() }
println(upperCaseString("hello"))
// HELLO
}
函数类型
对于使用变量接收一个Lambda
函数时,可能需要对函数进行类型定义
- 参数类型写在
()
内,多个类型用,
分割 - 返回值类型跟在
->
后边
kotlin
val upperCaseString1: (String) -> String = { string -> string.uppercase() }
// ↑ ↑
// 参数类型 返回值类型
val upperCaseString2 : () -> String = { "hello" }
fun main() {
println(upperCaseString("hello"))
// HELLO
}
作为参数使用
kotlin
fun main() {
val numbers = listOf(1, -2, 3, -4, 5, -6)
val positives = numbers.filter { x -> x > 0 }
val negatives = numbers.filter { x -> x < 0 }
println(positives) // [1, 3, 5]
println(negatives) // [-2, -4, -6]
}
.fileter()
方法接收一个Lambda
方法作为参数
- { x -> x > 0 } 获取
List
中>0的元素- { x -> x < 0 } 获取
List
中<0的元素
作为返回值在方法中返回
kotlin
fun main() {
fun toSeconds(time: String): (Int) -> Int = when (time) {
// ↑ ↑ ↑
// toSeconds的参数及类型 ↑ 要返回的lambda函数的返回值类型
// 要返回的lambda函数的参数类型
"hour" -> { value -> value * 60 * 60 }
"minute" -> { value -> value * 60 }
"second" -> { value -> value }
else -> { value -> value }
}
fun main() {
val timesInMinutes = listOf(2, 10, 15, 1)
val min2sec = toSeconds("minute")
val totalTimeInSeconds = timesInMinutes.map(min2sec).sum()
println("Total time is $totalTimeInSeconds secs") // Total time is 1680 secs
}
}
Trailing lambdas (后置Lambda)
.fold()
方法接收一个Int
和一个lambda
函数,调用方法时可写做
kotlin
println(listOf(1, 2, 3).fold(0, { x, item -> x + item })) // 6
使用后置lambda方式时可写做
kotlin
println(listOf(1, 2, 3).fold(0) { x, item -> x + item }) // 6
把
lambda
函数放在()
外