Kotlin基础知识学习(三)

函数使用

基本用法

函数声明变化

如果函数是公开的，则public关键字可以省略。
用fun关键字表示函数的定义。
如果函数没有返回值可以不用声明。
如果函数表示重载，直接在fun同一行用override修饰。
函数参数格式是变量名：变量类型。
函数参数允许空值则在后面加上?。

/**
 * 1、公共方法 public可以省略
 * 2、fun关键字表示函数定义
 * 3、test 方法名
 * 4、返回值在()后面，:Unit没有返回值，可以省略不写
 */
fun test(){
    println("没有入参，没有返回值的函数")
}

fun test():Unit{
    println("没有入参，没有返回值的函数")
}

    //无参函数调用
    test()//没有入参，没有返回值的函数

入参格式

参数格式（变量名：变量类型）
允许变量为空格式（变量名：变量类型？）

/**
 * 1、参数声明格式：变量：变量类型
 * @param name 名字
 * @param price 价格
 */
fun test1(name:String,price:Int){
    println("${name}买了一个${price}元的鸡蛋")
}

    //有参函数调用
    test1("张三",10)//张三买了一个10元的鸡蛋

/**
 * 1、如果参数运行为空在变量类型后面加上?
 * @param name 名字
 * @param price 价格
 */
fun test1(name:String?,price:Int){
    if(name != null){
        println("${name}买了一个${price}元的鸡蛋")
    }
}

返回格式

如果有返回值需要在()后面加上返回值类型，格式（:返回值类型），可以理解成跟变量定义一样。
如果没有返回值可以不用写，默认也会返回一个Unit类型对象。
返回值也是在方法体里用return返回。

/**
 * 1、有返回值需要在()后面加上【：返回值类型】
 * 2、方法体需要通过return 返回对应类型的数据
 * @param name 名字
 * @param price 价格
 */
fun test2(name:String,price:Int):String{
    println("${name}买了一个${price}元的鸡蛋")
    return "${name}买到鸡蛋了"
}

    //有返回值的函数调用
    var str = test2("李四",1)//李四买了一个1元的鸡蛋
    println(str)//李四买到鸡蛋了

入参参数的变化

参数默认值

函数入参参数可以指定默认值
格式（变量名：变量类型 = 默认值）

/**
 * 1、参数可以指定默认值
 * 2、格式：变量类型=默认值
 * @param mountain
 */
fun test(mountain:String,first:String="东岳泰山", second:String="西岳华山", third:String="南岳衡山", fourth:String="北岳恒山",five:String="中岳嵩山"){
    println("${mountain}是$first,$second,$third,$fourth,$five")
}

    //参数指定默认值，调用的时候可以不用再写
    test("中国五岳")//中国五岳是东岳泰山,西岳华山,南岳衡山,北岳恒山,中岳嵩山
    //调用的时候修改默认值，第一个默认参数可以直接修改
    test("中国五岳","泰山")//中国五岳是泰山,西岳华山,南岳衡山,北岳恒山,中岳嵩山

指定参数的默认值

如果在函数调用的时候，只想改某个参数的默认值，可以通过变量名进行指定。

    //如果修改的不是第一个有默认值的参数，需要通过变量名指定
    test("中国五岳", second = "华山")//中国五岳是东岳泰山,华山,南岳衡山,北岳恒山,中岳嵩山

可变参数

kotlin中可变参数是用关键字vararg进行修饰。
格式（vararg 变量名：变量类型）。
函数在解析的时候会将可变参数转化成数组，可通过数组形式进行访问。

/**
 * 1、参数可用可变参数，用关键字vararg说明
 * 2、格式：vararg 参数变量名:类型
 * 3、kotlin在解析的时候会把可变参数解析成数组
 * @param mountain
 */
fun test1(mountain:String,vararg strArray:String){
    var str = ""
    for (item in strArray){
        str += "$item "
    }
    println("${mountain}是$str")
}

test1("中国五岳", "东岳泰山","西岳华山","南岳衡山","北岳恒山","中岳嵩山")//中国五岳是东岳泰山 西岳华山 南岳衡山 北岳恒山 中岳嵩山

特殊函数

泛型函数

定义泛型函数时，得在函数名称前面添加“”，表示以T声明的参数（包括输入参数和输出参数），其参数类型必须在函数调用时指定。
调用格式（函数名称<具体类型>）。

/**
 * 泛型函数：<T> T表示泛型
 */
fun <T> test(tag:String,vararg array:T){
    var str:String = "$tag:"
    for (item in array){
        str = "$str${item.toString()} "
    }
    println(str)//中国五岳:东岳泰山 西岳华山 南岳衡山 北岳恒山 中岳嵩山
}

    test<String>("中国五岳","东岳泰山","西岳华山","南岳衡山","北岳恒山","中岳嵩山")
    test<Int>("10以内的偶数",2,4,6,8,10)//10以内的偶数:2 4 6 8 10

内联函数

内联函数在编译的时候被内联展开，即将函数体直接插入到调用该函数的地方。
内联函数主要用于消除函数调用的开销，特别是对于那些小而频繁调用的函数非常有用。
内联函数还可以用于实现一些高级特性，如非局部返回和重尾递归优化。
用关键字inline表示内联函数。

/**
 * 内联函数 用关键字inline
 * 在调用处将函数体直接插入
 */
inline fun <T> setNumber(number: T){
    println(number)
}

    setNumber(1)
    setNumber("张三")

函数简化

函数有返回值定义可以当初特殊的变量，变量可以通过=进行赋值，所以对于函数体是比较简单的可以通过=直接赋值给函数。

fun compare(a:Int,b:Int):Int{
    if(a > b){
        return a
    } else {
        return b
    }
}


/**
 * 函数有返回值定义可以当初特殊的变量，变量可以通过=进行赋值
 * 所以对于函数体是比较简单的可以通过=直接赋值给函数
 */
fun compare1(a:Int,b:Int) = if(a > b) a else b

fun factorial(n:Int):Int {
    if (n <= 1) return n
    else return n*factorial(n-1)
}

fun factorial1(n:Int) = if (n <= 1) n else n*factorial(n-1)

    println(compare1(1,3))//3
    println(factorial1(3))//6

尾递归函数

尾递归（Tail Recursion）是一种递归形式，其中递归调用是函数执行的最后一步。
通过关键字tailrec修饰。
尾递归优化是一种编译器优化技术，可以将尾递归调用转换为循环，从而避免栈溢出并提高性能。

/**
 * 尾递归函数，用tailrec进行修饰
 */
tailrec fun tailRecursiveFactorial(n: Int, accumulator: Int = 1):Int{
    if(n <= 1){
        return accumulator
    } else {
        return tailRecursiveFactorial(n-1,n*accumulator)
    }
}

println(tailRecursiveFactorial(3))//6

高阶函数

高阶函数（Higher-Order Function）是指一个函数，它可以接收另一个函数作为参数，或者返回一个函数作为结果。
高阶函数提供了一种非常灵活和强大的方式来处理函数逻辑，使得代码更加模块化和可重用。

接收函数作为参数

高阶函数可以接收一个或多个函数类型的参数。
格式：函数名称:(参数)->函数返回值

/**
 * 函数A作为函数B的参数
 * operation:(Int,Int) -> Int
 * operation是函数A的名称
 * (Int,Int)是函数A的参数
 * -> Int是函数A的返回值类型
 */
fun applyOperation(x:Int,y:Int,operation:(Int,Int) -> Int):Int{
    return operation(x,y)
}

    //{ a, b -> a + b } 表示参数函数A的参数和函数体，用->隔开
    var result = applyOperation(2,3) { a, b -> a + b }
    println(result)//5
    var result1 = applyOperation(2,3) { a, b -> a * b }
    println(result1)//6

返回函数作为结果

高阶函数可以返回一个函数类型的结果。
格式：在高阶函数后面:(参数)->返回值类型

/**
 * 函数A作为函数B的返回值
 * :(Int,Int)->Int
 * (Int,Int)是函数A的参数
 * ->Int 函数A的返回值
 */
fun functionB(a:Int):(Int,Int)->Int{
    return when(a){
        1 -> {b,c -> b+c}
        2 -> {b,c -> b-c}
        3 -> {b,c -> b*c}
        else -> {b,c -> b/c}
    }
}

    //返回函数
    var functionA = functionB(1)
    println(functionA(3,5))//8
    functionA = functionB(2)
    println(functionA(3,5))//-2

标准库中的高阶函数

Kotlin 标准库中有许多高阶函数，比如 let、run、apply、also、filter、map 等。这些函数极大地简化了集合操作和其他常见编程任务。

val numbers = listOf(1, 2, 3, 4, 5)
val doubled = numbers.map { it * 2 }
println(doubled) // 输出: [2, 4, 6, 8, 10]

扩展函数

扩展函数（Extension Function）是一种特殊类型的函数，它可以为现有的类添加新的成员函数，而无需使用继承或修改原有类的源代码。这种功能是通过静态成员函数的语法糖来实现的，尽管在底层实现上它们并不是真正的类成员方法。
定义：扩展函数使用receiverType.functionName的语法进行定义，其中receiverType是你要扩展的类名，functionName是你想要添加的函数名。函数体内部可以通过this关键字来引用接收者对象（即receiverType的实例）。

/**
 * 扩展函数，格式：原有类.扩展函数的名称
 * 对系统Array类增加交换扩展函数
 */
fun <T> Array<T>.swap(pos1:Int,pos2:Int){
    val temp = this[pos1]
    this[pos1] = this[pos2]
    this[pos2] = temp
}

    val intArray = arrayOf(1,2,3,4,5)
    //扩展函数调用跟普通函数一样
    intArray.swap(1,2)