Kotlin中的函数

kotlin中的函数分为普通函数，泛型函数，内联函数，扩展函数，高阶函数以及尾递归函数

1 普通函数

kotlin中使用fun代表函数

fun double(x: Int): Int {
    return 2 * x
}
//没有返回值,Unit可以不写
fun test(x:Int):Unit{ print(x) }  //等同于 fun test(x:Int){ print(x) }

1.1 函数中的参数

函数中的参数可以具有默认值

fun reformat(str: String,
             normalizeCase: Boolean = true,
             upperCaseFirstLetter: Boolean = true,
             divideByCamelHumps: Boolean = false,
             wordSeparator: Char = ' ') {
/*……*/
}
//除了str以外其余的参数名都含有默认值，我们可以使用默认调用
reformat("NO.1")

如果我们调起其余参数，可以使用具名参数（具体参数名调用）

reformat(str,
    normalizeCase = true,
    upperCaseFirstLetter = true,
    divideByCamelHumps = false,
    wordSeparator = '_'
)
//也可以只使用其中的一些参数
reformat(str,normalizeCase = true)

当我们继承与父类的一个成员函数的时候，不能修改其参数默认值

open class A {
    open fun foo(i: Int = 10) { /*……*/ }
}

class B : A() {
    override fun foo(i: Int) { /*……*/ }  // 不能有默认值
}

1.2 可变的函数参数

当一个参数是是可变的时候，使用vararg关键字

//这里的T代表泛型，总是泛型总是出现在函数名的前面
fun <T> asList(vararg ts: T): List<T> {
    val result = ArrayList<T>()
    for (t in ts) // ts is an Array
        result.add(t)
    return result
}
//调用的时候，使用逗号分隔
val list = asList(1,2,3)
//当我们已经有一个数组类型的参数的时候，我们可以用扩展符（*）来作为参数传入
val arr = arrayof(1,2,3)
val list = asList(4,5,*arr)

2 泛型函数

和其他语言一样，kotlin是可以使用泛型的

2.1 泛型

class Box<T>(t: T) {
    var value = t
}

我们在java中使用泛型的时候，考虑一下情况

// Java
interface Collection<E> …… {
  void addAll(Collection<E> items);
}
// Java
void copyAll(Collection<Object> to, Collection<String> from) {
  to.addAll(from);
  // ！！！对于这种简单声明的 addAll 将不能编译：
  // Collection<String> 不是 Collection<Object> 的子类型
}

为了保证类型安全Java中不允许我们进行这样的操作，如果需要执行这种操作我们需要使用通配符

interface Collection<E> …… {
  void addAll(Collection<? extends E> items);
}

? extend E代表通配符类型，此方法接受E或者E的一些子类，这是没有必要的因为我们知道Object是String 的父类。
在kotlin中我们有了更简单的方式，使用out关键字来表示

// Java
interface Source<T> {
  T nextT();
}
// Java
void demo(Source<String> strs) {
  Source<Object> objects = strs; // ！！！在 Java 中不允许
  // ……
}

interface Source<out T> {
    fun nextT(): T
}

fun demo(strs: Source<String>) {
    val objects: Source<Any> = strs // 这个没问题，因为 T 是一个 out-参数
    // ……
}

这里的out指明了他是一个可读的，但不是可写的，当一个类 C 的类型参数 T 被声明为 out 时，它就只能出现在 C 的成员的输出-位置，但回报是 C<Base> 可以安全地作为 C<Derived>的超类。
同理还有in关键字，它代表的意思就是，只可以被消费而不可以被生产，不可以作为返回值类型使用。
可以看出in 和out类似java中的super和extend，指定了一个类型的下界和上界。

interface Comparable<in T> {
    operator fun compareTo(other: T): Int
}

fun demo(x: Comparable<Number>) {
    x.compareTo(1.0) // 1.0 拥有类型 Double，它是 Number 的子类型
    // 因此，我们可以将 x 赋给类型为 Comparable <Double> 的变量
    val y: Comparable<Double> = x // OK！
}

2.2泛型中的函数

对于泛型函数我们需要把它放在函数名之前

fun <T> singletonList(item: T): List<T> {
    // ……
}

fun <T> T.basicToString(): String {  // 扩展函数
    // ……
}

3 扩展函数

声明一个扩展函数，我们需要一个接受者类型也就是被扩展的类型作为他的前缀

fun MutableList<Int>.swap(index1: Int, index2: Int) {
    val tmp = this[index1] // “this”对应该列表
    this[index1] = this[index2]
    this[index2] = tmp
}

这里只针对一种类型，我们可以使用泛型来适配

fun <T> MutableList<T>.swap(index1: Int, index2: Int) {
    val tmp = this[index1] // “this”对应该列表
    this[index1] = this[index2]
    this[index2] = tmp}

4内联函数

内联函数会将方法直接写在调用的地方，简而言之就是内联函数等于将代码块，copy到调用的地方。

inline fun sum(a: Int): Int {
    var sum = 8
    sum += a
    return sum
}

fun main() {
    println(sum(10)+ sum(5))
}

使用java查看字节码之后

image.png

4.1 内联关键字

noinline: 让原本的内联函数变为不是内联的，保留 数据 特征

如果一个内联函数的参数里包含 lambda表达式，也就是函数参数，那么该形参也是 inline 的，举个例子：
inline fun test(inlined: () -> Unit) {...}
这里有个问题需要注意，如果在内联函数的内部，函数参数被其他非内联函数调用，就会报错
//我们需要变为不为内联的
inline fun test(noinline inlined: () -> Unit) {...}

*crossinline： 非局部返回标记，为了不让lamba表达式直接返回内联函数，所做的标记
相关知识点：我们都知道,kotlin中,如果一个函数中,存在一个lambda表达式，在该lambda中不支持直接通过return退出该函数的,只能通过return@XXXinterface这种方式

fun test() {
innerFun {
return //非局部返回，直接退出 test() 函数。
}
inline fun innerFun(a: () -> Unit) {
a()
}

//设置为crossinline之后
fun test() {
innerFun {
return //这里这样会报错，只能 return@innerFun
}

//以下代码不会执行
println("test...")
}

inline fun innerFun(crossinline a: () -> Unit) {
a()
}

reified 直接使用泛型的类型

fun <T> TreeNode.findParentOfType(clazz: Class<T>): T? {
    var p = parent
    while (p != null && !clazz.isInstance(p)) {
        p = p.parent
    }
    @Suppress("UNCHECKED_CAST")
    return p as T?
}
//使用的时候
treeNode.findParentOfType(MyTreeNode::class.java)

//我们只希望
inline fun <reified T> TreeNode.findParentOfType(): T? {
    var p = parent
    while (p != null && p !is T) {
        p = p.parent
    }
    return p as T?
}

函数是内联的，不需要反射，正常的操作符如 !is 和 as 现在都能用了。此外，我们还可以按照上面提到的方式调用它：myTree.findParentOfType<MyTreeNodeType>()

高阶函数和Lambada

在kotlin中的函数是头等的，它可以出现在数据结构，函数的参数，成员变量中出现。

fun <T, R> Collection<T>.fold(
    initial: R, 
    combine: (acc: R, nextElement: T) -> R
): R {
    var accumulator: R = initial
    for (element: T in this) {
        accumulator = combine(accumulator, element)
    }
    return accumulator
}
//
val items = listOf(1, 2, 3, 4, 5)

// Lambdas 表达式是花括号括起来的代码块。
items.fold(0, { 
    // 如果一个 lambda 表达式有参数，前面是参数，后跟“->”
    acc: Int, i: Int -> 
    print("acc = $acc, i = $i, ") 
    val result = acc + i
    println("result = $result")
    // lambda 表达式中的最后一个表达式是返回值：
    result
})
//
// lambda 表达式的参数类型是可选的，如果能够推断出来的话：
val joinedToString = items.fold("Elements:", { acc, i -> acc + " " + i })
-
// 函数引用也可以用于高阶函数调用：
val product = items.fold(1, Int::times)

参数 combine 具有函数类型(R, T) -> R，因此 fold 接受一个函数作为参数， 该函数接受类型分别为 R 与 T 的两个参数并返回一个 R 类型的值。 在 for-循环内部调用该函数，然后将其返回值赋值给 accumulator。

  //使用typealias 来指定函数别名
typealias ClickHandler = (Button, ClickEvent) -> Unit
//如果我们函数的最后一个参数是一个lambda，可以写在括号外卖也可以写在括号里面
fun foo(bar: Int = 0, baz: Int = 1, qux: () -> Unit) { /*……*/ }

foo(1) { println("hello") }     // 使用默认值 baz = 1
foo(qux = { println("hello") }) // 使用两个默认值 bar = 0 与 baz = 1
foo { println("hello") }        // 使用两个默认值 bar = 0 与 baz = 1

4.1 函数类型的实例化

函数类型也和普通类型一样，代表了一类实例，一般由 （R,T）->R这种表示，可以通过 lambda表达式 、匿名函数、使用已经声明的接口可调用的引用（顶层，局部，成员，扩展函数等），使用实现函数类型接口的自定义实例类。

//lambda
val s =  { a:Int, b:Int -> a + b }
//匿名函数
 fun(s: String): Int { return s.toIntOrNull() ?: 0 }

//使用顶层函数的引用
val stringPlus: (String, String) -> String = String::plus//引用了plus
//实现函数类型的接口
class IntTransformer: (Int) -> Int {
    override operator fun invoke(x: Int): Int = TODO()
}

val intFunction: (Int) -> Int = IntTransformer()

如果lambda表达是的参数未被使用，可以使用下划线代替

fun test( handler: (x:Int,y:Int)->Unit){
    handler.invoke(2,3)
}
fun test2(){
  test ({ a:Int, b:Int-> a})//第一次完整调用
//最后一个参数是lambda表达式，可以写在括号外面
 test { a:Int, b:Int-> a}
//可以由于a，b的类型指定，可以省却类型
  test{a,b->a}
//b参数未被使用，下划线代替
  test{a,_->a}
}

4.2 函数类型的实例调用

调用函数类型的实例的时候，可以通过invoke方法调用，也可以直接使用名称调用。

val stringPlus: (String, String) -> String = String::plus
println(stringPlus.invoke("<-", "->"))
println(stringPlus("Hello, ", "world!")) 

如果该值具有接收者类型，那么应该将接收者对象作为第一个参数传递。 调用带有接收者的函数类型值的另一个方式是在其前面加上接收者对象， 就好比该值是一个1.foo(2)

val intPlus: Int.(Int) -> Int = Int::plus

println(intPlus.invoke(1, 1))
println(intPlus(1, 2))
println(2.intPlus(3)) // 类扩展调用

带有接收者的函数类型
(A.(B)->C)与扩展函数类似，在函数的内部可以使用接受者对象的成员函数和变量

val sum: Int.(Int) -> Int = { other -> plus(other) } //这里我们调用了接受者对象的函数 plus

//声明一个对象
class HTML {
    fun body() { …… }
}

//申明一个函数他的
fun html(init: HTML.() -> Unit): HTML {
    val html = HTML()  // 创建接收者对象
    html.init()        // 接受者类型调用
    init(html)          //函数式调用
    init.invoke(html)   //普通调用
    return html
}

html {       // 带接收者的 lambda 由此开始
    body()   // 调用该接收者对象的一个方法
}