kotlin语法快速入门--（完整版）

2024-05-14 1039阅读

温馨提示：这篇文章已超过386天没有更新，请注意相关的内容是否还可用！

Kotlin语法入门

文章目录

  • Kotlin语法入门
    • 一、变量声明
      • 1、整型
      • 2、字符型
      • 3、集合
        • 3.1、创建array数组
        • 3.2、创建list集合
        • 3.3、不可变类型数组
        • 3.4、Set集合--不重复添加元素
        • 3.5、键值对集合Map
        • 4、kotlin特有的数据类型和集合
          • 4.1、Any、Nothing
          • 4.2、二元组--Pair
          • 4.3、三元组--Triple
          • 5、const关键字
          • 二、条件控制和循环语句
            • 1、if...else
            • 2、when
              • 2.1、常规用法
              • 2.2、特殊用法--并列：
              • 2.3、特殊用法--类型判断：
              • 2.4、特殊用法--区间：
              • 2.5、返回值
              • 3、循环
                • 3.1、for..in
                • 3.2、forEach
                • 3.3、迭代器
                • 3.4、【扩展】for..in中的withIndex方法
                • 3.5、【扩展】forEachIndexed()方法
                • 3.6、do...while和while
                • 4、return，break，continue结束语句的使用
                  • 4.1、结束循环分支
                  • 4.2、标签备注代码块--@
                  • 4.3、forEach退出循环的几种方式
                  • 三、区间
                    • 1、语法
                    • 2、遍历
                    • 3、查找是否在区间内
                    • 4、字符区间
                    • 四、函数
                      • 1、函数定义
                      • 2、infix关键字
                      • 3、参数省略
                      • 4、函数类型参数
                      • 5、多参数--vararg
                      • 五、访问和属性修饰符
                        • 1、kotlin修饰符
                        • 2、internal
                        • 3、默认修饰符
                        • 4、open关键字开启继承并实现
                        • 六、类与对象
                          • 1、声明和调用
                          • 2、get和set
                          • 3、init函数初始化
                          • 4、constructor构造函数
                            • 4.1、主构造函数
                            • 4.2、二级构造函数
                            • 4.3、多个构造函数
                            • 4.4、省略主构造函数并写了次构造函数
                            • 5、类的继承与重写
                              • 5.1、继承
                              • 5.2、继承构造函数初始化
                              • 5.3、函数的重写
                              • 5.4、属性的重写
                              • 6、抽象类、嵌套类和内部类
                                • 6.1、抽象类
                                • 6.2、嵌套类
                                • 6.3、内部类
                                • 七、自定义注解
                                • 八、接口与接口实现
                                  • 1、接口定义与实现
                                  • 2、接口成员变量
                                    • 2.1、单个接口函数复写
                                    • 2.2、多个接口同名函数复写
                                    • 2.2、接口成员存在变量和常量
                                    • 九、数据类、伴生类、枚举类
                                      • 1、数据类
                                      • 2、伴生类
                                        • 2.1、定义伴生类
                                        • 2.2、@JvmStatic注解
                                        • 2.3、const关键字
                                        • 3、枚举类
                                          • 3.1、定义
                                          • 3.2、传参
                                          • 3.3、继承与实现
                                          • 十、单例和对象表达式
                                            • 1、单例模式的创建
                                            • 2、对象表达式
                                            • 十一、密封类和密封接口
                                              • 1、密封类
                                              • 2、密封接口

                                                一、变量声明

                                                1、整型

                                                fun main() {
    var b: Int = 1
  //var 变量名：变量类型=值
    val c=100
  //var 常量名：变量类型=值
}

                                                kotlin中的变量是自动推导的，其中变量类型Int是可以省略的。

                                                kotlin语法快速入门--（完整版）

                                                val常量：kotlin语法快速入门--（完整版）

                                                2、字符型

                                                定义就与上面一样，调用的方法也与java差不多，equals等。

                                                占位符：

                                                fun main() {
    var string: String = "hello world !"
    println("hello ${string}") //输出
}

                                                输出：kotlin语法快速入门--（完整版）

                                                多模版输出：

                                                fun main() {
    var string: String ="""
        1 2 3 4 5 6 7 8 9 10
    """.trimIndent() //此方法可以忽略缩进
    println(string)
}

                                                3、集合

                                                前景提要：除了数组都分为可变集合和不可变集合，区别就是在前面加上前缀mutable，这是kotlin语法中特有的。

                                                关键字如下：

                                                • array==>arrayof
                                                • list==>listof
                                                • 可变list==>mutableListOf
                                                  3.1、创建array数组
                                                  fun main() {
    var array: Array = arrayOf( 1,2,3)
    var get = array.get(0)
    println(get)
}

                                                  以上是常规的创建方法，也可以用自定义的方法，下面以Int为例，其实基本数据类型都是有的。

                                                  fun main() {
    var array: IntArray = intArrayOf(1, 2, 3) //int数组
    var array1: Array = emptyArray()  // 空数组
}
                                                  3.2、创建list集合
                                                  fun main() {
    var listOf = listOf( 1, 2, 3)
    println(listOf[0]) //获取第1个数据
}

                                                  当然，Int前面或者后面写一个就行。上述集合是可变的

                                                  3.3、不可变类型数组
                                                  fun main() {
    var array: IntArray = intArrayOf(1, 2, 3) 
    var mutableListOf = mutableListOf(1, 2, 3)
    array.add()  //不可变，没有add（）
    mutableListOf.add(6)  //可变，有add（）
}

                                                  kotlin语法快速入门--（完整版）

                                                  3.4、Set集合–不重复添加元素

                                                  不可变集合的方式：

                                                  fun main() {
    setOf(1, 2, 3, 3, 3, 3).forEach{ //遍历集合
        println(it)
    }
}

                                                  kotlin语法快速入门--（完整版）

                                                  可变集合的方式：

                                                  fun main() {
    var mutableSetOf = mutableSetOf(1, 2, 3, 4, 5)
}
                                                  3.5、键值对集合Map

                                                  中间用to来实现键值对的配对

                                                  fun main() {
    var mutableMapOf = mutableMapOf("1" to 1, "11" to 11) //多个参数逗号隔开
    mutableMapOf.put("2", 2)
    mutableMapOf.put("3", 3)
    println(mutableMapOf["1"]) //获取键为1的数据
    println(mutableMapOf.keys) //keys是获取所有的key的set集合
    println(mutableMapOf.keys.size) //数据长度
}

                                                  kotlin语法快速入门--（完整版）

                                                  4、kotlin特有的数据类型和集合

                                                  4.1、Any、Nothing

                                                  Any不再介绍，类似于Java中的Object。

                                                  Nothing：没有什么是没有实例的。您可以使用Nothing来表示“一个永远不存在的值”：例如，如果函数的返回类型为Nothing，则意味着它永远不会返回（总是抛出异常）。

                                                  可以看kotlin中的null就是这样的一个数据类型：

                                                  kotlin语法快速入门--（完整版）

                                                  kotlin中最具有特色的是：不会有空指针存在

                                                  例如：Null不能是非Null类型Int的值法一：kotlin语法快速入门--（完整版）

                                                  法一：

                                                  官方推荐写法：kotlin语法快速入门--（完整版）

                                                  这样后续在调用b的时候就进行了为空的判定，例如：kotlin语法快速入门--（完整版）

                                                  解释：b在拼接3的时候，？就会进行判定b是否为空，如果b为空那就不会调用plus方法，这样就避免了空指针异常。

                                                  （上述输出为null，即调用b.toString()方法输出。）

                                                  法二：

                                                  还有一点就是b在一定不为空的情况下，则可以使用！！强制赋值，例如：kotlin语法快速入门--（完整版）

                                                  并且后续使用b调用方法都不用再使用？判定b值是否为空。

                                                  法三：

                                                  使用lateinit关键字（只能对复杂类型初始化）进行初始化延后，但是不推荐这种写法，类似于欺骗编译器我等一会初始化，例如：kotlin语法快速入门--（完整版）

                                                  4.2、二元组–Pair

                                                  与下面的Triple一样都是属于kotlin中特有的数据集合。

                                                  fun main() {
    var pair = Pair(1, 2)
    println("第一个值：${pair.first}，第二个值：${pair.second}")
}
                                                  4.3、三元组–Triple
                                                  fun main() {
    Triple(1, 2, 3).let {
        println(it.first)
        println(it.second)
        println(it.third)
    }
}

                                                  5、const关键字

                                                  在Kotlin中，const关键字只能用于以下情况：

                                                  1. 伴生对象中的属性：const关键字可以用于伴生对象中的属性，将其声明为常量。
                                                  2. 顶层属性：const关键字可以用于顶层属性，将其声明为常量。
                                                  3. 原生数据类型和String类型：const关键字只能用于基本数据类型（如Int、Long、Double等）和String类型。

                                                  需要注意的是，const关键字所修饰的属性必须在编译时就能确定其值，不能是运行时才能确定的值。

                                                  另外，const关键字只能用于编译期常量，而不能用于运行时常量。因此，在使用const关键字时需要遵守以上规则

                                                  二、条件控制和循环语句

                                                  1、if…else

                                                  常规分支：

                                                  fun main() {
    var a = 1
    if (a == 1) {
        println("a is 1")
    } else {
        println("a is not 1")
    }
}

                                                  kotlin新特性：if语句可以有返回值

                                                  fun main() {
    var a = 1
    val b = if (a == 1) {
        3
    } else {
        4
    }
    println(b)
}

                                                  像上述这种，假如条件成立，则赋值给a，返回值不用return 即可返回。

                                                  但是，注意的是假如要有返回值，则必须要写else分支。

                                                  kotlin语法快速入门--（完整版）

                                                  多分支已是如此：

                                                  fun main() {
    var a = 1
    val b = if (a == 1) {
        3
    } else if(a==3)  {
        4
    }else{
        5
    }
    println(b)
}

                                                  由于kotlin没有三元表达式，所以，可以使用if及其分支拟造一个三元表达式：

                                                  fun main() {
 var a = 1
 var b = 2
 val c = if (a == b) true else false
 println(c)
}

                                                  2、when

                                                  2.1、常规用法

                                                  关于when的用法，可以对标Java中的Switch，示例代码如下：

                                                  fun main() {
    var a = 1
    when (a) {
        1 -> println("a is 1")
        2 -> println("a is 2")
        else -> println("a is null")
    }
}

                                                  其中，else是默认输出语句，对标Java中的default

                                                  2.2、特殊用法–并列：
                                                  fun main() {
    var a = 1
    when (a) {
        1,3 -> println("a is 1")  //1或3
        2 -> println("a is 2")
        else -> println("a is null")
    }
}
                                                  2.3、特殊用法–类型判断：
                                                  fun main() {
    var a: Any = 1
    when (a) {
        is Int -> println("a is Int")
        is String -> println("a is String")
        else -> println("a is else")
    }
}
                                                  2.4、特殊用法–区间：
                                                  fun main() {
    var a: Any = 1
    when (a) {
        in 1..10 -> println("a is in range")
        is String -> println("a is a String")
        else -> println("none of the above")
    }
}

                                                  值得注意的是，每当判断到成立条件的时候，下面的条件不管成立否都不会执行。

                                                  还有，多个条件可以并列写，例如:

                                                  fun main() {
 var a: Any = 11
 when (a) {
     in 1..10,is Int -> println("a is in range or is Int")
     else -> println("none of the above")
 }
}
                                                  2.5、返回值

                                                  与if一样，kotlin的when也可以带上返回值，将返回值写在执行的最后一样即可:

                                                  fun main() {
    var a: Any = 11
    val b = when (a) {
        in 1..10 -> {
            println("a is in range")
            1
        }
        is Int -> {
            println("a is a Int")
            2
        }
        else -> {
            println("none of the above")
            3
        }
    }
    println(b)
}

                                                  3、循环

                                                  3.1、for…in
                                                  fun main() {
    var list = (1..
        println(i)
    }
}

    var list = (1..
        println(it)
    }
}

    var list = ('a'..value-
         println(value)
    }
}

    var list = (1..
        println(iterator.next())
    }
}

    var list = ('a'..
        println("$index $i")
    }
}

    var list = ('a'..index, value-
         println("$index $value")
    }
}

    var i = 1
    do {
        println("$i")
    } while (i++  println("玩家3")
        is EnemyType1 -> println("敌人1")
        is EnemyType2 -> println("敌人2")
        is EnemyType3 -> println("敌人3")
    }
}
fun handerWeapon(role: Weapon) {
    when (role) {
        is PlayerType1 -> println("玩家1")
        is PlayerType2 -> println("玩家2")
        is PlayerType3 -> println("玩家3")
        is EnemyType1 -> println("敌人1")
        is EnemyType2 -> println("敌人2")
        is EnemyType3 -> println("敌人3")
    }
}
sealed interface Health {}
sealed interface Weapon {}
class PlayerType1 : Health, Weapon
class PlayerType2 : Health, Weapon
class PlayerType3 : Health, Weapon
class EnemyType1 : Health, Weapon
class EnemyType2 : Health, Weapon
class EnemyType3 : Health, Weapon
VPS购买请点击我

免责声明：我们致力于保护作者版权，注重分享，被刊用文章因无法核实真实出处，未能及时与作者取得联系，或有版权异议的，请联系管理员，我们会立即处理! 部分文章是来自自研大数据AI进行生成,内容摘自(百度百科,百度知道,头条百科,中国民法典,刑法,牛津词典,新华词典,汉语词典,国家院校,科普平台)等数据,内容仅供学习参考,不准确地方联系删除处理! 图片声明：本站部分配图来自人工智能系统AI生成,觅知网授权图片,PxHere摄影无版权图库和百度，360，搜狗等多加搜索引擎自动关键词搜索配图，如有侵权的图片，请第一时间联系我们，邮箱：ciyunidc@ciyunshuju.com。本站只作为美观性配图使用,无任何非法侵犯第三方意图,一切解释权归图片著作权方,本站不承担任何责任。如有恶意碰瓷者,必当奉陪到底严惩不贷!

相关阅读

目录[+]