函数

2018-06-10 本文已影响0人一江碎月

定义

使用 fun 关键字定义一个函数。fun 后为函数名，函数名后为参数列表，参数列表后为冒号，冒号后为返回值类型。
函数格式
如果函数返回值为 void，则可以省略冒号及返回值类型。

fun test(a: Int) { // 该函数没有返回值
    println("a = $a")
}

fun test2(b: Int): String { // 该函数返回值类型为 String
    return "$b"
}

参数

不能使用 var 或 val 修饰
必须指明类型。如：

fun test(a:Int,b:Int = 3 ) = a+b

fun main(args:Array<String>){
    println(test(2)) //5
    print(test(3,4))  // 7
}

命名参数

在调用函数时，可以使用参数名指定为某个参数传值。

命名参数主要是为了提高代码的可读性 —— 阅读代码时，可以很方便的知道不同的实参是为哪个形参进行赋值。

参数的顺序可以调换。

fun main(args: Array<String>) {
    println(test(a = 1, c = 2, b = "bb"))
}

fun test(a: Int, b: String, c: Int) = "a = ${a},b = ${b},c = ${c}"

命名参数的后面所有参数必须是命名参数。如上述代码中，如果改写成如下格式便会出错，因为 b 使用了命令参数，而后面没有使用：
```
println(test(1, b = "bb", 2))
```
命名参数只能在 kt 之间使用，kt 调 java 不支持。

默认参数值

kt 中，在声明函数时可以为参数指定默认值。当调用者没有传递该参数时，该参数的值为默认值。

默认参数的主要原因是为了避免太多的重载方法。

当按常规方法调用函数时，除了最后设置有默认值的参数可以省略，必须为每一个参数进行赋值。可以省略末尾的有默认值的参数，中间的不参省略。

如下示例中，传参时必须为 b 进行赋值，但可以省略 d 的实参。常规调用时，没办法做到只为 a,c 赋值。
```
fun main(args: Array<String>) {
    println(test(1, "bb",2))
}

fun test(a: Int, b: String = "bb", c: Int,d:Int=3) = "a = ${a},b = ${b},c = ${c},d=${d}"
```
命名参数时，可以按任意顺序，省略所有有默认值的参数。如下，在调用时，完全没有考虑顺序，也没有为任何一个有默认值的参数进行传参。
```
fun main(args: Array<String>) {
    println(test(c = 2,a = 1))
}

fun test(a: Int, b: String = "bb", c: Int,d:Int=3) = "a = ${a},b = ${b},c = ${c},d=${d}"
```

表达式函数体

当一个函数的函数体中只有一个表达式的时候，可以变成表达式函数。

所谓的表达式函数指的是：除掉普通函数的大括号以及 return 语句，并使用等号将表达式连接在参数列表后。

同时，也可以省略返回值类型。

fun test(b: Int) = "$b"
fun test2(b:String):String = "$b is b"

在第一个表达式函数中，并没有指定返回值类型。因为函数体只是一个表达式，而表达式的返回值可以经过类型推导得到。

顶层函数

kt 中函数可以不依赖于任何类而单独存在。这些函数被称为顶层函数。

因为 jvm 只能调用类中的方法，因此 kt 被编译后，顶层函数会被编译到一个与文件名相同的类中，并且成为该类中的一个静态函数。

例如 kotlin 中代码如下：

// 文件名为 Demo.kt
package com.demo
fun test(a:Int,b:String) = "${a}+${b}"

经过编译后，会生成 DemoKt 类，而 test 是该类中的一个静态方法。其调用过程如下：

import com.demo.DemoKt; // 导入 kt 文件编译后生成的类
public class Test {
    public static void main(String[] args){
        String s = DemoKt.test(1, "2"); // 调用类中的静态方法
        System.out.println(s);
    }
}

@file:JvmName

指定 kt 文件编译后的类名。

该注解必须使用在文件的第一行，凌驾于 package 之上。如将上述文件修改如下，那么调用时就应该使用 Utils.test ，而不是 DemoKt.test。

@file:JvmName("Utils")
package com.demo
fun test(a:Int,b:String) = "${a}+${b}"

顶层属性

与顶层函数一样，属性也可以不依赖任何类而单独存在。该定义的属性，与普通的类中的属性一样，java 使用时需要通过 getter / setter 进行处理。

@file:JvmName("Utils")
package com.demo
var count = 0
val age = 10

Java 使用时，如下：

Utils.getAge();
Utils.setCount(1);
Utils.getCount();

const

定义常量的顶层属性。

上述定义的顶层属性，都会生成 getter / setter 方法以供 java 调用，并不是 java 中的 public static final 。如果使用 const 修饰的变量转换成 Java 后，就是 public static final。如：

@file:JvmName("Utils")
package com.demo
const val score = 10;

外界调用时，可以直接使用 Utils.score，该值不能被修改。

kt 中无法定义出被 public static 修饰的属性。

可变参数

使用 vararg 修饰符修饰。
可变参数可定义在任意位置。
java 中可以将一个数组直接赋值给一个可变参数，但 kt 中数组必须使用 * 进行解包。
为 可变参数后面的形参进行赋值时，必须使用命名参数 —— 不然无法识别该实参是给可变参数的，还是给别的形参的，即使类型不同。

// 可变参数可以定义在任意位置
fun test(vararg a: Int, b: Int) {
    val sb = StringBuilder()
    for (index in 0..(a.size - 1)) {
        sb.append("${a[index]} ")
    }
    sb.append(b)
    println(sb.toString())
}

fun main(args: Array<String>) {
    val a: IntArray = intArrayOf(1, 2, 3, 4)
    test(*a, b = 5) // 数组必须被解包
}

中缀调用

使用 infix 关键字修改的函数为中缀函数。

调用中缀函数时可以省略点号和括号，而且中缀函数需要满足以下条件：

必须是成员函数或扩展函数。因为这样才能确定调用者的类型。
必须只有单个参数。
参数不能是可变参数，而且不能有默认值
接受者和参数都需要明确指定。即使接受者是 this ，也不能省略。

// 扩展函数的中缀
infix fun Any.test(a: Int) = println("${a * 2}")

class My {
    // Any 为所有 kt 类的父类，该函数表示任意一个对象都可以调用 add 函数。
    infix fun Any.add(s: String) = "${this}+${s}"

    fun test(s: String) = this add s
    // test2 与 test 效果一样
    fun test2(s:String) = this.add(s)
}

fun main(args: Array<String>) {
    val my = My()
    println(my.test("xxx"))
    println(my.test2("xxx"))
}

注意其中的 test 与 test2 两个函数，都没有省略 this。这是中缀函数要求的：不能省略 this。

局部函数

kt 中可以在函数中嵌套函数。

局部函数可以访问所在函数的所有参数和变量，但只能是 定义在局部函数前面的参数和变量。

fun test(){
    val b = "name"
    fun name() = println("${b}") // 局部函数

    val a = "age" // name 函数无法访问到该变量
    name()
}

局部函数可以定义在扩展函数中。

fun User.validate() {
    fun vali(name:String,value:String){
        if (value.isEmpty()) {
            throw IllegalArgumentException("${name} 不能为空")
        }else{
            println("正确的")
        }
    }
    vali("id",this.id)
}

fun main(args: Array<String>) {
    val u1 = User("","11")
    val u2 = User("2","22")
    u2.validate()
    u1.validate() // 该句报错
}

可空类的扩展

扩展函数的接收者类型可以为可空类型

定义成可空类型时，扩展函数中使用 this 可能为 null，所以需要单独判断。

fun main(args:Array<String>){
    var t:Test? = Test()
    t.test()
    t = null
    t.test()
}

class Test
// 类型使用 Test?，表示该方法可以被可空类型的对象调用
fun Test?.test() {
    if (this == null) println("xxx") else println("$this")
}

成员扩展

在一个类中为另一个类定义扩展函数或属性，这样的函数或属性叫成员扩展

成员扩展不能在类的作用域之外使用

fun main(args: Array<String>) {
    Outer().test("12345678")    
  //  println("aabbcc".six())  在类的外面无法访问在类中定义的扩展函数 six()
}

class Outer {
    fun String.six(): Char = toCharArray()[6]
    fun test(s: String) {
        println(s.six())
    }
}

无法像普通的扩展函数那样，在不改变类的情况下添加新的扩展。如上例，在不改变 Outer 类的情况下，无法为 String 在 Outer 类中定义新的成员扩展。

函数

定义

参数