Kotlin day04-函数

目录

函数定义

常见函数

vararg关键词修饰的个数可变的形参函数

函数重载

局部函数

高阶函数

函数类型赋值给变量

函数类型作为其他函数的形参

函数类型作为其他函数的返回值

---

函数定义

常见函数

 fun method01(){
        Log.e("sujd====","无返回值函数")
    }

    fun method02():String{
        return "有返回值函数,返回值类型String"
    }

    fun method03():String="只有一行返回值的函数，可以省略大括号，进行简写,单表达式函数"

    fun method04(x:Int,y:String){
        Log.e("sujd====","带参函数${x}和${y}")
    }

    fun method05(y:String="默认形参",x:Int){
        Log.e("sujd====","带参函数${x}和${y}")
    }


//调用

        method01()
        Log.e("sujd====",method02())
        Log.e("sujd====",method03())
        method04(5,"Kotlin")//传统调用
        method04(x=5,y = "Kotlin")//命名调用
        method05(x=6)

vararg关键词修饰的个数可变的形参函数

• 这种方式，函数接收过来是一个数组，并且如果后面还有参数的话，必须使用命名传参的方式

method06("1","2","3","4","5","6",x=10)    

fun method06(vararg str:String,x:Int){
        for(stri in str){
            Log.e("sujd====","${stri} ")
        }
    }

假如有这样一种情况，我有一个数组arr（只能是数组），我想把arr中是数据传入到method06中，该怎么传入呢，这里用*来代替

        var arr= arrayOf<String>("1","2","3","4","5","6")
        method06(*arr,x=10)

 

 函数重载

函数重载和Java相同，形参列表不同或者返回值类型不同

 局部函数

局部函数只能在其封闭函数中调用

Log.e("sujd====", method07("加",2,3).toString())  

fun method07(type:String,x:Int,y:Int):Int{
        fun add(x: Int,y: Int):Int{
            return x+y
        }
        fun reduce(x: Int,y: Int):Int{
            return x-y
        }
        fun cheng(x: Int,y: Int):Int{
            return x*y
        }
        fun chu(x: Int,y: Int):Int{
            return x/y
        }

        when(type){
            "加"->{
               return add(x,y)
            }

            "减"->{
                return reduce(x,y)
            }

            "乘"->{
                return cheng(x,y)
            }

            "除"->{
                return chu(x,y)
            }

            else->{
                return add(x,y)
            }

        }
    }

 

高阶函数

• 函数类型赋值给变量

当直接访问一个函数的函数引用，而不是调用函数时，需要在函数名前面加上两个冒号::，而且不能在函数后面加圆括号，否则会变成函数调用

//首先由这样一个函数
    fun method08(x:Int,y:Int):Int{
        return x+y
    }
//其次把变量定义为和该函数参数相同的类型
    var m:(Int,Int)->Int
//把函数赋给变量m
    m=::method08
//传值打印
    Log.e("sujd====", m(6,6).toString())

• 函数类型作为其他函数的形参

//首先定义一个作为形参的函数
    fun add(x: Int):Int{
        return x+x
    }
//其次，定义函数
    fun method09(list:Array<Int>,method:(Int)->Int):Array<Int>{

        var result=Array<Int>(list.size,{0})

        for(i in list.indices){
            result[i]=method(list[i])
        }
        return result
    }

//调用
        var data= arrayOf(1,2,3,4,5)
        Log.e("sujd====", method09(data,::add).contentToString())

• 函数类型作为其他函数的返回值

var n=method10("加")
Log.e("sujd====", n(10,4).toString())

fun method10(type: String): (Int, Int) -> Int {
        fun add(x: Int,y: Int):Int{
            return x+y
        }

        fun reduce(x: Int,y: Int):Int{
            return x-y
        }

        when(type){
            "加"->{
                return ::add
            }
            else->{
                return ::reduce
            }
        }
    }