Kotlin学习总结（三）写个函数

kkmt
330 阅读6分钟
2019.07.03:你未必光芒万丈，但始终温暖有光

写个函数

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

class HelloPeiqiTest{
    init {
      var tempPrint= handleAge(12)
    }
    fun handleAge(age: Int){
        println(age)
    }
}
函数一般用法
调用函数使用传统的方法

var tempPrint= handleAge(12)
调用成员函数使用点表示法

HelloPeiqiTest().handleAge(12)// 创建类 HelloPeiqiTest实例并调用 handleAge

参数

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

fun handleAge(age: Int,str:String){
        println(age)
}
默认参数
函数参数可以有默认值，当省略相应的参数时使用默认值。与其他语言相比，这可以减少重载数量
默认值通过类型后面的 = 及给出的值来定义。

class HelloPeiqiTest{
    init {
      var tempPrint= handleAge(12)
    }
    fun handleAge(age: Int,str: String="my age is:"){
        println(str+age)
    }
}
结果

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

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

class B : A() {
    override fun foo(i: Int) { …… }  // 不能有默认值
}
如果一个默认参数在一个无默认值的参数之前，那么该默认值只能通过使用命名参数调用该函数来使用

class HelloPeiqiTest{
    init {
      var tempPrint= handleAge(14)//这样不行
      var tempPrint= handleAge(num=14)
    }
    fun handleAge(age: Int=12,num: Int){
        println(num+age)
    }
}
如果在默认参数之后的最后一个参数是 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
命名参数
可以在调用函数时使用命名的函数参数。当一个函数有大量的参数或默认参数时这会非常方便。

class HelloPeiqiTest{
    init {
        //使用默认参数来调用它
        reformat("nihao")
        //当使用非默认参数调用它时，该调用看起来就像
        reformat("buhao", true, true, false, '_')
        //使用命名参数我们可以使代码更具有可读性
        //如果我们不需要所有的参数
        //需要修改那个默认参数，就用它的命名参数去赋值
        //这样就不用向上面全部写出来了
        reformat("yibanban",wordSeparator = 'c')
    }
    fun reformat(str: String,
                 normalizeCase: Boolean = true,
                 upperCaseFirstLetter: Boolean = true,
                 divideByCamelHumps: Boolean = false,
                 wordSeparator: Char = ' ') {
        println(str)
    }
}
当一个函数调用混用位置参数与命名参数时，所有位置参数都要放在第一个命名参数之前。例如，允许调用 f(1, y = 2) 但不允许 f(x = 1, 2)。
可以通过使用星号操作符将可变数量参数（vararg） 以命名形式传入

class HelloPeiqi{
    init {
        basicTest(strs = *arrayOf("1","2","3"))
    }
    fun basicTest(vararg strs:String){
        strs.forEach {
            println(it)
        }
    }
}

请注意，在调用 Java 函数时不能使用命名参数语法，因为 Java 字节码并不总是保留函数参数的名称。
返回 Unit 的函数
如果一个函数不返回任何有用的值，它的返回类型是 Unit。Unit 是一种只有一个值——Unit 的类型。这个值不需要显式返回,跟Java中的void一样。

fun printHello(name: String): Unit {
    if (name != null)
        println("Hello ${name}")
    else
        println("Hi there!")
    // `return Unit` 或者 `return` 是可选的
}
Unit 返回类型声明也是可选的。上面的代码等于fun printHello(name: String) {
    if (name != null)
        println("Hello ${name}")
    else
        println("Hi there!")
    // `return Unit` 或者 `return` 是可选的
}
单表达式函数
当函数返回单个表达式时，可以省略花括号并且在 = 符号之后指定代码体即可：

class HelloPeiqi {
    init {
        //basicTest等同于basicTest2
        println(basicTest(2))
        println(basicTest2(2))
    }
    fun basicTest(num: Int): Int = num * 5
    fun basicTest2(num: Int): Int {
        return num * 5
    }
}
当返回值类型可由编译器推断时，显式声明返回类型是可选的
具有块代码体的函数必须始终显式指定返回类型，除非他们旨在返回 Unit,具有块代码体的函数的返回类型不好推断德，所以必须要显式的去声明返回类型

class HelloPeiqi {
    init {
        //basicTest等同于basicTest2
        println(basicTest(2))
        println(basicTest2(2))
    }
    fun basicTest(num: Int)= num * 5
    
    fun basicTest2(num: Int): Int {
        return num * 5
    }
}
可变数量的参数（Varargs）
函数的参数（通常是最后一个）可以用 vararg 修饰符标记：

class HelloPeiqi{
    fun basicTest(vararg strs:String){
        strs.forEach {
            println(it)
        }
    }
}
允许将可变数量的参数传递给函数：

class HelloPeiqi {
    init {
        val list1 = asList(1, 2, 3)
        val list2 = asList("ddd","fff")
    }
    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
    }
}
只有一个参数可以标注为 vararg。如果 vararg 参数不是列表中的最后一个参数， 可以使用命名参数语法传递其后的参数的值，或者，如果参数具有函数类型，则通过在括号外部传一个 lambda。
当我们调用 vararg-函数时，我们可以一个接一个地传参，例如 asList(1, 2, 3)，或者，如果我们已经有一个数组并希望将其内容传给该函数，我们使用伸展（spread）操作符（在数组前面加 *）：

class HelloPeiqi {
    init {
        var list1 = arrayOf(1, 2, 3)
        val list2 = asList(4,*list1,6)
    }
    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
    }
}
中缀表示法
标有 infix 关键字的函数也可以使用中缀表示法（忽略该调用的点与圆括号）调用。中缀函数必须满足以下要求：
  • 它们必须是成员函数或扩展函数；
  • 它们必须只有一个参数；
  • 其参数不得接受可变数量的参数且不能有默认值。

class HelloPeiqi {
    init {
        // 用中缀表示法调用该函数
        var num= 1 hah 5
        println(num)
        // 用中缀表示法调用该函数
        var str="nihao" appendNum 5
        //等同
        var str2="nihao".appendNum(4)
        println(str)
        println(str2)
    }
    infix fun Int.hah(num:Int):Int{
      return num*2
    }
    infix fun String.appendNum(num: Int):Int{
        return num*4
    }
}
请注意，中缀函数总是要求指定接收者与参数。当使用中缀表示法在当前接收者上调用方法时，需 要显式使用 this；不能像常规方法调用那样省略。这是确保非模糊解析所必需的。

class HelloPeiqi {
    init {
        add(1)
    }
    infix fun add(num:Int):Int{
      return num*2
    }
    fun build(){
        //正确
        this.add(1)
        //正确
        add(12)
        //错误
        add 12
    }
}
函数作用域
在 Kotlin 中函数可以在文件顶层声明，这意味着你不需要像一些语言如 Java、C# 或 Scala 那样需要创建一个类来保存一个函数。此外除了顶层函数，Kotlin 中函数也可以声明在局部作用域、作为成员函数以及扩展函数。
局部函数
Kotlin 支持局部函数，即一个函数在另一个函数内部：
局部函数可以访问外部函数（即闭包）的局部变量

fun add(num: Int) {
    fun handleNum(tempNum: Int): Int {
        return tempNum * 2
    }
    var x = 13
    handleNum(x)
}
成员函数
成员函数是在类或对象内部定义的函数：成员函数以点表示法调用HelloPeiqi().add(12)

class HelloPeiqi {
    init {
        add(2)
    }
    //成员函数
    fun add(num: Int) {
        println(num)
    }
}
泛型函数
函数可以有泛型参数，通过在函数名前使用尖括号指定

fun <T> singletonList(item: T): List<T> { …… }
总结：这部分属于结合基本类型写一些简单的函数，对函数的调用，下部分学习函数高级的部分。


avatar
文章
阅读
粉丝