kotlin基础语法

本文最后更新于234 天前，其中的信息可能已经过时，如有错误请发送邮件到xieyuchen3@gmail.com

什么是 Kotlin

Kotlin 是由 JetBrains 开发的现代编程语言，运行在 Java 虚拟机（JVM）上。它被 Google 官方推荐为 Android 开发的首选语言。

主要特点：

现代：支持函数式编程、协程等

简洁：代码量比 Java 少很多

安全：空安全机制避免空指针异常

互操作：与 Java 100% 互操作

基础语法

fun main() {
    println("Hello, Kotlin!")
}
变量声明

Kotlin 有两种变量：

val：不可变变量（类似 Java 的 final）

var：可变变量

fun main() {
    val name = "Kotlin"  // 类型自动推断为 String
    var age = 10         // 可变变量
    
    // 显式声明类型
    val price: Double = 99.99
    var count: Int = 0
    
    // name = "Java"  // 错误！val 不能重新赋值
    age = 11          // 正确！var 可以重新赋值
}

字符串模板

fun main() {
    val name = "小明"
    val age = 20
    
    println("我的名字是 $name")           // 我的名字是 小明
    println("我今年 ${age} 岁")          // 我今年 20 岁
    println("明年我 ${age + 1} 岁")      // 明年我 21 岁
}

数据类型

基本数据类型

Kotlin 的基本类型：

数组：Array

数字：Byte, Short, Int, Long, Float, Double

字符：Char

布尔：Boolean

字符串：String

fun main() {
    // 整数类型
    val byte: Byte = 127
    val short: Short = 32767
    val int: Int = 2147483647
    val long: Long = 9223372036854775807L
    
    // 浮点类型
    val float: Float = 3.14F
    val double: Double = 3.141592653589793
    
    // 字符和字符串
    val char: Char = 'A'
    val string: String = "Hello"
    
    // 布尔
    val isTrue: Boolean = true
    val isFalse: Boolean = false
}

类型转换

fun main() {
    val intValue = 100
    val longValue = intValue.toLong()  // Int 转 Long
    val doubleValue = intValue.toDouble()  // Int 转 Double
    val stringValue = intValue.toString()  // Int 转 String
    
    val stringNumber = "123"
    val intFromString = stringNumber.toInt()  // String 转 Int
}

控制流

if 表达式

在 Kotlin 中，if 是表达式，可以返回值：

fun main() {
    val a = 10
    val b = 20
    
    // 传统用法
    if (a > b) {
        println("a 更大")
    } else {
        println("b 更大")
    }
    
    // 作为表达式
    val max = if (a > b) a else b
    println("最大值是 $max")
    
    // 多行表达式
    val result = if (a > b) {
        println("a 更大")
        a
    } else {
        println("b 更大")
        b
    }
}

when 表达式

when 是 Kotlin 的增强版 switch：

fun main() {
    val score = 85
    
    // 基本用法
    when (score) {
        100 -> println("满分！")
        90, 91, 92, 93, 94, 95, 96, 97, 98, 99 -> println("优秀")
        in 80..89 -> println("良好")  // 范围判断
        in 60..79 -> println("及格")
        else -> println("不及格")
    }
    
    // 作为表达式
    val grade = when {
        score >= 90 -> "A"
        score >= 80 -> "B"
        score >= 60 -> "C"
        else -> "D"
    }
    println("等级：$grade")
}

循环

fun main() {
    // for 循环
    for (i in 1..5) {  // 1 到 5（包含）
        println(i)
    }
    
    for (i in 1 until 5) {  // 1 到 4（不包含 5）
        println(i)
    }
    
    for (i in 5 downTo 1) {  // 5 到 1（倒序）
        println(i)
    }
    
    for (i in 1..10 step 2) {  // 1, 3, 5, 7, 9
        println(i)
    }
    
    // 遍历数组/列表
    val fruits = listOf("苹果", "香蕉", "橙子")
    for (fruit in fruits) {
        println(fruit)
    }
    
    // 带索引遍历
    for ((index, fruit) in fruits.withIndex()) {
        println("$index: $fruit")
    }
    
    // while 循环
    var i = 0
    while (i < 5) {
        println(i)
        i++
    }
    
    // do-while 循环
    var j = 0
    do {
        println(j)
        j++
    } while (j < 5)
}

函数

函数定义

// 基本函数
fun greet(name: String) {
    println("你好，$name！")
}

// 带返回值的函数
fun add(a: Int, b: Int): Int {
    return a + b
}

// 单表达式函数（可以省略大括号和 return）
fun multiply(a: Int, b: Int): Int = a * b

// 类型推断（可以省略返回类型）
fun subtract(a: Int, b: Int) = a - b

// 默认参数
fun greetWithDefault(name: String = "朋友") {
    println("你好，$name！")
}

// 命名参数
fun createUser(name: String, age: Int, email: String = "") {
    println("用户：$name, 年龄：$age, 邮箱：$email")
}

fun main() {
    greet("小明")
    println(add(3, 5))
    
    greetWithDefault()  // 使用默认参数
    greetWithDefault("小红")
    
    createUser("张三", 25, "zhang@example.com")
    createUser(name = "李四", age = 30)  // 命名参数，跳过 email
}

可变函数

fun sum(vararg numbers: Int): Int {
    var total = 0
    for (num in numbers) {
        total += num
    }
    return total
}

fun main() {
    println(sum(1, 2, 3))           // 6
    println(sum(1, 2, 3, 4, 5))     // 15
}

高阶函数

函数可以作为参数或返回值：

// 函数作为参数
fun calculate(a: Int, b: Int, operation: (Int, Int) -> Int): Int {
    return operation(a, b)
}

fun main() {
    val add = { x: Int, y: Int -> x + y }
    val multiply = { x: Int, y: Int -> x * y }
    
    println(calculate(5, 3, add))        // 8
    println(calculate(5, 3, multiply))  // 15
    
    // 使用 Lambda 表达式
    println(calculate(10, 5) { x, y -> x - y })  // 5
}

类和对象

类定义

// 基本类
class Person {
    var name: String = ""
    var age: Int = 0
    
    fun introduce() {
        println("我是 $name，今年 $age 岁")
    }
}

// 主构造函数
class Student(val name: String, var age: Int) {
    fun introduce() {
        println("我是学生 $name，今年 $age 岁")
    }
}

// 带初始化块
class Teacher(name: String, age: Int) {
    val name: String
    val age: Int
    
    init {
        this.name = name
        this.age = age
        println("创建了一个教师：$name")
    }
    
    fun teach() {
        println("$name 正在授课")
    }
}

fun main() {
    val person = Person()
    person.name = "张三"
    person.age = 25
    person.introduce()
    
    val student = Student("李四", 20)
    student.introduce()
    
    val teacher = Teacher("王老师", 35)
    teacher.teach()
}

数据类

数据类自动生成 equals(), hashCode(), toString() 等方法：

data class User(val name: String, val age: Int)

fun main() {
    val user1 = User("小明", 20)
    val user2 = User("小明", 20)
    val user3 = User("小红", 22)
    
    println(user1)  // User(name=小明, age=20)
    println(user1 == user2)  // true（内容相同）
    println(user1 == user3)  // false（内容不同）
    
    // 解构声明
    val (name, age) = user1
    println("$name, $age")
}

继承

// 基类（默认是 final，需要 open 才能被继承）
open class Animal(val name: String) {
    open fun makeSound() {
        println("$name 发出声音")
    }
}

// 继承
class Dog(name: String) : Animal(name) {
    override fun makeSound() {
        println("$name 汪汪叫")
    }
}

class Cat(name: String) : Animal(name) {
    override fun makeSound() {
        println("$name 喵喵叫")
    }
}

fun main() {
    val dog = Dog("旺财")
    val cat = Cat("咪咪")
    
    dog.makeSound()  // 旺财 汪汪叫
    cat.makeSound()  // 咪咪 喵喵叫
}

集合

List列表

fun main() {
    // 不可变列表
    val fruits = listOf("苹果", "香蕉", "橙子")
    println(fruits[0])  // 苹果
    
    // 可变列表
    val mutableFruits = mutableListOf("苹果", "香蕉")
    mutableFruits.add("橙子")
    mutableFruits.remove("苹果")
    println(mutableFruits)  // [香蕉, 橙子]
    
    // 列表操作
    val numbers = listOf(1, 2, 3, 4, 5)
    println(numbers.size)           // 5
    println(numbers.contains(3))    // true
    println(numbers.first())        // 1
    println(numbers.last())         // 5
    println(numbers.filter { it > 3 })  // [4, 5]
    println(numbers.map { it * 2 })     // [2, 4, 6, 8, 10]
}

Set（集合）

fun main() {
    // 不可变集合（自动去重）
    val numbers = setOf(1, 2, 3, 2, 1)
    println(numbers)  // [1, 2, 3]
    
    // 可变集合
    val mutableSet = mutableSetOf(1, 2, 3)
    mutableSet.add(4)
    mutableSet.add(2)  // 重复，不会添加
    println(mutableSet)  // [1, 2, 3, 4]
}

Map（映射）

fun main() {
    // 不可变映射
    val scores = mapOf(
        "小明" to 95,
        "小红" to 88,
        "小刚" to 92
    )
    
    println(scores["小明"])  // 95
    println(scores.getOrDefault("小李", 0))  // 0（不存在时返回默认值）
    
    // 可变映射
    val mutableScores = mutableMapOf<String, Int>()
    mutableScores["小明"] = 95
    mutableScores["小红"] = 88
    mutableScores["小明"] = 100  // 更新值
    
    // 遍历
    for ((name, score) in mutableScores) {
        println("$name: $score")
    }
}

空安全

Kotlin 最重要的特性之一，避免空指针异常：

fun main() {
    // 非空类型（默认）
    var name: String = "Kotlin"
    // name = null  // 编译错误！
    
    // 可空类型（使用 ?）
    var nullableName: String? = "Kotlin"
    nullableName = null  // 可以
    
    // 安全调用操作符 ?.
    val length1 = nullableName?.length  // 如果 nullableName 为 null，返回 null
    println(length1)  // null
    
    nullableName = "Kotlin"
    val length2 = nullableName?.length
    println(length2)  // 6
    
    // Elvis 操作符 ?:（提供默认值）
    val length3 = nullableName?.length ?: 0
    println(length3)  // 6
    
    nullableName = null
    val length4 = nullableName?.length ?: 0
    println(length4)  // 0
    
    // 非空断言 !!（不推荐，可能抛出异常）
    // val length5 = nullableName!!.length  // 如果为 null 会抛出异常
    
    // 安全转换 as?
    val str: String? = "123"
    val num: Int? = str as? Int  // 转换失败返回 null，不会抛异常
    println(num)  // null
}

扩展函数

可以为现有类添加新函数，而不需要修改类本身：

// 为 String 添加扩展函数
fun String.removeSpaces(): String {
    return this.replace(" ", "")
}

// 为 Int 添加扩展函数
fun Int.isEven(): Boolean {
    return this % 2 == 0
}

fun main() {
    val text = "Hello World"
    println(text.removeSpaces())  // HelloWorld
    
    val number = 10
    println(number.isEven())  // true
    println(7.isEven())        // false
}

看完这些就可以开始练习题了🎉

when 表达式

高阶函数

数据类

发送评论 编辑评论

发送评论编辑评论