kotlin中函数的定义和调用

1 、函数声明（前面内容官方有）

Kotlin 中的函数使用 fun 关键字声明

fun double(x: Int): Int {
    return 2 * x
}

函数参数使用 Pascal 表示法定义，即 name: type。参数用逗号隔开。每个参数必须有显式类型：

fun powerOf(number: Int, exponent: Int) { …… }

函数参数可以有默认值，当省略相应的参数时使用默认值。与其他语言相比，这可以减少重载数量：

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

覆盖方法总是使用与基类型方法相同的默认参数值。 当覆盖一个带有默认参数值的方法时，必须从签名中省略默认参数值：

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

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

如果一个函数不返回任何有用的值，它的返回类型是 Unit。Unit 是一种只有一个值——Unit 的类型。这个值不需要显式返回：

fun printHello(name: String?): Unit {
    if (name != null)
        println("Hello ${name}")
    else
        println("Hi there!")
    // `return Unit` 或者 `return` 是可选的
}

Unit 返回类型声明也是可选的。

函数

函数声明

Kotlin 中的函数使用 fun 关键字声明：

fun double(x: Int): Int {
    return 2 * x
}
fun double(x: Int): Int {
    return 2 * x
}

函数用法

调用函数使用传统的方法：

val result = double(2)

调用成员函数使用点表示法：

Sample().foo() // 创建类 Sample 实例并调用 foo参数
函数参数使用 Pascal 表示法定义，即 name: type。参数用逗号隔开。每个参数必须有显式类型：

fun powerOf(number: Int, exponent: Int) { …… }

默认参数

函数参数可以有默认值，当省略相应的参数时使用默认值。与其他语言相比，这可以减少重载数量：

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

默认值通过类型后面的 = 及给出的值来定义。

覆盖方法总是使用与基类型方法相同的默认参数值。 当覆盖一个带有默认参数值的方法时，必须从签名中省略默认参数值：

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

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

如果一个默认参数在一个无默认值的参数之前，那么该默认值只能通过使用命名参数调用该函数来使用：

fun foo(bar: Int = 0, baz: Int) { …… }

​
foo(baz = 1) // 使用默认值 bar = 0
如果在默认参数之后的最后一个参数是 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

命名参数

可以在调用函数时使用命名的函数参数。当一个函数有大量的参数或默认参数时这会非常方便。

给定以下函数：

fun reformat(str: String,
             normalizeCase: Boolean = true,
             upperCaseFirstLetter: Boolean = true,
             divideByCamelHumps: Boolean = false,
             wordSeparator: Char = ' ') {
……
}

我们可以使用默认参数来调用它：

reformat(str)
然而，当使用非默认参数调用它时，该调用看起来就像：

reformat(str, true, true, false, ‘_’)
使用命名参数我们可以使代码更具有可读性：

reformat(str,
    normalizeCase = true,
    upperCaseFirstLetter = true,
    divideByCamelHumps = false,
    wordSeparator = '_'
)

并且如果我们不需要所有的参数：

reformat(str, wordSeparator = ‘_’)
当一个函数调用混用位置参数与命名参数时，所有位置参数都要放在第一个命名参数之前。例如，允许调用 f(1, y = 2) 但不允许 f(x = 1, 2)。

可以通过使用星号操作符将可变数量参数（vararg） 以命名形式传入：

fun foo(vararg strings: String) { …… }
​
foo(strings = *arrayOf(“a”, “b”, “c”))
请注意，在调用 Java 函数时不能使用命名参数语法，因为 Java 字节码并不总是保留函数参数的名称。

返回 Unit 的函数
如果一个函数不返回任何有用的值，它的返回类型是 Unit。Unit 是一种只有一个值——Unit 的类型。这个值不需要显式返回：

fun printHello(name: String?): Unit {
    if (name != null)
        println("Hello ${name}")
    else
        println("Hi there!")
    // `return Unit` 或者 `return` 是可选的
}
fun printHello(name: String?): Unit {
    if (name != null)
        println("Hello ${name}")
    else
        println("Hi there!")
    // `return Unit` 或者 `return` 是可选的
}

Unit 返回类型声明也是可选的。上面的代码等同于：

fun printHello(name: String?) { …… }

单表达式函数
当函数返回单个表达式时，可以省略花括号并且在 = 符号之后指定代码体即可

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>()
    for (t in ts) // ts is an Array
        result.add(t)
    return result
}
val list = asList(1, 2, 3)

java中是没有参数默认值得。当java中调用kotlin函数的时候，必须显示的指定所有参数值，如果需要java中做频繁的调用，
而且希望能对java的调用这更简便，可以用@JVMOverLoads注解他，

1.1消除静态工具类：顶层函数和属性

java是面向对象的语言，所有的代码都需要写成类的函数，java中就是以utils为后缀的类。在kotlin中不需要创建这些没有意义的类，可以把这些函数直接放到代码文件的顶层，放在文件顶层的函数是包内成员，
看看下面的例子

package strings;   文件名是  Join.kt
fun joinToString(...):String){..}    
..........................................
上面的例子会编译称下面的java类
package strings;

public class JoinKt{
	public class JoinKt {
           public  static String joinToStrig(...){   }
           }
}
当java调用这个函数的时候，JoinKt.joinToString(list,",",");

要概念包含kotlin顶层函数的生成的类的名称，需要为这个文件添加@JvmName的注解

@file：JvmName(’'指定的类名")

1.1.1 顶层函数

和函数一样，属性也可以放在文件的顶层，但是不常用，定义在顶层的属性会被存储到一个静态的字段中，默认情况下，顶层属性和其他任意属性一样，是通过访问器暴露给java使用的，如果你想把一个常量以public static final 的属性暴露给java 可以哟个const来修饰

1.2扩展函数和属性，特色的地方

当把一个现有的java项目集成kotlin时候，就可以用扩展函数。使用的时候需要把扩展的类或者接口的名称放到即将添加的函数前面。这个类的名称被称为接受者类型，用来调用这个扩展函数的对象叫做接受者对象

fun String.lastChar():Char() =  this.get(this.lenth-1)// String为接受者类型。this为接受者对象

“kotlin”.lastChar() //调用

扩展函数并不允许打包它的封装性，和在类内部定义的方法不同的是，扩展函数不能访问私有的或者手保护的成员。
我们可以用导入类一样的语法来导入单个函数，使用关键字as来修改导入的类或者函数的名称
扩展函数会被编译称静态函数.扩展函数的静态性质决定了扩展函数不能被子类重写，