Kotlin学习基础知识大全(上)

Kotlin基础知识全面解析

第一章：Kotlin语言概述

1.1 Kotlin的发展历程

Kotlin是由JetBrains公司开发的一种静态类型编程语言，最初发布于2011年。JetBrains是知名IDE工具IntelliJ IDEA的开发商，他们开发Kotlin的目的是为了解决Java语言在开发效率、代码简洁性和安全性方面的一些不足。

2016年2月，Kotlin 1.0正式发布，标志着语言进入稳定阶段。2017年5月，在Google I/O大会上，Google宣布Kotlin成为Android开发的官方支持语言，这一决定极大地推动了Kotlin的普及。

1.2 Kotlin的设计目标

Kotlin的设计团队为这门语言设定了几个核心目标：

1. 简洁性：通过减少样板代码提高开发效率
2. 安全性：在语言层面避免常见的编程错误，如空指针异常
3. 互操作性：与Java完全互操作，可以无缝使用现有Java生态
4. 工具友好：提供优秀的IDE支持，特别是IntelliJ IDEA

1.3 Kotlin的应用领域

Kotlin主要应用于以下几个领域：

1. Android开发：作为Java的替代语言，Kotlin已成为Android开发的首选
2. 服务器端开发：可以与Spring等框架配合使用
3. 跨平台开发：通过Kotlin Multiplatform可以开发跨平台应用
4. 前端开发：可以编译为JavaScript
5. 数据科学：Kotlin也正在成为数据科学领域的一个选择

1.4 Kotlin与Java的比较

特性	Java	Kotlin
空安全	无	有
扩展函数	无	有
数据类	需要手动实现	原生支持
函数式编程	Java 8+支持有限	全面支持
协程	无	有
字符串模板	有限支持	强大支持
默认参数	无	有
类型推断	有限	全面

第二章：Kotlin基础语法

2.1 变量与常量

在Kotlin中，变量声明使用var关键字，常量声明使用val关键字。

// 变量声明
var count: Int = 10
count = 20  // 可以重新赋值

// 常量声明
val language: String = "Kotlin"
// language = "Java"  // 编译错误，val不可重新赋值

Kotlin支持类型推断，可以省略类型声明：

var count = 10      // 自动推断为Int类型
val name = "Kotlin" // 自动推断为String类型

2.2 基本数据类型

Kotlin中的所有数据类型都是对象，没有Java中的原始类型概念。Kotlin的基本数据类型包括：

• 数字类型：Byte, Short, Int, Long, Float, Double
• 字符类型：Char
• 布尔类型：Boolean
• 字符串类型：String

数字类型示例：

val one: Int = 1
val threeBillion: Long = 3000000000
val oneLong = 1L  // Long类型
val oneByte: Byte = 1

val pi = 3.14  // Double
val eFloat = 2.7182818284f  // Float，实际值为2.7182817

字符和字符串示例：

val letter: Char = 'A'
val text: String = "Hello, Kotlin!"

// 字符串模板
val name = "Alice"
val greeting = "Hello, $name!"  // "Hello, Alice!"
val lengthInfo = "Name has ${name.length} characters"  // "Name has 5 characters"

// 多行字符串
val multiLineText = """
    This is a multi-line string.
    It preserves all indentation and line breaks.
    You can include "quotes" without escaping.
""".trimIndent()

2.3 运算符

Kotlin支持大多数标准运算符：

• 算术运算符：+, -, *, /, %
• 比较运算符：==, !=, <, >, <=, >=
• 逻辑运算符：&&, ||, !
• 位运算符：and, or, xor, inv, shl, shr, ushr

val a = 10
val b = 20

println(a + b)  // 30
println(a < b)  // true
println(a == 10 && b == 20)  // true
println((a and 0x0F) shl 2)  // 40

2.4 控制流

if表达式

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

val max = if (a > b) a else b

// 也可以是多行
val max = if (a > b) {
    println("Choose a")
    a
} else {
    println("Choose b")
    b
}

when表达式

when表达式比Java中的switch更强大：

when (x) {
    1 -> print("x == 1")
    2 -> print("x == 2")
    3, 4 -> print("x == 3 or 4")
    in 5..10 -> print("x is in the range 5 to 10")
    !in 11..20 -> print("x is outside the range 11 to 20")
    else -> print("x is neither 1 nor 2")
}

when也可以不带参数使用：

when {
    x.isOdd() -> print("x is odd")
    x.isEven() -> print("x is even")
    else -> print("x is funny")
}

循环结构

Kotlin提供了多种循环结构：

// for循环
for (i in 1..5) {
    print(i)  // 输出: 12345
}

for (i in 1 until 5) {
    print(i)  // 输出: 1234
}

for (i in 5 downTo 1) {
    print(i)  // 输出: 54321
}

for (i in 1..10 step 2) {
    print(i)  // 输出: 13579
}

// while循环
var x = 5
while (x > 0) {
    print(x--)  // 输出: 54321
}

// do-while循环
var y = 0
do {
    print(y++)  // 输出: 01234
} while (y < 5)

2.5 异常处理

Kotlin的异常处理与Java类似，但有一些改进：

try {
    // 可能抛出异常的代码
    val result = 10 / 0
} catch (e: ArithmeticException) {
    println("除零错误: ${e.message}")
} finally {
    println("无论是否异常都会执行")
}

Kotlin不强制要求捕获所有异常，只有运行时异常（RuntimeException）和错误（Error）。

第三章：函数与Lambda表达式

3.1 函数定义

Kotlin中使用fun关键字定义函数：

// 基本函数定义
fun add(a: Int, b: Int): Int {
    return a + b
}

// 表达式函数体
fun add(a: Int, b: Int) = a + b

// 无返回值函数
fun printSum(a: Int, b: Int): Unit {
    println("sum of $a and $b is ${a + b}")
}
// Unit返回类型可以省略
fun printSum(a: Int, b: Int) {
    println("sum of $a and $b is ${a + b}")
}

3.2 函数参数

Kotlin函数参数支持默认值和命名参数：

fun greet(name: String = "World", prefix: String = "Hello") {
    println("$prefix, $name!")
}

// 使用示例
greet()                          // Hello, World!
greet("Kotlin")                  // Hello, Kotlin!
greet(prefix = "Hi", name = "Android") // Hi, Android!

3.3 扩展函数

扩展函数允许在不修改类定义的情况下为类添加新函数：

fun String.addExclamation(): String {
    return "$this!"
}

println("Hello".addExclamation()) // 输出: Hello!

// 扩展属性
val String.lastChar: Char
    get() = this[length - 1]

println("Kotlin".lastChar) // 输出: n

3.4 高阶函数与Lambda

高阶函数是指以函数作为参数或返回值的函数：

// 高阶函数示例
fun calculate(a: Int, b: Int, operation: (Int, Int) -> Int): Int {
    return operation(a, b)
}

// 使用Lambda表达式
val sum = calculate(10, 5) { x, y -> x + y }  // 15
val product = calculate(10, 5) { x, y -> x * y }  // 50

// Lambda表达式语法
val sum: (Int, Int) -> Int = { x, y -> x + y }
println(sum(1, 2))  // 3

3.5 内联函数

使用inline关键字可以减少高阶函数的运行时开销：

inline fun measureTime(block: () -> Unit): Long {
    val start = System.currentTimeMillis()
    block()
    return System.currentTimeMillis() - start
}

val time = measureTime {
    // 执行一些耗时操作
    Thread.sleep(1000)
}
println("Execution took $time ms")

第四章：类与对象

4.1 类定义

Kotlin中使用class关键字定义类：

class Person {
    // 属性
    var name: String = ""
    var age: Int = 0
    
    // 方法
    fun speak() {
        println("$name is $age years old")
    }
}

// 使用
val person = Person()
person.name = "Alice"
person.age = 25
person.speak()  // 输出: Alice is 25 years old

4.2 构造函数

Kotlin类可以有一个主构造函数和多个次构造函数：

// 主构造函数
class Person constructor(firstName: String) {
    val name: String
    
    init {
        // 初始化块
        name = firstName.capitalize()
    }
}

// 简化写法
class Person(val name: String, var age: Int) {
    init {
        println("Person created with name=$name and age=$age")
    }
    
    // 次构造函数
    constructor(name: String) : this(name, 0) {
        println("Secondary constructor called")
    }
}

// 使用
val person1 = Person("Alice", 25)
val person2 = Person("Bob")

4.3 继承

Kotlin中所有类默认都是final的，要允许继承需要使用open关键字：

open class Animal(val name: String) {
    open fun makeSound() {
        println("$name makes a sound")
    }
}

class Dog(name: String) : Animal(name) {
    override fun makeSound() {
        println("$name barks")
    }
}

val dog = Dog("Rex")
dog.makeSound()  // 输出: Rex barks

4.4 抽象类与接口

// 抽象类
abstract class Shape {
    abstract fun area(): Double
}

class Circle(val radius: Double) : Shape() {
    override fun area() = Math.PI * radius * radius
}

// 接口
interface Drawable {
    fun draw()
}

class Rectangle : Drawable {
    override fun draw() {
        println("Drawing a rectangle")
    }
}

4.5 数据类

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

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

val user1 = User("Alice", 25)
val user2 = user1.copy(age = 26)

println(user1)  // 输出: User(name=Alice, age=25)
println(user1 == user2)  // false

4.6 单例与伴生对象

// 单例
object Singleton {
    fun doSomething() {
        println("Doing something...")
    }
}

Singleton.doSomething()

// 伴生对象
class MyClass {
    companion object {
        const val CONSTANT = "constant"
        
        fun create(): MyClass = MyClass()
    }
}

val instance = MyClass.create()
println(MyClass.CONSTANT)

第五章：空安全与类型系统

5.1 可空类型

Kotlin通过类型系统区分可空和非空引用：

var a: String = "abc"  // 非空类型
// a = null  // 编译错误

var b: String? = "abc"  // 可空类型
b = null  // 允许

5.2 安全调用操作符

val length = b?.length  // 如果b为null，返回null

// 链式调用
val streetLength = person?.address?.street?.length

5.3 Elvis操作符

val length = b?.length ?: 0  // 如果b为null，返回0

// 也可以抛出异常
val length = b?.length ?: throw IllegalArgumentException("b is null")

5.4 非空断言

val length = b!!.length  // 如果b为null，抛出NullPointerException

5.5 安全类型转换

val aInt: Int? = a as? Int  // 如果转换失败，返回null而不是抛出异常