Kotlin研发第十二弹——函数和lambda表达式

函数和lambda表达式

函数

1、函数声明

在kotlin中用关键字fun声明函数：

fun double(x:Int):Int{}

2、函数用法

1. 通过传统的方式调用函数

   val resule=double(2)
   

2. 通过.调用成员函数

   Sample().foo()//创建Sample类的实例，调用foo方法
   

3、中缀符号（infix）

在满足以下条件时，函数也可以通过中缀符号进行调用：

他们是成员函数或者是扩展函数

只有一个参数

使用infix关键词进行标记

//给Int定义一个扩展方法
infix fun Int.shl(x:Int):Int{...}

1 shl 2//中缀注解调用扩展函数

1.shl(2)

/Users/wyc/Library/Android/sdk

 infix fun Int.shl(x:Int):Int{
        return         times(x)
    }
   
 val nameA= 1 shl 2
    val nameB= nameA.shl( 4)
    println(nameA)
    println(nameB)

参数

函数参数是用Pascal符号定义的 name：type。参数之间用都好隔开，每个参数必须指明类型。

fun powerOf(number：Int，exponent：Int){}

默认参数

函数参数可以设置默认值，当参数被忽略时会使用默认值，

这样比其他语言可以减少重载

fun read(b：Array<Byte>,off:Int=0,len:Int=b.size){}

默认值可以通过type类型后使用=进行赋值

命名参数

在调用函数时可以参数命名，这对于那种有大量参数的函数很方便

 fun reformat(str:String,isMale:Boolean=true,age:Int=27){...}
 TestResourceLoader().reformat("wyc")

使用时可以使用默认的参数来初始化方法不用过分重载，适用于某些含有默认属性的方法

注意：命名参数语法不能用于调用Java函数中，因为Java的字节码不能确保方法参数命名的不变性

不带返回值的参数

如果函数不会反悔任何有用值，那么他的返回类型就是unit.并且可以省略

fun printHello(name: String?): Unit {
    if (name != null)
        println("Hello ${name}")
    else
        println("Hi there!")
    // `return Unit` or `return` is optional
}

单表达式函数

当函数只返回单个表达式，大括号可以省略并在=后面定义函数体

fun double(x:Int):Int=X*2

在编译器可以推断出返回值类型的时候，返回值可以省略

fun double(x:Int)=X*2

明确返回类型

下面的例子中必须有明确返回类型，除非他是返回Unit类型。kotlin并不会对函数体重的返回类型进行推断，因为函数体中可能有复杂的控制流，他的返回类型未必对读者课件（甚至编译器而言也有可能是不可见的）

变长参数

函数的参数（通常是最后一个参数）可以用vararg修饰符进行标记：

//可变长度参数
fun <T> asList(vararg ts:T):List<T>{
    val result=ArrayList<T>()
    result.addAll(ts)
    return result
}
println(asList(1,2,3,"wyc"))

输出结果

[1, 2, 3, wyc]

标记后允许传递可变长度的参数

注意，只有一个参数可以被标注vararg。加入vararg并不是列表中的最后一个参数，那么后面的参数需要通过命名参数语法进行传值，再或者如果这个参数是函数类型，就需要通过lambda法则。

当调用变长参数的函数时，我们可以一个一个传递参数，比如asList(1,2,3),或者我们传递一个array的内容给函数，我们就可以使用*前缀操作符：

 val list= arrayOf("q","w","e","r")
    val changeResult= asList(1,2,3,"wyc",*list)
    println(changeResult)

函数范围

Kotlin中可以在文件顶级声明函数，这就意味着你不用想在Java，C#或者Scala一样创建一个类来持有函数。除了顶级函数，Kotlin函数可以声明为局部的，作为成员函数或者扩展函数

局部函数

Kotlin支持局部函数，比如在一个函数中包含另外一个函数

fun dfs(graph: Graph) {
  fun dfs(current: Vertex, visited: Set<Vertex>) {
    if (!visited.add(current)) return
    for (v in current.neighbors)
      dfs(v, visited)
  }
    dfs(graph.vertices[0], HashSet())
}

局部函数可以范文外部函数的局部变量（比如闭包）

fun dfs(graph: Graph) {
    val visited = HashSet<Vertex>()
    fun dfs(current: Vertex) {
        if (!visited.add(current)) return 
        for (v in current.neighbors)
            dfs(v)
    }
    dfs(graph.vertices[0])
} 

局部函数甚至可以返回到外部函数

fun reachable(from: Vertex, to: Vertex): Boolean {
    val visited = HashSet<Vertex>()
    fun dfs(current: Vertex) { 
        if (current == to) return@reachable true //返回到外部
        if (!visited.add(current)) return
        for (v in current.neighbors)
            dfs(v)
    }
    dfs(from)
    return false
}

成员函数

成员函数定义到一个类或者对象里边的

class Sample(){
    fun foo(){prinln("foo")}
}

成员函数的调用方式

Sample.foo()

泛型函数

函数可以有泛型参数，样式就是在函数名前加上尖括号。

fun <T> sigletonArray(intm:T):Array<T>{
    return Array<T>(1,{item})
}