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

文章目录

Kotlin基础知识全面解析
- 第一章：Kotlin语言概述
- - [1.1 Kotlin的发展历程](#1.1 Kotlin的发展历程)
  - [1.2 Kotlin的设计目标](#1.2 Kotlin的设计目标)
  - [1.3 Kotlin的应用领域](#1.3 Kotlin的应用领域)
  - [1.4 Kotlin与Java的比较](#1.4 Kotlin与Java的比较)
- 第二章：Kotlin基础语法
- - [2.1 变量与常量](#2.1 变量与常量)
  - [2.2 基本数据类型](#2.2 基本数据类型)
  - - 数字类型示例：
    - 字符和字符串示例：
  - [2.3 运算符](#2.3 运算符)
  - [2.4 控制流](#2.4 控制流)
  - [2.5 异常处理](#2.5 异常处理)
- 第三章：函数与Lambda表达式
- - [3.1 函数定义](#3.1 函数定义)
  - [3.2 函数参数](#3.2 函数参数)
  - [3.3 扩展函数](#3.3 扩展函数)
  - [3.4 高阶函数与Lambda](#3.4 高阶函数与Lambda)
  - [3.5 内联函数](#3.5 内联函数)
- 第四章：类与对象
- - [4.1 类定义](#4.1 类定义)
  - [4.2 构造函数](#4.2 构造函数)
  - [4.3 继承](#4.3 继承)
  - [4.4 抽象类与接口](#4.4 抽象类与接口)
  - [4.5 数据类](#4.5 数据类)
  - [4.6 单例与伴生对象](#4.6 单例与伴生对象)
- 第五章：空安全与类型系统
- - [5.1 可空类型](#5.1 可空类型)
  - [5.2 安全调用操作符](#5.2 安全调用操作符)
  - [5.3 Elvis操作符](#5.3 Elvis操作符)
  - [5.4 非空断言](#5.4 非空断言)
  - [5.5 安全类型转换](#5.5 安全类型转换)

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的设计团队为这门语言设定了几个核心目标：

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

1.3 Kotlin的应用领域

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

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

1.4 Kotlin与Java的比较

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

第二章：Kotlin基础语法

2.1 变量与常量

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

kotlin 复制代码

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

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

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

kotlin 复制代码

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

2.2 基本数据类型

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

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

数字类型示例：

kotlin 复制代码

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

字符和字符串示例：

kotlin 复制代码

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

kotlin 复制代码

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是一个表达式，可以返回值：

kotlin 复制代码

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更强大：

kotlin 复制代码

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也可以不带参数使用：

kotlin 复制代码

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

循环结构

Kotlin提供了多种循环结构：

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类似，但有一些改进：

kotlin 复制代码

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

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

第三章：函数与Lambda表达式

3.1 函数定义

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

kotlin 复制代码

// 基本函数定义
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函数参数支持默认值和命名参数：

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 扩展函数

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

kotlin 复制代码

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

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

kotlin 复制代码

// 高阶函数示例
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关键字可以减少高阶函数的运行时开销：

kotlin 复制代码

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关键字定义类：

kotlin 复制代码

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类可以有一个主构造函数和多个次构造函数：

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关键字：

kotlin 复制代码

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 抽象类与接口

kotlin 复制代码

// 抽象类
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()等方法：

kotlin 复制代码

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 单例与伴生对象

kotlin 复制代码

// 单例
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通过类型系统区分可空和非空引用：

kotlin 复制代码

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

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

5.2 安全调用操作符

kotlin 复制代码

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

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

5.3 Elvis操作符

kotlin 复制代码

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

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

5.4 非空断言

kotlin 复制代码

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

5.5 安全类型转换

kotlin 复制代码

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