• Android Kotlin 基础详解

    1,基础语法

    1.1 可变变量与不可变变量

    可以多次赋值的变量是可变变量，用关键字var表示：

    var <标识符> : <类型> = <初始化值>  注意，在kotlin中成员变量不会赋默认值，不像java一样，必须手动添加默认值。
    1. var name : String ="yuanzhen"
    2. name ="yuanzhen1"
    3. var age : Int =20
    4. age =30
    5. println("name:$name,age:$age")
    1. 输出：
    2. name:yuanzhen1,age:30

    只能赋值一次的变量，是不可变变量，用关键字val表示，类似于java里面的final：

    val <标识符> : <类型> = <初始化值> 注意，在kotlin中成员变量不会赋默认值，不像java一样，必须手动添加默认值。

    1.2类型推导

    kotlin可以根据传入的值，自动推导出变量类型：

    1. var name ="yuanzhen"  //类型推导
    2. name ="yuanzhen1"
    3. var age =20  //类型推导
    4. age =30

    1.3函数 方法

    kotlin中的Unit相当于java中的void ，如果函数的返回值为Unit，可以不用写返回值

    kotlin中使用fun关键字定义函数

    定义一个有参数和返回值的函数：

    1. fun test(name1:String ,name2:String):String{
    2.     return name1+name2
    3. }

       调用:

    1. println(test("yuan","zhen"))
    2. //输出 yuanzhen

       也可以根据类型推导，直接写成：

    fun test(name1:String ,name2:String) =name1+name2

      可变参数用关键字vararg表示：

    1. fun lenMethod(vararg value: Int) {
    2.     for (i in value) {
    3.         println(i)
    4.     }
    5. }

    调用：

    lenMethod(1, 2, 3, 4, 5, 6, 7)

    1.4字符串

    在kotlin中，$表示一个变量名或者变量值，$name 表示变量值，如果变量值有多个，可以写为：${name1+name2}

    1. var name ="yuanzhen1"  //类型推导
    2. var name1 ="yuanzhen"
    3. println("${name+name1}")

    输出：yuanzhen1yuanzhen

    换行：""" """  自己不用关心换行：

    1. val infoMesage = """
    2.     AAAAAAAAAAA
    3.     BBBBBBBBBBB
    4.     CCCCCCCCCCC
    5.     DDDDDDDDDDD
    6.     EEEEEEEEEEE
    7. """  // 前置空格
    8. println(infoMesage)
    9. val infoMesage2 = """
    10.     AAAAAAAAAAA
    11.     BBBBBBBBBBB
    12.     CCCCCCCCCCC
    13.     DDDDDDDDDDD
    14.     EEEEEEEEEEE
    15. """.trimIndent()  // 没空格
    16. println(infoMesage2)
    17. val infoMesage3 = """
    18.     ?AAAAAAAAAAA
    19.     ?BBBBBBBBBBB
    20.     ?CCCCCCCCCCC
    21.     ?DDDDDDDDDDD
    22.     ?EEEEEEEEEEE
    23. """.trimMargin("?")  // 没空格 控制？
    24. println(infoMesage3)

    输出：

    1.  
    2.     AAAAAAAAAAA
    3.     BBBBBBBBBBB
    4.     CCCCCCCCCCC
    5.     DDDDDDDDDDD
    6.     EEEEEEEEEEE
    7.  
    8. AAAAAAAAAAA
    9. BBBBBBBBBBB
    10. CCCCCCCCCCC
    11. DDDDDDDDDDD
    12. EEEEEEEEEEE
    13. AAAAAAAAAAA
    14. BBBBBBBBBBB
    15. CCCCCCCCCCC
    16. DDDDDDDDDDD
    17. EEEEEEEEEEE

    1.5 null检查机制

    在kotlin中，如果你这么定义一个变量，一定会报错的

    因为这是kotlin特有的机制，不允许直接赋空值。那么要怎么做呢？

    var age:Int?=null

    加个？的意思就相当于 我发出了一个广播，告诉所有人这个值可能是空的，必须要有处理措施。

    第一种处理措施：

    1. var age:Int?=null
    2. val i = age?.and(2)
    3. println("$i")

    输出：null

    age?.and(2)的意思就是如果age是null，那就不执行？后面的内容了

    第二种处理措施：

    1. var age:Int?=null
    2. age!!.and(2)

    !!的意思就是我不管，我就强行执行and方法，出了事我负责。

    第三种处理措施：

    就跟java一样，自己判断处理

    1. var age:Int?=null
    2. if(age !=null){
    3.     age.and(2)
    4. }

    1.6 区间

    区间用..来表示

    1. // 1 到 9
    2. for (i in 1..9) {
    3.     println(i)
    4. }

    输出 1 2 3 4 5 6 7 8 9

    那如果这样写呢？

    1. for (i in 9..1) {
    2.     println(i)
    3. }

    注意：这样是不会输出的，因为没有9到1这种写法，那如果非要输出9到1呢？

    1. for (i in 9 downTo 1) {
    2.     println(i)
    3. }

    要用downTo

    还可以指定步长：

    1. for (i in 1..20 step 2) {
    2.    println(i)
    3. }

    输出：1 3 5 7 9 11 13 15 17 19    每隔2输出一个值

    排除最后一个元素：

    1. for (i in 1 until 10) {
    2.     println(i)
    3. }

    输出：1 2 3 4 5 6 7 8 9 

    2, 比较与数组

    2.1比较

    在java中比较两个字符串，用equls来比较，但是在kotlin中，用==来比较字符串的值

    1. val name1: String = "张三"
    2. val name2: String = "张三"
    3.  
    4. println(name1 == name2)

    比较对象地址用===表示

    1. // ---  比较对象地址
    2. val test1:Int? =  10000
    3. val test2:Int? =  10000
    4. println(test1 === test2)

    输出false

    2.2 数组

    在java中数组有三种创建方式：

    1. int[] array  = {1,2,3};
    2. int[] array1 = new int[3];
    3. int[] array2 = new int[]{7,8,9};

    在kotlin中 数组有两种方式：

    第一种:

    val numbers = arrayOf(1, 2, 3, 4, 5, 6, 7, 8)

    第二种：

    1. val numbers2 = Array(10,  {value: Int -> (value + 200) })
    2. for (value in numbers2) {
    3.     println(value)
    4. }

    输出：

    200
    201
    202
    203
    204
    205
    206
    207
    208
    209

    为什么会这样呢？ 因为value的默认值是0，之后会依次加一。

    3,条件控制

    比较大小值，可以这样写:

    1. val number1: Int = 99
    2. val number2: Int = 88
    3. // 表达式 比 大小 最大值
    4. val maxValue = if (number1 > number2) number1 else number2
    5. println(maxValue)

    输出99 

    如果要执行多行代码，还可以这样写：

    1. val max: Int = if (number1 > number2) {
    2.     println("number1是最大的")
    3.     number1
    4. } else {
    5.     println("number2是最大的")
    6.     number2
    7. }

    注意：返回值不需要加return关键字

    when相当于java中的switch case，只不过用法更加灵活

    用于某个值：

    1. val number5 = 5
    2. when(number5) {
    3.     1 -> println("一")
    4.     2 -> println("二")
    5.     3 -> println("三")
    6.     4 -> println("四")
    7.     5 -> println("五")
    8.     else -> println("其他")
    9. }

    用于区间：

    1. val number = 700
    2. when(number) {
    3.     in 1..100 -> println("1..100")
    4.     in 200..500 -> println("200..500")
    5.     else -> println("其他")
    6. }

    用于执行多行代码 并且有返回值：

    1. val number = 3
    2. val result = when (number) {
    3.     1 -> {
    4.         println("很开心")
    5.         "今天是星期一"
    6.         99
    7.     }
    8.     2 -> {
    9.         println("很开心")
    10.         "今天是星期二"
    11.         88
    12.     }
    13.     3 -> {
    14.         println("很开心")
    15.         "今天是星期三"
    16.         true
    17.         100
    18.     }
    19.     else -> 99
    20. }

    4，循环与标签

    4.1标签

    自定义标签：在kotlin中，我们可以自定义一个标签，用来控制程序的执行流程等

    1. yuanzhen@ for (i in 1..20) {
    2.     for (j in 1..20) {
    3.         println("i:$i, j:$j")
    4.         if (i == 5) {
    5.             // break // j循环 给break
    6.             break@yuanzhen // i循环 给break
    7.         }
    8.     }
    9. }

    一个类中自带的标签：

    1. class Yuan {
    2.  
    3.     val I = "aa"
    4.  
    5.     fun show() {
    6.         println(I)
    7.         println(this.I)
    8.         println(this@Yuan.I)
    9.     }
    10.  
    11. }

    4.2循环

    在kotlin中，要遍历一个list，通常有三种方式：

    var items  = listOf("aaa", "bbb", "ccc")

    方式一：

    1. for (item in items) {
    2.     println(item)
    3. }

    方式二：

    1. items.forEach {
    2.     println(it)
    3. }

    方式三：

    1. for (index in items.indices) {
    2.     println("下标：$index,  对应的值：${items[index]}")
    3. }

    5，类与对象

    5.1类的创建

    在kotlin中，创建一个类，如果前面不写修饰符，默认就是public final 

    1. // 默认就是public final
    2. class Empty

    这样是不能被继承的，要想被继承，就必须加上open

    open class Person{}

    5.2构造函数

    在java中，会有一个默认的构造函数，并且可以重载无数个构造函数。

    但是在kotlin中，它会有一个默认的主构造函数，其余的都是次构造。

    上面的Person类，相当于有一个默认的主构造：

    1. open class Person() // 主构造
    2. {
    3.  
    4. }

    那如果我们要给主构造增加一个参数呢？

    1. open class Person(id: Int) // 主构造
    2. {
    3. }

    那如果还要增加好几个次构造呢？

    1. open class Person(id: Int) // 主构造
    2. {
    3.  
    4.     // 次构造
    5.     constructor(id: Int, name: String) : this(id) {
    6.  
    7.     }
    8.  
    9.     // 次构造
    10.     constructor(id: Int, sex: Char) : this(id) {
    11.  
    12.     }
    13.  
    14.     // 次构造
    15.     constructor() : this(222) {
    16.  
    17.     }
    18.  
    19. }

    次构造必须继承主构造，同时把参数传给主构造

    在使用时，可以这么用：

    1. val person = Person() // 次构造
    2. val person2 = Person(23456) // 主构造
    3. Person(234, "yy") // 次构造
    4. Person(234, 'M') // 次构造

    5.3类的继承

    继承父类用：表示

    1. class Student(id: Int) : Person(id) // 主构造
    2. {
    3.     // 再Kotlin 全部都是没有默认值的
    4.  
    5.     // 再Java 成员有默认值，但是方法内部没有默认值
    6.  
    7.     // lateinit 懒加载 不用立马赋值，在使用的时候赋值， 没有赋值 就不能使用，否则报错
    8.     lateinit var name : String
    9.     var age: Int = 0
    10. }

    5.4接口

    在kotlin中，接口和抽象类默认都是open的

    1. interface Callback {
    2.  
    3.     fun callbackMethod() : Boolean
    4.  
    5. }
    1. interface Callback2 {
    2.  
    3.     fun callbackMethod() : Boolean
    4.  
    5. }
    1. abstract class Person : Callback , Callback2 {
    2.  
    3.     abstract fun getLayoutID() : Int
    4.  
    5.     abstract fun initView()
    6.  
    7. }
    1. class Student : Person() {
    2.  
    3.     override fun getLayoutID(): Int = 888
    4.  
    5.     override fun initView() { }
    6.  
    7.     override fun callbackMethod(): Boolean  = false
    8. }

    与java差别不大

    5.5data数据类

    数据类是kotlin中独有的，在java中，我们要写数据类，通常会手写很多属性和方法等。

    在kotlin中，我们只需要用数据类定义属性就可以，不用关心get，set等方法，内部会自动帮我们生成。

    1. // 会自动生成get set 构造 equals hashCode toString copy
    2. data class User(val id: Int, val name: String, val sex: Char)
    1. val user = User(99, "lisi", 'M')
    2. //copy 函数
    3. val(myID, myName, mySex) = user.copy()
    4. println("myID:$myID, myName:$myName, mySex:$mySex")

    5.6单例

    在kotlin中，object只实例一次，相当于单例

    1. object MyEngine {
    2.  
    3.     fun m() {
    4.         println("M run")
    5.     }
    6.  
    7.     fun show() {
    8.         println("我就只有一个实例")
    9.     }
    10. }

    companion ：意思是同伴对象。相当于java的static.

    下面来看一下kotlin中的单例模式怎么写：

    方式一：

    1. class NetManager {
    2.  
    3.     // 只有一个实例
    4.     object Holder {
    5.  
    6.         val instance = NetManager()
    7.  
    8.     }
    9.  
    10.     // 看不到 static  可以 派生操作
    11.     companion object {
    12.  
    13.         // 全部都是  相当于 Java static
    14.  
    15.         fun getInstance() : NetManager = Holder.instance
    16.     }
    17.  
    18.     fun show(name: String) {
    19.         println("show:$name");
    20.     }
    21.  
    22. }

    方式二：

    1. class NetManager2 {
    2.  
    3.     companion object {
    4.  
    5.         private var instance: NetManager2? = null
    6.  
    7.         // 返回值：允许你返回null
    8.         fun getInstance(): NetManager2? {
    9.             if (instance == null) {
    10.                 instance = NetManager2()
    11.             }
    12.  
    13.             // 如果是null，也返回回去了
    14.             return instance
    15.  
    16.             // 第二种补救： 我来负责 instance 肯定不为null
    17.             // return instance!!
    18.         }
    19.  
    20.     }
    21.  
    22.  
    23.     fun show(name: String) {
    24.         println("show:$name");
    25.     }
    26.  
    27. }

    5.7嵌套类

    嵌套类，就是在类的内部又写了一个类，但是它不是内部类，拿不到外部类的成员。

    1. class Sub {
    2.     fun show() {
    3.         println()
    4.     }
    5.     class A {
    6.         class B {
    7.             class C {
    8.             }
    9.         }
    10.     }
    11. }

    5.8内部类

    在kotlin中，内部类用关键字inner来表示。

    1. class Sub {
    2.     fun show() {
    3.         println()
    4.     }
    5.     class A {
    6.         class B {
    7.             class C {
    8.             }
    9.         }
    10.     }
    11.    }
    12.     // 这个才是内部类
    13.     inner class Sub2 {
    14.         fun show() {
    15.             println(I)
    16.         }
    17.     }
    18. }

  • 相关阅读:
    为什么老外会说有些业务员的询盘回复不是他想要的？
    RabbitMQ（四）
    AI写代码：我用kimi生成了一个设备节点监控网站，完美实现功能
    Scala语言使用Selenium库编写网络爬虫
    压力之下番茄也会「惊声尖叫」，特拉维夫大学发现植物王国不沉默
    微信小程序第三天
    VScode 自定义主题各参数解析
    数据结构_复杂度讲解(附带例题详解)
    uni-app生命周期详解
    Windows 配置 C/C++ 编译环境指南
  • 原文地址：https://blog.csdn.net/y2653904/article/details/132880145