Android Kotlin 从入门到精通(三、方法 Lambda表达式)

Kotlin 方法的使用

class demo2 {
    @Test
    fun main(){
        println("方法调用:${learn(4,7)}")
        println("普通类方法调用:${learn_class().learn(4,7)}")
        //静态类里面的方法，都是静态方法
        //不需要构建实例对象，可以通过类名，直接访问静态方法
        val result  = xxxUtil.double(10)
        println("静态类方法调用：${result}")
        //伴生类的使用
        learn_class.learn2()
    }

    //fun 方法名（变量名：变量类型，变量名：变量类型）：返回类型{ return}
    fun learn(a:Int,b:Int):Int{
        return a*b
    }
}
//普通类
class learn_class{
    fun learn(a:Int,b:Int):Int{
        return a+b
    }
    //当我们想在一个普通类定义一个静态方法的话  不需要构建实例对象，可以通过类名，直接访问静态方法
    companion object{
        fun learn2(){
            println("伴生类调用")
        }
    }
}
//静态类 如果我们想实现一个util工具类，可以借助 关键字 object来创建一个静态类
object xxxUtil{
    fun double(a:Int,):Int{
        return a*2
    }
}

具名参数

class demo3 {
    @Test
    fun main(){
        read(1,3)
        //使用具名参数(指定参数名称传值) 只给b传参数 a默认为0
        read(b=3)

        //括号内
        read2(1,2, action = {
            //方法体中的最后一行，就是该方法的返回值
            val str = "hahaha"
            "括号内使用具名参数，传递action参数" //return 可以省略
        })
        //括号外
        read2(b=10,){
            "括号外传递action参数"
        }
    }


    //read中 a为默认参数（调用该方法是时没有给a传参数时默认为0）
    fun read(a:Int=0,b:Int){
        println("read方法：a=${a} b=${b}")
    }


    // a：int 他有一个默认值0
    // b：int 他没有默认值
    // 第三个参数是一个方法，参数名叫做，action:() 如果参数的类型是()，说明该参数是一个方法类型
    // 方法参数的返回值使用 ->String
    fun read2(a:Int=0,b:Int,action:()->String){
        val ret = action();
        println("read2:${ret}")
    }
}

变长参数

fun main(){

        val result = read3('1', '2', '3', '4')
        println("可变长参数调用 ${result}")

        val word = charArrayOf('w','o','r','d')
        val result2 = read3('h', 'e', 'l', 'l','o',',',*word) //*数组名 会将数组中元素依次传图
        println("可变长参数:${result2}")

        val result3 = read4('h', 'e', 'l', 'l','o',',',*word, sum = 100) //*数组名 会将数组中元素依次传图
        println("可变长参数(带其他参数，需使用具名参数传值：${result3})")
    }

    //可变的参数 Vararg 如果Vararg不是最后一个参数 可以使用具名参数语法传值
    fun read4(vararg str:Char,sum:Int):String{
        val result = StringBuffer()
        for (char in str){
            result.append(char)
        }
        result.append(sum)
        return result.toString()
    }

    //可变的参数 Vararg
    fun read3(vararg str:Char):String{
        val result = StringBuffer()
        for (char in str){
            result.append(char)
        }
        return result.toString()
    }

    

Lambda 表达式

class demo4_Lambda {
    @Test
    fun main(){
        //调用具有方法类型参数的方法
        val numbers = arrayOf(1,2,3,4)
        //具名参数低啊用，即使用参数名action给他赋值
        transfrom(numbers,action = {index,element ->
            index*element
        })
        for (num in numbers){
            println("transfrom:$num") //输出: 0,2,6,12
        }
    }

    //lambda 表达式作为方法中的参数的时候 定义transform方法，可以对数组中的元素进行变换
    //array ：要求传入一个数组，元素类型为Int整数类型
    //action：要求传入的是一个方法，接收两个参数下标index，元素element。
    // 要求返回变换后的元素，会替换老得元素
    fun transfrom(array:Array<Int>,action:(index:Int,element:Int)->Int){
        for (index in array.indices){
            val newValue = action(index,array[index])
            array[index] = newValue
        }
    }
}

这个地方对新学者比较难理解,解释下运行流程

运行流程:

        1、将数组(1,2,3,4)传入transfrom中 

        2、在for循环中遍历,将数组的下标和值传入action方法中(index*element) 

        3、第一次循环 下标index为0 值为1  在action方法中1*0返回0赋值给newValue 

        4、再将array数组中下标为index 的位置替换成newValue中的值  直到循环结束

        5、这样得到的新数组array中的值为{0,2,6,12}

//与上面方法穿惨作用相同 省掉方法名称
transfrom(numbers) { index, element -> 
            index * element
        }

forEachIndexed方法

        val list = arrayListOf<Int>(1,2,3,4,5,6)
        //括号内输出
        list.forEachIndexed(action = {index: Int, element: Int ->
            println("forEachIndexed:${index}->${element}")
        })
        //括号外输出
        list.forEachIndexed { index, element ->
            println("forEachIndexed:${index}->${element}")
        }