学习

Seminar Week 2 Summary · Jimmy Huang's Blog

概念	作用	适合什么场景
类（Class）	给对象建模，保存状态	例如用户、订单、某个实体对象
属性（Property）	保存数据	例如 `name`、`age`、`message`
函数（Function）	执行动作或逻辑	例如计算、格式化、事件处理

关键字	含义	能不能重新赋值	适合什么情况
`var`	可变（mutable）	可以	值之后会变
`val`	只读引用（immutable / read-only）	不可以	默认优先使用

写法	含义	结果	风险/特点
`if (x != null)`	先显式判断再用	最传统	安全，但较啰嗦
`x?.length`	安全调用（safe call）	返回可空结果，如 `Int?`	推荐，简洁安全
`x!!.length`	非空断言（`!!`）	当成一定非空	如果其实是 `null`，会直接抛异常

更适合用函数	更适合用类
计算逻辑、工具函数、格式化、事件处理	有明确实体、要保存状态、要长期传递和复用的数据结构

普通函数	Composable 函数
主要做逻辑、计算、数据处理	主要描述 UI
不需要 `@Composable`	必须带 `@Composable`
返回值关注“数据”	更关注“界面长什么样”

布局	作用	适合什么场景
`Column`	垂直排列	上下堆叠文字、按钮、表单项
`Row`	水平排列	图标 + 文字、左右并排元素
`Box`	叠放 / 定位容器	居中放元素、做覆盖层、占满空间后再定位

kotlin

fun calculate(num: Int, action: (Int) -> Int): Int {
    return action(num)
}

fun main() {
    val a = calculate(7) { it * 2 }
    val b = calculate(7) { it + 3 }
    val c = calculate(7) { it * it }

    println(a) // 14
    println(b) // 10
    println(c) // 49
}

kotlin

fun double(x: Int): Int {
    return x * 2
}

fun calculate(num: Int, action: (Int) -> Int): Int {
    return action(num)
}

fun main() {
    val result = calculate(7, ::double)
    println(result)
}

kotlin

// 定义一个名为 Calculation 的类
// 构造时需要传入一个整数 num，并且这个 num 只能在类内部使用（private）
class Calculation(private val num: Int) {

    // 英寸换算系数
    // 1 厘米 ≈ 0.393701 英寸
    // private 表示这个变量只能在当前类内部使用
    private val inchConverter = 0.393701

    // 计算 1 到 count 的累加和
    // 例如 count = 5，则结果是 1 + 2 + 3 + 4 + 5 = 15
    fun echoThis(count: Int): Int {
        var total = 0

        // 遍历 1 到 count
        for (i in 1..count) {
            total += i
        }

        return total
    }

    // 把构造函数里传入的 num（单位默认看作厘米）转换成英寸
    // 返回值是 Double，因为乘以小数后结果可能带小数
    fun convertCMtoInch(): Double {
        return num * inchConverter
    }

    // 把字符串转换成大写
    // 参数和返回值都允许为 null
    // ?. 表示安全调用：如果 word 是 null，就不会报错，而是直接返回 null
    fun changeToUpperCase(word: String?): String? {
        return word?.uppercase()
    }

    // 也是把字符串转换成大写
    // 这里参数允许为 null，但返回值要求一定是 String
    // !! 表示“我强行认为它不为 null”
    // 如果传进来的 word 真的是 null，这里会直接报错（NullPointerException）
    fun changeToUpperCase1(word: String?): String {
        return word!!.uppercase()
    }

    // 还是把字符串转换成大写
    // 这种写法先做非空判断，再决定怎么处理，更安全，也更容易理解
    // 如果传入 null，就返回空字符串 ""
    fun changeToUpperCase2(word: String?): String {
        var result = ""

        if (word != null)
            result = word.uppercase()

        return result
    }

    // 返回字符串长度
    // 参数允许为 null，但这里用了 !! 强制非空
    // 所以如果传入 null，会报错
    fun wordLength(word: String?): Int {
        return word!!.length
    }

    // 高阶函数示例
    // doubleIt 不是普通参数，而是一个函数类型参数
    // (Int) -> Int 的意思是：
    // 传入一个 Int，返回一个 Int
    //
    // 这里会把类里的 num 传给 doubleIt 这个函数去处理
    // 比如 num = 7，传入 { it * 2 }，结果就是 14
    fun calculate(doubleIt: (Int) -> Int): Int {
        val result = doubleIt(num)
        return result
    }
}

kotlin

val calculator = Calculation(7)

val result = calculator.calculate { it * 2 }          // 14
val result2 = calculator.changeToUpperCase("hello")   // HELLO
val result3 = calculator.wordLength("hello")          // 5
val result4 = calculator.echoThis(5)                  // 15

kotlin

@Composable
fun RowAndColumn() {
    Row(verticalAlignment = Alignment.CenterVertically) {
        Icon(
            imageVector = Icons.Default.Person,
            contentDescription = "Person"
        )
        Column {
            Text("the first Text")
            Text("the second Text")
        }
    }
}

kotlin

@Composable
fun Greeting(name: String) {
    Box(Modifier.fillMaxSize()) {
        Text(
            text = "Welcome to$name!",
            fontSize = 30.sp,
            modifier = Modifier.align(Alignment.Center)
        )
    }
}

kotlin

val context = LocalContext.current

ElevatedButton(
    onClick = {
        Toast.makeText(
            context,
            "This is a Toast",
            Toast.LENGTH_SHORT
        ).show()
    }
) {
    Text("Click")
}

Seminar Week 2 Summary

Learning Outcomes

本周在课程中的位置

Seminar Week 2 Summary

Learning Outcomes

本周在课程中的位置

Kotlin Basics

Kotlin 与 Android：这门语言为什么重要

类、属性、函数：先分清各自角色

属性（Properties）

属性的基本声明方式

var 和 val 的区别

类型推断（Type Inference）

类属性必须初始化

延迟初始化（Late Initialization）

空安全（Null Safety）

Kotlin 的核心态度：默认不允许空值

三种常见处理方式

例子

推荐理解方式

函数（Functions）

基本特征

函数参数不能写 var / val

默认参数（Default Parameters）

什么时候更适合用函数？

主构造器（Primary Constructor）与继承（Inheritance）

主构造器

构造器参数是否能在类内使用，取决于有没有 val / var

多参数主构造器

继承（Inheritance）

Lambda 与高阶函数（Higher-Order Functions）

Lambda 是什么

Lambda 的阅读方法

普通函数与 Lambda 的对照

Lambda 类型（Function Type）

高阶函数

尾随 Lambda（Trailing Lambda）与 it

列表（List）

两种基本列表

一个容易忽略的点

课堂综合例子：Calculation 类怎么读

这个类里能看到什么

这个例子想让你看懂什么

课件中的输出结果

Jetpack Compose (Part I)

为什么要用 Jetpack Compose

为什么这节课先讲 Kotlin，再讲 Compose

可组合函数（Composable Functions）

什么是 @Composable

和普通 Kotlin 函数有什么不同

UI 预览（Preview）

基本做法

为什么 Preview 很重要

实践建议

布局（Layouts）

三个最基本的布局

Column

Row

Box

一个重要的整体理解

Compose 的三阶段：Composition -> Layout -> Drawing

1. Composition

2. Layout

3. Drawing

一句话记忆

课堂补充：重组（Recomposition）

Modifier：外观、位置、行为的统一入口

Modifier 是做什么的

Modifier 的顺序很重要

一个实践结论

常见组件（Composable Components）

1. Surface

2. Scaffold

3. Button

4. Toast

5. TextField / OutlinedTextField

Kotlin 与 Compose 的连接：为什么 Lambda 特别重要

典型例子 1：Button 的点击事件

典型例子 2：TextField 的值变化

这说明了什么

`var` 和 `val` 的区别

函数参数不能写 `var` / `val`

构造器参数是否能在类内使用，取决于有没有 `val` / `var`

尾随 Lambda（Trailing Lambda）与 `it`

课堂综合例子：`Calculation` 类怎么读

什么是 `@Composable`

`Column`

`Row`

`Box`