Kotlin 语言速成：用 ManyCourse 真实代码学语法

1
val name = "李同学"       // val：只读，赋值后不能再改（类似"常量"）
2
var activeIndex = 0       // var：可变，能重新赋值

1
private lateinit var tabFragments: List<Fragment>
2
private var activeIndex = 0

1
val n: Int = 14            // 整数
2
val name: String = "课多多"  // 字符串
3
val ok: Boolean = true     // 布尔

1
"第${startPeriod}节"                       // → "第1节"
2
"这所学校（$schoolId）不在学校清单里了"       // → 直接拼变量

1
val periodLabel: String
2
    get() = if (periodCount <= 1) "第${startPeriod}节"
3
            else "第${startPeriod}-${startPeriod + periodCount - 1}节"

1
val a: String = "一定有值"   // 非空类型
2
val b: String? = null        // 可空类型：结尾带 `?`

1
val s: String? = maybeNull()
2

3
// ① 安全调用 ?. —— 为空就整体返回 null，不抛异常
4
s?.length          // s 为空 → null；不为空 → 字符串长度
5

6
// ② Elvis 操作符 ?: —— 为空时给个默认值（"否则"的意思）
7
s?.length ?: 0     // 为空 → 0
8

9
// ③ !! —— 我保证它不为空（空了你崩）；尽量别用
10
s!!.length
11

12
// ④ ?.let { } —— 不为空才执行一段代码
13
s?.let { println("内容：$it") }

1
val name = profile.getOrNull()?.name.orEmpty()
2
//                       ↑ 安全调用    ↑ 为空给 ""

1
schoolId = SessionStore.schoolId.value ?: LoginSettings.selectedSchoolId.value
2
//            ↑ 前者为空时，取后者（Elvis 兜底）

1
fun add(a: Int, b: Int): Int {   // 返回类型 : Int
2
    return a + b
3
}
4

5
// 单表达式函数：函数体只有一个表达式，可以简写（项目里极常见）
6
fun double(x: Int) = x * 2

1
fun sync(schoolId: String?, account: String, force: Boolean = false) { ... }
2
// 调用：sync(id, account)            → force 用默认 false
3
//       sync(id, account, force = true)

1
Course(name="高数", teacher="王建国", weekday=1, startPeriod=1, periodCount=2)

1
class Person(val name: String, var age: Int) {
2
    // name 是只读属性，age 是可变属性，都能直接 对象.name 访问
3
    fun greet() = "我是 $name"
4
}

1
data class School(
2
    val id: String,
3
    val name: String,
4
    val baseUrl: String,
5
    val system: String = "",
6
    val timetable: Timetable = Timetables.default,
7
) {
8
    val host: String          // ← 计算属性，每次取都算一次
9
        get() = baseUrl.substringAfter("://").trimEnd('/')
10
}

1
data class StudentProfile(
2
    val name: String,
3
    val account: String = "",
4
    val className: String = "",
5
    val major: String = "",
6
    val college: String = "",
7
)

1
// object：单例。整个程序只有一个实例，用「对象名.成员」访问
2
object CourseRepository {
3
    val courses = mutableStateListOf<Course>()
4
    fun clear() = courses.clear()
5
}
6
// 用法：CourseRepository.clear()

1
// companion object：挂在类上的静态成员（类似 Java 的 static）
2
class Course {
3
    companion object {
4
        const val MAX_PERIOD = 14
5
    }
6
}
7
// 用法：Course.MAX_PERIOD

1
// if 是表达式，有返回值（类似 Java 的三元运算符 ?:）
2
val label = if (periodCount <= 1) "第${startPeriod}节"
3
            else "第${startPeriod}-${startPeriod + periodCount - 1}节"
4

5
// when：加强版 switch，不写判断对象就是 if-else 链
6
when {
7
    response.isRedirect -> LoginResult.Success("登录成功")
8
    response.body.contains("密码错误") -> LoginResult.Failure("密码错误")
9
    else -> LoginResult.Failure("登录失败")
10
}

1
fun coursesOn(weekday: Int): List<Course> =
2
    courses.filter { it.weekday == weekday }.sortedBy { it.startPeriod }

1
fun readableMessage(e: Throwable): String = when {
2
    e is SessionExpiredException -> "登录已过期，请重新登录"
3
    e is UnknownHostException -> "网络不通，请检查网络连接"
4
    e is SocketTimeoutException -> "连接超时，请重试"
5
    else -> e.message ?: "未知错误"
6
}

1
sealed interface LoginResult {
2
    data class Success(val message: String) : LoginResult
3
    data class Failure(val message: String) : LoginResult
4
    data class Pending(val message: String) : LoginResult
5
    data class NeedCaptcha(val message: String, val captcha: LoginCaptcha) : LoginResult
6
}

1
when (val result = loginResult) {
2
    is LoginResult.Success -> enterMain()
3
    is LoginResult.Failure -> showError(result.message)
4
    is LoginResult.Pending -> showPending(result.message)
5
    is LoginResult.NeedCaptcha -> showCaptcha(result.captcha)
6
}
7
// 如果漏掉任何一种，IDE 会标红："'when' expression must be exhaustive"

1
// 完整 lambda
2
{ x: Int, y: Int -> x + y }
3

4
// 如果最后一个参数是 lambda，可以移到括号外（尾随 lambda）
5
api.login(account, password) { result ->
6
    // 处理登录结果
7
}
8

9
// 单参数 lambda 默认叫 it
10
list.filter { it > 2 }    // it 就是每个元素

1
api.fetchProfile(account) { profile ->          // 第一层回调：拉姓名
2
    main {                                       // 切回主线程
3
        api.fetchSchedule(account) { schedule -> // 第二层回调：拉课表
4
            main {                               // 再切回主线程
5
                schedule.fold(
6
                    onSuccess = { list -> CourseRepository.replaceAll(list) },
7
                    onFailure = { error -> state.value = State.Failed(...) },
8
                )
9
            }
10
        }
11
    }
12
}

1
fun fetchSchedule(account: String, callback: (Result<List<SchoolCourse>>) -> Unit)
2

3
// 成功时
4
callback(Result.success(listOf(course1, course2)))
5

6
// 失败时
7
callback(Result.failure(IOException("网络不通")))

1
result.fold(
2
    onSuccess = { courses -> /* 用数据 */ },
3
    onFailure = { error -> /* 显示错误 */ },
4
)

1
// 为什么需要它？
2
// OkHttp 的回调跑在工作线程，Compose 状态只能在主线程改。
3
// 所以网络回调里改 UI 状态前，都要 main { } 切线程。
4

5
api.fetchProfile(account) { profile ->
6
    main {
7
        // 这里的代码在主线程跑，可以安全地改 Compose 状态
8
        state.value = State.Ready(...)
9
    }
10
}