Kotlin函数

Kotlin函数思维导图

目录

函数的声明

可见性修饰符 链接

public

internal

protected

private

总结

函数的返回值

函数的参数

声明时的默认参数

使用时的关键字传参

可变参数

特殊的函数使用

成员函数

单表达式函数

---

函数的声明

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

   声明的具体格式是：可见性修饰符 fun 函数名 ( 参数名: 参数类型 ) : 返回值类型 { 函数体 }

   使用时：无返回值的可 函数名 (参数使用)

                 有返回值的可 var 变量名 = 函数名 ( 参数使用 )

   示例如下：

//顶层声明的Int数组求和函数
public fun getSum(args:Array):Int{
    var sum=0
    for (i in args){
        sum+=i
    }
    return sum
} //public可省略,不同的文件内可访问

private fun sub_arr(args1: Array, args2: Array): Array {
// private修饰的顶层函数，只能在本文件内访问
// 该函数实现了数组对应元素相减，一般要求两数组，若不等长，则长-短
    var res: Array
    if (args1.size>args2.size){
        res=args1
        for (i in args2.indices){
            res[i]=args1[i]-args2[i]
        }
    }else{
        res=args2
        for (i in args1.indices){
            res[i]=args2[i]-args1[i]
        }
    }
    return res
}

internal fun no_return(args:Int=5){
//无返回值且有默认参数
    println(args)
}

fun main(args:Array){
// 顶层声明的main函数，可见性修饰词默认为public，返回值为Unit类型
// 参数为String数组，参数名为args
    var arr1= arrayOf(1,3,5,7,9)
    var arr2= arrayOf(2,4,6,8)
    val sum=getSum(arr1)
    println(sum)// 25
    for (i in sub_arr(arr2,arr1)){
        print("$i ")// -1 -1 -1 -1 9
    }
    println()
    no_return() //5 
    no_return(8) //8
}

可见性修饰符 链接

public

    public 修饰符是Kotlin中默认的修饰符，可省略不写，在顶层、类、局部中均可以使用，可见性最大，一般是在父区域下的所有子区域均可见

internal

     internal是Kotlin特有的，是模块内可见，可以在顶层，类中使用

     Kotlin的模块是指一套编译在一起的Kotlin源文件：可以是一个IntelliJ IDEA模块;一个Maven项目;一个Gradle源集合;一组调用Ant任务编译的文件

protected

   protected修饰符和之前语言中遇到的类似，只能在类中使用，一般是在本类及继承类可访问

private

     private修饰符也和之前语言中的一致，可以在顶层、类内使用，一般是在本类内或者本文件内可访问

总结

顶层处只能使用除protected外的3个修饰符

类内4个修饰符均可以使用

块内局部声明只能用public修饰变量

// learn.kt
package kotlin_learn

private fun f() {  } // 在 learn.kt 内可见

public var a: Int = 5 // 变量a在其他文件内也可见（可以通过导入包使其可访问）
private var b:Int = 0   // 变量b只在learn.kt 内可见
    
internal val c= 6    // 变量c在相同模块内可见

open class A{
    private val a = 1 //在当前类内可见
    protected open val b = 2 //在当前类及其继承类内可见
    internal val c = 3 //在当前类及相同模块类内可见
    val d = 4  // 默认 public ，随类A的可见性
    
    protected class Nested { //内部类且为protected
        public val e: Int = 5 //属性e访问权限随Nested类可见性
    }
}

class Subclass : A() { //继承A
    // a 不可见
    // b、c、d 可见
    // Nested 和 e 可见

    override val b = 5  // 重写了b
}

class B(o:A) {  //并非继承的关系，主构造器，B只能访问A的public和interna属性、方法
    // o.a、o.b 不可见
    // o.c 和 o.d 可见（相同模块）
    // A.Nested 不可见，Nested::e 也不可见
}

函数的返回值

  Kotlin中函数的返回值类型粗略可分两种 Unit和有返回值类型

  一般函数若无返回值，则函数声明可不写返回值和return语句（return语句若写，可直接写return）

  当函数有具体的返回值时，则需要在声明处写明返回值的类型，写法是"：返回值类型"

且当返回值为可空类型时，返回值类型处也须写可空类型

fun printArr(array: Array){
    for (i in array){
        print("$i ")
    }
    println()
    return //return可省略
}
fun getSum(array: Array):Int?{
    var a=0
    var sign=true
    for (i in array){
        if (i!=null){
            a+=i
            sign=false
        }
    }
    return if (sign) null else a //三元表达式
}
fun main(args:Array){
    var arr:Array = arrayOf(1,3,5,7,9)
    printArr(arr) // 1 3 5 7 9
    println(getSum(arr))// 25
    arr= arrayOf(null)
    printArr(arr)// null
    println(getSum(arr)) // null
}

函数的参数

   函数声明时，一般参数的声明是以 参变量名: 参变量类型 的格式

声明时的默认参数

   默认参数的含义不再赘述，这里主要讲默认参数的使用

   使用一般仍需遵循从右往左设置以方便位置传参的逻辑

   使用格式：参变量名: 参变量类型 = 值

internal fun no_return(args:Int=5){
//无返回值且有默认参数
    println(args)
}

使用时的关键字传参

   关键字传参，即在调用函数时，函数的() 内，须以 参变量名 = 值或变量 的形式传递参数

   使用这种传参方式，则不须遵从默认参数从右往左的设置顺序

fun add_arr(addition:Int=1,array: Array):Array{

    for (i in array.indices){
        array[i] = array[i]?.plus(addition)
    }
    return array
}
fun printArr(array: Array){
    for (i in array){
        print("$i ")
    }
    println()
    return //return可省略
}
fun main(args:Array){
    var arr:Array = arrayOf(1,3,5,7,9)
    add_arr(array = arr)
    printArr(arr)
    add_arr(-2,arr)
    printArr(arr)
}

可变参数

  当函数中需要用的某参变量的长度不固定时，则可以使用可变修饰符 vararg 修饰，被 vararg修饰的参变量相当于一个数组，数组的长度由传参确定

  声明格式：可见性修饰符 fun 函数名 (参数名:类型, vararg 参数名: 类型)

  一般来说，函数参数声明最后放可变参数，以便更好地符合位置传参的逻辑，但当使用关键字传参时，可变参数的声明位置可任意

fun myPrint(vararg args:Int){
    for (i in args){
        print("$i ")
    }
    println()
}

fun main(args:Array){
    myPrint(1,2,3,4,5)
    myPrint(args = IntArray(3) { index -> (index * 3) }) 
    //lambda 函数的使用，这种数组声明在之前的Kotlin数据类型博客中介绍过
}

特殊的函数使用

成员函数

    声明在类内的函数称为成员函数

    成员函数的使用：类对象.函数名( 参数 ) 

单表达式函数

   当函数有返回值，且函数体可仅表示为 return 某表达式 的形式，此时函数的{ }可省略，用= 直接连接return后的表达式即可，这种表示形式称为单表达式函数

fun myMultiply(a:Double ,b:Double)=a*b