一、kotlin的主函数

IDEA文件展开

alt text

1. Kotlin的执行流程

1
> Kotlin的源代码先通过jdk解释成Java字节码，然后再由JVM执行转换成机器码由计算机执行。
1
2
3
fun main(args: Array<String>) {
    println("Hello, World!")
}

2. 变量+基础数据类型+空值

1
> 在Kotlin中，变量可以使用`val`或`var`关键字来声明。`val`声明的变量是不可变的，而`var`声明的变量是可变的。
1
2
3
val a: Int = 10 // 不可变变量
var b: Int = 20 // 可变变量

1
2
3
4
5
6
7
8
> Byte：8位有符号整数，范围为-128到127.   Byte.MAX_VALUE为127, Byte.MIN_VALUE为-128
> Short：16位有符号整数，范围为-32768到32767.   Short.MAX_VALUE为32767, Short.MIN_VALUE为-32768
> Int：32位有符号整数，范围为-2147483648到2147483647.   Int.MAX_VALUE为2147483647, Int.MIN_VALUE为-2147483648
> Long：64位有符号整数，范围为-9223372036854775808到9223372036854775807.   Long.MAX_VALUE9223372036854775807, Long.MIN_VALUE为-9223372036854775808
> Float：32位单精度浮点数.   Float.MAX_VALUE为3.4028235e38, Float.MIN_VALUE为1.4e-45
> Double：64位双精度浮点数.   Double.MAX_VALUE为1.7976931348623157e308, Double.MIN_VALUE为4.9e-324
> Char：16位无符号整数，用于表示Unicode字符.   Char.MAX_VALUE为'\uFFFF', Char.MIN_VALUE为'\u0000'
> Boolean：表示true或false
1
2
> 空值类型：Kotlin中的空值类型是`null`，它表示一个不存在的值。
> var text: String? = null
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
fun main(args: Array<String>) {
    val text: String? = null
    if (text != null) {
        println(text.length)
    } else {
        println("text is null")
    }
}
<=>
fun main(args: Array<String>) {
    val text: String? = null
    println(text?.length)

}

val text2: String? = text ?: "default"
如果text不为null，那么text2就等于text，否则就等于"default"

3. 函数+返回值+参数指定默认值

1
> 在Kotlin中，函数可以使用`fun`关键字来声明。函数可以有参数也可以没有参数，也可以有返回值也可以没有返回值。
1
2
3
fun sum(a: Int, b: Int = 0): Int {
    return a + b
}

1. vararg参数

1
> 在Kotlin中，函数可以使用`vararg`关键字来声明可变数量的参数。
1
2
3
4
5
6
7
8
9
10
fun main(args: Array<String>) {
    println(sum(1, 2, 3, 4, 5, 6 , 7 , 8 , 9 , 10 , 556 , 48 ))
}
fun sum(vararg nums: Int): Int {
    var result = 0
    for (num in nums) {
        result += num
    }
    return result
}

4. 循环

1
> 在Kotlin中，循环可以使用`for`或`while`关键字来声明。
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
fun main(args: Array<String>) {
    for (i in 0 until 10) {
        println(i)
    }
    for (i in 0..9) {
        println(i)
    }
    for (i in 0 until 10 step 2) {
        println(i)
    }
    for (i in 9 downTo 0) {
        println(i)
    }
    while (i < 10) {
        println(i)
        i++
    }
}

1
2
3
4
5
> 在Kotlin中，结束循环可以使用`break`或`continue`关键字。
> - `break`关键字用于立即结束循环。
> - `continue`关键字用于跳过当前迭代，继续下一次迭代。
> - 'break@outer'用于跳出外部循环。
> - 'outer@'是循环标签，用于标识外部循环。

5. 数组+is关键字

· 数组可以使用arrayOf函数来创建。
· 数组可以使用is关键字来判断是否是某种类型的数组。
· Ctrl+;添加类型显示。

1
2
3
4
5
6
fun main(args: Array<String>) {
    val arr = arrayOf(1, 2, 3, 4, 5)
    if (arr is Array<Int>) {
        println("arr is Array<Int>")
    }
}

6. 类+构造函数+初始化块

1
> 在Kotlin中，类可以使用`class`关键字来声明。类可以有属性也可以没有属性，也可以有方法也可以没有方法。
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
fun main(args: Array<String>) {
    val person = Person()
    val student = Student("张三", 18).sayHello()
    person.name = "张三"
    person.age = 18
    person.sayHello()
}
class Person{
    var name: String = ""
    var age: Int = 0
    
    fun sayHello() {
        println("Hello, my name is $name, I am $age years old.")
    }
}
// 构造函数
class Student(name: String, var age: Int = 0){
    var name: String = name.trim()   // 去掉字符串首尾的空格
    fun sayHello() {
        println("Hello, my name is $name, I am $age years old. I am a student.")
    }
}

// 初始化块,初始化块用 init 关键字声明，属于类的一部分，每创建一个类的实例，所有初始化块都会执行。
// Kotlin 次构造函数必须先调用主构造函数，因此 init 块一定会在所有次构造函数逻辑前执行；
class Student(name: String, var age: Int = 0){
    var name: String = name.trim()   // 去掉字符串首尾的空格
    init {
        // lowercase().startsWith("a")先把字符串转为小写，再判断是否以指定前缀开头，适用于「不区分大小写的前缀匹配」场景
        if(name.lowercase().startsWith("a")){
            this.name = name
        }else{
            this.name = "User"
            println("Name is not start with A, add User prefix.")
        }
    }
    fun sayHello() {
        println("Hello, my name is $name, I am $age years old. I am a student.")
    }
}

//辅助构造函数
//辅助构造函数用 constructor 关键字声明（无 fun），核心规则：
//一个类可以有多个辅助构造函数（重载）；
//所有辅助构造函数必须直接 / 间接调用主构造函数（通过 this()）；
//辅助构造函数的逻辑执行在 init 块之后。
class Student(name: String, var age: Int = 0){
    var name: String = name.trim()   // 去掉字符串首尾的空格
    init {
        // lowercase().startsWith("a")先把字符串转为小写，再判断是否以指定前缀开头，适用于「不区分大小写的前缀匹配」场景
        if(name.lowercase().startsWith("a")){
            this.name = name
        }else{
            this.name = "User"
            println("Name is not start with A, add User prefix.")
        }
    }
    constructor(name: String) : this(name, 0) {
        // 辅助构造函数中可以调用其他构造函数，这里调用主构造函数 this(name, 0)
    }
    fun sayHello() {
        println("Hello, my name is $name, I am $age years old. I am a student.")
    }
}

//getter和setter
//Kotlin 中，类的属性可以使用 var 或 val 关键字来声明。
//var 关键字声明的属性可以读写，val 关键字声明的属性只能读。
//Kotlin 中，属性的读写逻辑可以自定义，这就需要使用到 get 和 set 方法。
//get 方法用于读取属性值，set 方法用于写入属性值。
//get 方法默认返回属性值，set 方法默认接收一个参数，参数为属性值。
//可以在属性声明中自定义 get 和 set 方法，这就需要使用到 get 和 set 关键字。
//getter和setter方法都是隐式的，不需要手动实现。
class Student(name: String, var age: Int = 0){
    var name: String = name.trim()   // 去掉字符串首尾的空格
        get() {
            return field
        }
        set(value) {
            field = value
        }

    //例如，student.name 会调用 name 属性的 getter 方法，student.name = "张三" 会调用 name 属性的 setter 方法。
    //Kotlin 中声明属性（val/var）时，编译器会自动为属性生成：访问器：get()（所有属性）和 set()（仅 var）；字段标识符field是 Kotlin 里专门用于访问属性「底层存储字段」的关键字
}


图片引用方法三