教程雨

OKX新手入门教程导航，收录OKX注册、充值、买币、提现等基础操作教程

Kotlin+Jetpack Compose跨平台开发实战，一份代码跑遍Android/iOS/Desktop/Web全平台应用

Kotlin+Jetpack Compose跨平台开发实战：2026年最值得学习的Android开发技术栈

前言：为什么2026年要学Kotlin和Compose

2026年的移动开发格局已经很清晰了：原生开发依然重要，但开发方式在变。

Flutter和React Native曾经是跨平台的主流选择，但原生开发的门槛其实没那么高——如果你用对了工具的话。

Kotlin是Google钦定的Android首选开发语言，它的简洁性和现代特性让它比Java好用太多。

Jetpack Compose是Google推出的声明式UI框架，用Compose写界面，代码量比传统XML少一半，开发体验却好很多。

更重要的是，Kotlin Multiplatform正在让「一份代码，多端运行」成为现实。不再是那种「看起来跨平台但其实坑很多」的技术，而是真正的原生体验。

这篇文章，我会带你从零掌握这套技术栈。不管你想做Android开发，还是想探索跨平台，这套方案都值得你投入时间。

Kotlin与Jetpack Compose开发三阶段学习路线，从基础语法到KMP跨平台项目完整学习路径规划

一、Kotlin：现代Android开发的首选语言

1.1 为什么选Kotlin而不是Java

如果你还在用Java写Android，真的该换了。不是Java不好，是Kotlin太好。

Kotlin的核心优势：

  • 简洁性：同样的功能，Kotlin代码量通常只有Java的一半
  • 空安全：Kotlin从语言层面解决了空指针异常
  • 协程：处理异步操作比线程+回调优雅太多
  • 扩展函数：可以给现有类添加新方法而不继承
  • 数据类：自动生成equals、hashCode、toString、copy
  • 智能类型推断：变量声明更简洁

实际对比（一个数据类的处理）：

java

// Java：需要手写大量样板代码
public class User {
    private String name;
    private int age;
    
    public User(String name, int age) {
        this.name = name;
        this.age = age;
    }
    
    public String getName() { return name; }
    public void setName(String name) { this.name = name; }
    public int getAge() { return age; }
    public void setAge(int age) { this.age = age; }
    
    @Override
    public boolean equals(Object o) {...}
    @Override
    public int hashCode() {...}
    @Override
    public String toString() {...}
}

kotlin

// Kotlin：一行搞定
data class User(val name: String, val age: Int)

1.2 Kotlin基础速成

变量声明：

kotlin

// val：不可变变量（推荐）
val name: String = "张三"
val age = 25  // 类型推断

// var：可变变量（必要时使用）
var count = 0
count = 1

// 可空类型
var nullableName: String? = null
nullableName = "李四"

函数：

kotlin

// 标准函数
fun greet(name: String): String {
    return "Hello, $name"
}

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

// 默认参数
fun greet(name: String, prefix: String = "Hello") = "$prefix, $name"

// Lambda表达式
val sum = { a: Int, b: Int -> a + b }
val result = sum(1, 2)

类与对象：

kotlin

// 数据类
data class User(val name: String, val email: String)

// 单例对象
object AppConfig {
    val apiUrl = "https://api.example.com"
}

// 密封类（受限的类继承）
sealed class Result<out T> {
    data class Success<T>(val data: T) : Result<T>()
    data class Error(val message: String) : Result<Nothing>()
    object Loading : Result<Nothing>()
}

协程基础：

kotlin

import kotlinx.coroutines.*

// 异步执行
suspend fun fetchUser(): User {
    return withContext(Dispatchers.IO) {
        api.getUser()
    }
}

// 使用协程
viewModelScope.launch {
    val user = fetchUser()
    _userState.value = user
}

1.3 Kotlin学习资源推荐

官方教程：

  • Kotlin官方文档（kotlinlang.org）——最权威的学习资料
  • Kotlin Koans——在线练习题，边学边练

书籍：

  • 《Kotlin实战》——经典入门书
  • 《深入理解Kotlin协程》——进阶必备

实践建议：

  • 用Kotlin重写你之前的Java项目
  • 尝试用Kotlin写一个命令行工具或脚本
  • 参与Kotlin开源项目

二、Jetpack Compose：从XML到声明式UI

2.1 什么是声明式UI

传统Android开发用的是命令式UI：你告诉系统「去找到这个按钮，设置它的文字为XX，加上这个监听器」。

Compose是声明式UI：你只描述「这个界面应该长什么样」，系统自动帮你处理更新。

kotlin

// 传统XML方式
val button = findViewById<Button>(R.id.submit)
button.text = "提交"
button.setOnClickListener { 
    Toast.makeText(this, "点击了", Toast.LENGTH_SHORT).show() 
}

// Compose声明式方式
@Composable
fun SubmitButton() {
    var clicked by remember { mutableStateOf(false) }
    
    Button(
        onClick = { clicked = true },
        colors = ButtonDefaults.buttonColors(
            containerColor = if (clicked) Color.Green else Color.Blue
        )
    ) {
        Text(if (clicked) "已提交" else "提交")
    }
}

声明式的优势在于：UI状态和UI描述是自动同步的。你改变了状态，界面自动更新，不用手动处理。

2.2 Compose开发环境

前置要求：

  • Android Studio Jellyfish（2024.3）或更新版本
  • JDK 17+
  • Kotlin 1.9.0+

创建Compose项目（在Android Studio中）：

  1. File → New → New Project
  2. 选择「Empty Activity」
  3. 设置项目名和包名
  4. Compose版本会自动配置好

build.gradle.kts配置（关键部分）：

kotlin

android {
    composeOptions {
        kotlinCompilerExtensionVersion = "1.5.8"
    }
}

dependencies {
    // Compose BOM（统一管理版本）
    val composeBom = platform("androidx.compose:compose-bom:2024.02.00")
    implementation(composeBom)
    
    // UI
    implementation("androidx.compose.ui:ui")
    implementation("androidx.compose.ui:ui-graphics")
    implementation("androidx.compose.ui:ui-tooling-preview")
    
    // Material Design
    implementation("androidx.compose.material3:material3")
    
    // 调试
    debugImplementation("androidx.compose.ui:ui-tooling")
}

2.3 Compose核心概念

Composable函数：

用@Composable注解标记的函数是Compose的UI构建单元：

kotlin

@Composable
fun Greeting(name: String) {
    Text(text = "Hello, $name!")
}

@Composable
fun MyScreen() {
    Greeting(name = "Android")
}

状态管理：

kotlin

@Composable
fun Counter() {
    // remember：跨重组保持状态
    // mutableStateOf：状态变化触发UI重组
    var count by remember { mutableStateOf(0) }
    
    Column(
        horizontalAlignment = Alignment.CenterHorizontally,
        verticalArrangement = Arrangement.Center
    ) {
        Text(text = "计数: $count")
        
        Spacer(modifier = Modifier.height(16.dp))
        
        Button(onClick = { count++ }) {
            Text("点击 +1")
        }
    }
}

副作用处理：

kotlin

@Composable
fun UserProfile(userId: String) {
    var user by remember { mutableStateOf<User?>(null) }
    var isLoading by remember { mutableStateOf(true) }
    
    // LaunchedEffect：处理副作用
    LaunchedEffect(userId) {
        isLoading = true
        user = userRepository.getUser(userId)
        isLoading = false
    }
    
    if (isLoading) {
        CircularProgressIndicator()
    } else {
        UserCard(user = user!!)
    }
}

2.4 常用UI组件

布局组件：

kotlin

@Composable
fun MyLayout() {
    Column(
        modifier = Modifier
            .fillMaxSize()
            .padding(16.dp)
    ) {
        // 垂直排列
        Text("标题", style = MaterialTheme.typography.headlineMedium)
        
        Spacer(modifier = Modifier.height(8.dp))
        
        // 可滚动列表
        LazyColumn(
            modifier = Modifier.weight(1f),
            verticalArrangement = Arrangement.spacedBy(8.dp)
        ) {
            items(10) { index ->
                ListItem(title = "第 ${index + 1} 项")
            }
        }
        
        // 底部按钮
        Button(
            onClick = { /* ... */ },
            modifier = Modifier.fillMaxWidth()
        ) {
            Text("提交")
        }
    }
}

Material Design 3：

kotlin

@Composable
fun MaterialThemeExample() {
    MaterialTheme(
        colorScheme = MaterialTheme.colorScheme.copy(
            primary = Color(0xFF6750A4),
            secondary = Color(0xFF625B71)
        )
    ) {
        // 所有子组件都使用主题颜色
        Button(onClick = { }) {
            Text("按钮")
        }
    }
}

三、Kotlin Multiplatform：真正的跨平台开发

3.1 什么是Kotlin Multiplatform

Kotlin Multiplatform（KMP）是由JetBrains推出的跨平台解决方案，核心理念是：

  • 共享业务逻辑：数据模型、网络请求、数据库操作等用Kotlin写一份
  • 保留原生体验：UI用各平台的原生框架（Android用Compose，iOS用SwiftUI）
  • 编译成原生代码：不是Web打包，是真正的原生应用

这和Flutter/React Native不一样——它们是用Dart/JS重写一切，然后渲染到原生控件。KMP是「能用原生就用原生，只共享必须共享的部分」。

3.2 项目结构

plaintext

shared/
├── src/
│   ├── commonMain/kotlin/      # 共享代码
│   │   └── com/example/shared/
│   │       ├── data/
│   │       │   ├── api/        # 网络请求
│   │       │   ├── db/         # 数据库
│   │       │   └── repository/ # 仓储层
│   │       └── domain/         # 业务模型
│   ├── androidMain/            # Android平台代码
│   ├── iosMain/                # iOS平台代码
│   └── desktopMain/           # 桌面平台代码
├── androidApp/                 # Android应用
├── iosApp/                     # iOS应用
└── desktopApp/                # 桌面应用

3.3 共享代码示例

定义期望（Expect）：

kotlin

// shared/src/commonMain/kotlin/com/example/shared/Platform.kt
expect class Platform() {
    val name: String
}

// Android实现
actual class Platform() {
    actual val name: String = "Android ${android.os.Build.VERSION.SDK_INT}"
}

// iOS实现
actual class Platform() {
    actual val name: String = UIDevice.current.name
}

// Desktop实现
actual class Platform() {
    actual val name: String = "${System.getProperty("os.name")}"
}

共享业务逻辑：

kotlin

// shared/src/commonMain/kotlin/com/example/shared/Greeting.kt
class Greeting(private val platform: Platform) {
    fun greet(): String {
        return "Hello from ${platform.name}!"
    }
}

3.4 KMP适用场景分析

适合用KMP的：

  • 企业内部应用，需要快速覆盖多平台
  • 有Web端+iOS端+Android端，功能相似
  • 团队有Kotlin经验，但没有Swift/Dart经验
  • 对原生性能要求高的场景

不适合用KMP的：

  • 高度平台化的UI（每个平台体验要完全不一样）
  • 强依赖平台特定API的场景
  • 小团队，精力有限

四、实战项目：从零构建一个笔记应用

4.1 项目需求

我们来做一个小型的笔记应用，功能包括：

  • 创建、编辑、删除笔记
  • 笔记分类（标签）
  • 本地存储（Room数据库）
  • 多平台支持（Android + 桌面端）

4.2 搭建项目结构

使用Android Studio的KMP项目向导，创建共享模块：

plaintext

note_app/
├── shared/
│   └── src/
│       ├── commonMain/kotlin/
│       │   └── com/example/note/
│       │       ├── data/
│       │       │   ├── local/       # 数据库
│       │       │   └── repository/   # 仓储
│       │       ├── domain/
│       │       │   └── model/        # 数据模型
│       │       └── di/              # 依赖注入
│       └── ...
├── androidApp/
└── desktopApp/

4.3 数据模型和仓储

kotlin

// domain/model/Note.kt
data class Note(
    val id: String = UUID.randomUUID().toString(),
    val title: String,
    val content: String,
    val tags: List<String> = emptyList(),
    val createdAt: Long = System.currentTimeMillis(),
    val updatedAt: Long = System.currentTimeMillis()
)

kotlin

// commonMain/repository/NoteRepository.kt
interface NoteRepository {
    suspend fun getAllNotes(): List<Note>
    suspend fun getNoteById(id: String): Note?
    suspend fun saveNote(note: Note)
    suspend fun deleteNote(id: String)
    suspend fun searchNotes(query: String): List<Note>
}

4.4 Compose UI实现

kotlin

// androidApp/src/main/.../androidMain/NoteListScreen.kt
@Composable
fun NoteListScreen(
    notes: List<Note>,
    onNoteClick: (String) -> Unit,
    onAddNote: () -> Unit
) {
    Scaffold(
        floatingActionButton = {
            FloatingActionButton(onClick = onAddNote) {
                Icon(Icons.Default.Add, contentDescription = "添加笔记")
            }
        }
    ) { padding ->
        LazyColumn(
            modifier = Modifier.padding(padding),
            contentPadding = PaddingValues(16.dp),
            verticalArrangement = Arrangement.spacedBy(12.dp)
        ) {
            items(notes, key = { it.id }) { note ->
                NoteCard(
                    note = note,
                    onClick = { onNoteClick(note.id) }
                )
            }
        }
    }
}

4.5 编译和运行

bash

# 运行Android
./gradlew :androidApp:run

# 运行桌面端
./gradlew :desktopApp:run

# 打包Android APK
./gradlew :androidApp:assembleRelease

# 打包桌面端
./gradlew :desktopApp:packageRelease

五、学习路线建议

5.1 入门阶段（第1-2周）

目标：掌握Kotlin基础，能用Compose写简单界面

任务清单：

  • 学习Kotlin基础语法（变量、函数、类、空安全）
  • 完成Kotlin Koans练习
  • 搭建Compose开发环境
  • 用Compose实现一个简单的计数器界面
  • 学习Compose状态管理（remember、mutableStateOf）

5.2 进阶阶段（第3-6周）

目标：掌握Compose常用组件，能开发完整页面

任务清单：

  • 学习Compose布局组件（Column、Row、Box、LazyColumn）
  • 掌握Material Design 3组件
  • 学习网络请求（Retrofit + Ktor）
  • 学习本地数据库（Room）
  • 实现一个带网络请求和本地存储的完整页面

5.3 跨平台阶段（第7-10周）

目标：理解KMP架构，能开发KMP项目

任务清单：

  • 学习KMP项目结构
  • 理解expect/actual机制
  • 将之前的笔记应用改造为KMP项目
  • 添加桌面端支持
  • 学习原生平台互调

结语

Kotlin和Jetpack Compose代表了Android开发的未来方向，而Kotlin Multiplatform正在让「一次编写，多端运行」从口号变成现实。

这套技术栈的学习曲线不算陡峭，但需要你有耐心去理解它的理念——声明式UI、协程、跨平台共享。掌握了这些，你会发现开发移动应用比以前高效太多。

建议从一个小项目开始，边做边学。别等「完全准备好」再动手——真正准备好的人，都是在做的过程中变强的。

祝你学习顺利，有问题欢迎回来查资料。

发表回复

您的邮箱地址不会被公开。 必填项已用 * 标注