kotlin的学习记录

马东18

已于 2023-10-27 15:51:47 修改

阅读量79

点赞数

文章标签： kotlin 学习开发语言

于 2023-10-20 20:29:07 首次发布

本文链接：https://blog.csdn.net/madong369/article/details/133869006

版权

apply apply

apply函数的详解

MyData?.apply{

//MyData不为空的时候，执行操作这里。

}


class MainActivity : AppCompatActivity() {
    override fun onCreate(savedInstanceState: Bundle?) {
        super.onCreate(savedInstanceState)
        setContentView(R.layout.activity_main)

        //总结回调问题解决了，现在也稍微理解了，还不是因为自己手敲代码，敲的少。


        // 3 创建初始化的那个类， 并且用类，   在新的一个类中进行实时回调
         var callInit3 = CallInit()
        //实时回调，操作
        callInit3.setEventListener(object: CallBack{

            override fun action(string: String) {
                TODO("Not yet implemented")
            }

            override fun myAction() {
                TODO("Not yet implemented")
            }

        })

        //匿名函数 == Lambada表达式
    }




    //这边继续写一个接口回调
   // 1 首先是接口，然后定义接口中的方法

    interface CallBack{
        //有参数的方法，  没有参数的方法
        fun action(string: String)
        fun myAction()
    }



    //2 在写一个类 初始化 并且调用起这个方法
    class CallInit {

        private lateinit var callBack2: CallBack

        //接口的初始化，操作。
       fun  setEventListener(callBack1: CallBack){
           this.callBack2 = callBack1

            callBack2.action("马东")
            callBack2.myAction()
       }


    }

}










    }


}

package com.example.myjavaapplication
import android.util.Log


class StudyGrammar {

    /*
      在接触Kotlin开始，的疯狂的提前的储备它的一些特性和它的一个经典的语法，要不你在写需求的时候，你会卡的很厉害，所以啊
      在开始的时候，要多用空余时间去学习它的一些特性，要不到写大需求的时候就凉凉了，就能卡si到写需求的过程中。

    * lambda表达式，在项目中用的非常多，非常多，所这个知识点必须非常熟悉 非常熟悉的 掌握
    * */

    //lambda表达式，=== 匿名函数

    //匿名函数  没有名字的方法   fun是关键字
    val anonymity = fun(){

    }


    //这个是没有参数，也没有返回值的 lambda表达式
    val lambdaFunction1:() -> Unit = {

    }


    //这个是基于 lambdaFunction1 上面的   没有参数，没有返回值的  lambda 简易写法  取掉 “ :() -> Unit ”
    val lambdaFunction2 = {

    }


    // lambda表达式，参数是int  返回值也是 int的
    val lambdaFunction3:(Int) -> Int = {
        // it代表传进来的参数， 这个有返回值的最后一行必须有对应返回的类型
        //最后一行的是  int的返回值  Int的返回值，都是最后的一行。
        it + 3
    }


    //这个方法是简化不了的，因为这个有 （Int）这个传进来的这个参数呢
    val lambdaFunction4:(Int)->Int={
        it+4  // 参数只有一个的时候，系统会默认自带it   如果有多个参数的时候，自己的定义一下。
    }


    //这个方法是可以简化的，因为（）里面没有参数  可以直接取掉  " :()->Int "
    val lambdaFunction5:()->Int={
        5
    }

    val lambdaFunction5to1:()->Int={5}


    //这个方法基于上面 lambdaFunction5  简化的lambda表达式  去掉 " :()->Int " 后的简化方法
    val lambdaFunction6={
        6
    }


    //这些（）里面有参数的这些是简化不了的，因为（）里面都有参数。
    val lambdaMoreParameter1:(Int,Int,Int)->Int={x,y,r->
        x+y+r+7
        7
    }


    //()里面是参数类型        -> 所指的就是返回类型       函数内容的实现在{}里面     _ 下划线代表这个参数用不上，就不会报错了
    val lambdaMoreParameter2:(Int,Int)->Int ={x,_->
        x+8 // 会自动取识别最后一行的值，为返回值。
        8
    }

    //---------------------------------------------------- 1

    //lambda表达式的实现就是用一个 {} 实现的--->写入函数体
    //lambda表达式本身也就是一个函数
    fun mainTest() {
        //取掉（） 简化写法    原本是test()
        test {

        }
    }

    //参数就是lambda表达式
    //我们的函数参数 最后一个为lambda表达式的时候 可以把{}写在外面 --> test（）{}
    fun test(lambdaFunction1:()->Unit){

    }

    //---------------------------------------------------- 2

        fun mainTest2(){
            test2(1){

            }
    }

    fun test2(a:Int,lambdaFunction1:()->Unit){

    }

    //---------------------------------------------------- 3

    fun mainTest3() {
        //取掉（） 简化写法    原本是test()
        //this 代表是 1
        test3{

        }
    }

    //参数就是lambda表达式
    //我们的函数参数 最后一个为lambda表达式的时候 可以把{}写在外面 --> test（）{}
    fun test3(lambdaFunction1:Int.()->Unit){
        1.lambdaFunction1()
    }

    //---------------------------------------------------- 4

    fun mainTest4() {
        //取掉（） 简化写法    原本是test()
        //this 代表是 4
        test4<Int>(4){
            Log.d("dong","打印出-->  $this ")
        }
    }

    //参数就是lambda表达式
    //我们的函数参数 最后一个为lambda表达式的时候 可以把{}写在外面 --> test（）{}
    //定义泛型，泛型，加入的参数泛型
    fun <T>test4(re:T,lambdaFunction1:T.()->Unit){
        re.lambdaFunction1()
    }






    // ==============================================================================

    fun mainMethod() {
        //这块我关注的重点是， addResultMethod(1,1) 这个方法对应的传参数是对应的  number1:Int,number2:Int  这个是我需要关注的，可能这个就是它的这个语法的写法吧。
        addResultMethod(1,1)

    }

    // 匿名函数 == lambda表达式
    val addResultMethod={number1:Int,number2:Int->
        number1+number2
        Log.d("dong"," 两数相加结果是 ： ${ number1+number2 } ")
    }


    /*匿名函数 入参 Int，   返回 Any类型
    *lambda表达式的参数是 Int，   lambda表达式的结果是Any类型
    *
    * Any == java中的 object
    * */
    val addResultMethod2 = {number: Int->
        when(number){
            1->"星期一"
            2->"星期二"
            3->"星期三"
            4->"星期四"
            else->-1
        }

    }

    fun mainMethod2() {
        //这块我关注的重点是， addResultMethod(1,1) 这个方法对应的传参数是对应的  number1:Int,number2:Int  这个是我需要关注的，可能这个就是它的这个语法的写法吧。
        addResultMethod2(1)
    }
    
// ==============================================================================
    
}

package com.example.myjavaapplication

import androidx.appcompat.app.AppCompatActivity
import android.os.Bundle
import android.util.Log
import java.io.File


class MainActivity : AppCompatActivity() {
    private val info = "ma dong Learn grammar"

    override fun onCreate(savedInstanceState: Bundle?) {
        super.onCreate(savedInstanceState)
        setContentView(R.layout.activity_main)

        //普通的写法
        Log.d("dong"," ${info.length}")
        Log.d("dong"," ${info.substring(0,7)}")
        Log.d("dong"," ${info.toUpperCase()}")


        //apply内置函数的方式
        //info.apply特点：apply始终返回info本身String类型   apply里面是 this  本身的可以直接用
        val infoTest :String= info.apply {
            //一般匿名函数，都是it的状态，但是apply这个是持有this == info 本身
            length
            substring(0,12)
            toUpperCase()


            Log.d("dong","apply匿名函数里面打印的：$this")


            Log.d("dong"," $length")
            Log.d("dong"," ${substring(0,12)}")
            Log.d("dong"," ${toUpperCase()}")

        }

        Log.d("dong","val infoTest :String    $infoTest       ")


        //真正使用apply的规则写法
        info.apply{
            Log.d("dong"," $length")
        }.apply {
            Log.d("dong"," ${substring(0,16)}")
        }.apply {
            Log.d("dong"," ${toUpperCase()}")
        }

        Log.d("dong","=======================================================================================")

        //普通用法
        val file = File("E:\\a.txt")
        file.setExecutable(true)
        file.setReadable(true)
        Log.d("dong"," ${file.readLines()}")


        //apply的使用方法
        file.apply {
            //这个方法里面有this，谁点出它，就是谁  这个里面就是 file    this = file
            file.setExecutable(true)
        }.apply {
            file.setReadable(true)

        }.apply {
            Log.d("dong"," ${file.readLines()}")
        }

        // 使用场景 apply


       }

   }