Android 程序入口与核心组件详解

引言

本文将从一个更系统的视角出发，详细拆解 Android 应用从点击图标到界面呈现的完整启动流程，并逐一解释每个核心组件的作用与设计理念。同时，本文会持续引入 iOS 技术栈的对照，帮助有 iOS 开发经验的读者快速建立知识映射。

第一部分：Android 应用启动流程

1.1 程序入口详解

1.1.1 Android 应用启动流程图

scss 复制代码

用户点击图标
    ↓
Zygote 进程 fork 出新的应用进程
    ↓
创建 Application 对象（如果指定了自定义 Application，则创建其实例）
    ↓
执行 Application.onCreate()
    ↓
系统读取 AndroidManifest.xml
    ↓
找到声明了 LAUNCHER 的 Activity（启动页）
    ↓
创建该 Activity 实例
    ↓
执行 Activity.onCreate(savedInstanceState)
    ↓
Activity.onStart()
    ↓
Activity.onResume()
    ↓
用户看到界面

1.1.2 对比 iOS 应用启动流程

scss 复制代码

用户点击图标
    ↓
main() 函数被调用
    ↓
UIApplicationMain() 创建 UIApplication 实例
    ↓
创建 AppDelegate 对象
    ↓
执行 AppDelegate.application(_:didFinishLaunchingWithOptions:)
    ↓
读取 Info.plist，确定初始界面（Storyboard / SwiftUI App）
    ↓
创建 UIWindow（窗口）
    ↓
创建根视图控制器（RootViewController）
    ↓
设置为 window.rootViewController
    ↓
window.makeKeyAndVisible()
    ↓
用户看到界面

1.1.3 核心概念对比表

阶段	Android	iOS
入口点	`MainActivity`（LAUNCHER Activity）	`UIWindow.rootViewController`
配置文件	`AndroidManifest.xml`	`Info.plist`
应用级代理	`Application`	`AppDelegate`
窗口容器	Activity（直接承载视图）	`UIWindow`（容器）+ `UIViewController`
启动页	LAUNCHER Activity	LaunchScreen.storyboard
视图容器	Activity 的内容视图	UIViewController 的 `view`

1.2 AndroidManifest.xml 配置详解

1.2.1 什么是 AndroidManifest.xml？

AndroidManifest.xml 是每个 Android 项目必备的配置文件，它就像应用的"身份证"，向系统声明了应用包含哪些组件、需要哪些权限、支持哪些设备特性等。在 iOS 中，它的功能分散在 Info.plist、Entitlements、AppDelegate 等多个文件中。

1.2.2 完整配置示例

以下是一个使用 Compose 的现代 Android 应用的 AndroidManifest.xml 示例（基于 AGP 9.x，namespace 已在 build.gradle.kts 中定义）：

xml 复制代码

<?xml version="1.0" encoding="utf-8"?>
<manifest xmlns:android="http://schemas.android.com/apk/res/android">

    <!-- Android 6.0+ 需要动态申请危险权限，轻量级权限只需声明即可 -->
    <uses-permission android:name="android.permission.INTERNET" />
    <uses-permission android:name="android.permission.CAMERA" />

    <!-- 应用配置 -->
    <application
        android:name=".HelloKotlinApplication"  <!-- 自定义 Application 类 -->
        android:allowBackup="true"
        android:icon="@mipmap/ic_launcher"
        android:label="@string/app_name"
        android:roundIcon="@mipmap/ic_launcher_round"
        android:supportsRtl="true"
        android:theme="@style/Theme.HelloKotlin"
        android:hardwareAccelerated="true">

        <!-- LAUNCHER Activity（启动页） -->
        <activity
            android:name=".MainActivity"
            android:exported="true"
            android:label="@string/app_name"
            android:theme="@style/Theme.HelloKotlin"
            android:screenOrientation="portrait"
            android:configChanges="orientation|keyboardHidden|screenSize"
            android:windowSoftInputMode="adjustResize">

            <!-- Intent Filter：告诉系统这是启动页 -->
            <intent-filter>
                <action android:name="android.intent.action.MAIN" />
                <category android:name="android.intent.category.LAUNCHER" />
            </intent-filter>
        </activity>

        <!-- 第二个 Activity -->
        <activity
            android:name=".SecondActivity"
            android:exported="false"
            android:parentActivityName=".MainActivity" />

    </application>
</manifest>

1.2.3 对比 iOS 的 Info.plist

xml 复制代码

<!-- iOS Info.plist 等价配置 -->
<key>CFBundleDisplayName</key>
<string>HelloKotlin</string>

<key>CFBundleIdentifier</key>
<string>$(PRODUCT_BUNDLE_IDENTIFIER)</string>

<key>CFBundleShortVersionString</key>
<string>1.0</string>

<key>CFBundleVersion</key>
<string>1</string>

<key>UILaunchStoryboardName</key>
<string>LaunchScreen</string>

<key>UISupportedInterfaceOrientations</key>
<array>
    <string>UIInterfaceOrientationPortrait</string>
</array>

<key>UIApplicationSceneManifest</key>
<dict>
    <key>UIApplicationSupportsMultipleScenes</key>
    <false/>
    <key>UISceneConfigurations</key>
    <dict>
        <key>UIWindowSceneSessionRoleApplication</key>
        <array>
            <dict>
                <key>UISceneConfigurationName</key>
                <string>Default Configuration</string>
                <key>UISceneDelegateClassName</key>
                <string>$(PRODUCT_MODULE_NAME).SceneDelegate</string>
            </dict>
        </array>
    </dict>
</dict>

1.3 Application 类详解

1.3.1 什么是 Application？

Application 是整个应用的入口类，在 Android 系统中它代表正在运行的应用。它在所有组件之前被创建，并且全局唯一 。在 iOS 中，AppDelegate 承担了类似的应用级生命周期管理职责。

1.3.2 自定义 Application 示例

kotlin 复制代码

import android.app.Application
import android.util.Log

// 自定义 Application 类：相当于 iOS 的 AppDelegate
class HelloKotlinApplication : Application() {

    // 单例：方便全局获取 Application 实例，但需谨慎使用，避免内存泄漏
    companion object {
        lateinit var instance: HelloKotlinApplication
            private set
    }

    // 应用创建时调用，类似 iOS 的 didFinishLaunchingWithOptions
    override fun onCreate() {
        super.onCreate()
        instance = this

        // 初始化操作
        initThirdPartySDKs()
        initGlobalConfig()
        initLogger()
        initDatabase()

        Log.d("HelloKotlinApp", "✅ 应用创建成功")
    }

    private fun initThirdPartySDKs() {
        // 初始化友盟统计、推送服务、崩溃监控等
    }

    private fun initGlobalConfig() {
        // 设置全局配置，例如 API 地址、环境标识
    }

    private fun initLogger() {
        // 初始化日志框架
    }

    private fun initDatabase() {
        // 初始化 Room 数据库
    }

    override fun onTerminate() {
        super.onTerminate()
        releaseResources()
    }

    // 系统内存不足时调用
    override fun onLowMemory() {
        super.onLowMemory()
        clearMemoryCache()
    }

    // 更详细的内存警告级别
    override fun onTrimMemory(level: Int) {
        super.onTrimMemory(level)
        when (level) {
            TRIM_MEMORY_RUNNING_LOW -> {
                // 清理不必要的缓存
            }
            TRIM_MEMORY_RUNNING_CRITICAL -> {
                // 释放更多内存
            }
        }
    }

    private fun releaseResources() {
        // 释放资源
    }

    private fun clearMemoryCache() {
        // 清理内存缓存
    }
}

1.3.3 在 AndroidManifest.xml 中注册

xml 复制代码

<application
    android:name=".HelloKotlinApplication"
    ...>
</application>

1.3.4 对比 iOS 的 AppDelegate

swift 复制代码

// iOS AppDelegate.swift（功能等价）
import UIKit

class AppDelegate: UIResponder, UIApplicationDelegate {

    static var shared: AppDelegate!

    func application(
        _ application: UIApplication,
        didFinishLaunchingWithOptions launchOptions: [UIApplication.LaunchOptionsKey: Any]?
    ) -> Bool {
        AppDelegate.shared = self
        // 初始化操作
        initThirdPartySDKs()
        initGlobalConfig()
        return true
    }

    func applicationWillTerminate(_ application: UIApplication) {
        releaseResources()
    }

    func applicationDidReceiveMemoryWarning(_ application: UIApplication) {
        clearMemoryCache()
    }
}

第二部分：MainActivity 详解

2.1 什么是 MainActivity？

2.1.1 Activity 的定义

在 Android 中，Activity 是一个用户界面的基本构建块，可以理解为一个单独的"屏幕"或"页面"。一个应用可以包含多个 Activity，它们共同构成应用的导航流。

类比 iOS：

Activity 相当于 iOS 中的 UIViewController。
每个 Activity 管理自己的界面和交互。
Activity 的显示和管理依赖于系统级的"返回栈"（Activity 栈），这类似于 iOS 的 UINavigationController 管理的 ViewController 栈。

2.1.2 Activity vs UIViewController 对比

概念	Android (Activity)	iOS (UIViewController)
基本定义	一个屏幕/页面	一个屏幕/页面
数量	一个应用可以有多个	一个应用可以有多个
显示方式	系统管理，直接显示在屏幕上	放在 UIWindow 中显示
布局设置	`setContentView()` 或 Compose 的 `setContent`	`viewDidLoad()` 中添加子视图
生命周期	`onCreate → onStart → onResume` 等	`viewDidLoad → viewWillAppear → viewDidAppear` 等
返回管理	系统 Activity 栈	`UINavigationController` 栈
配置声明	在 `AndroidManifest.xml` 中	在 Storyboard 或 SwiftUI App 中

2.2 MainActivity 完整代码解析

2.2.1 完整代码

kotlin 复制代码

// MainActivity.kt
package com.example.hellokotlin

import android.os.Bundle
import androidx.activity.ComponentActivity
import androidx.activity.compose.setContent
import androidx.compose.foundation.layout.fillMaxSize
import androidx.compose.material3.MaterialTheme
import androidx.compose.material3.Surface
import androidx.compose.material3.Text
import androidx.compose.runtime.Composable
import androidx.compose.ui.Modifier
import androidx.compose.ui.tooling.preview.Preview
import com.example.hellokotlin.ui.theme.HelloKotlinTheme

// MainActivity 继承自 ComponentActivity
// ComponentActivity 是现代 Android Activity 的基类，提供了对 Compose 和 Fragment 的支持
class MainActivity : ComponentActivity() {

    // onCreate 是 Activity 生命周期的第一个方法
    // 相当于 iOS 的 viewDidLoad
    override fun onCreate(savedInstanceState: Bundle?) {
        // 必须调用父类的 onCreate 完成基础初始化
        super.onCreate(savedInstanceState)

        // setContent 是 Compose 的入口，用于定义该 Activity 显示的内容
        // 相当于 iOS 的 view.addSubview(...) 或 SwiftUI 的 body
        setContent {
            // 应用自定义主题
            HelloKotlinTheme {
                // Surface 是一个容器，提供背景色、形状等基础样式
                Surface(
                    modifier = Modifier.fillMaxSize(),
                    color = MaterialTheme.colorScheme.background
                ) {
                    // 调用自定义的可组合函数，显示问候语
                    Greeting("Android")
                }
            }
        }
    }
}

// 可组合函数：描述一段 UI 的样子
// 相当于 SwiftUI 的 View
@Composable
fun Greeting(name: String, modifier: Modifier = Modifier) {
    Text(
        text = "Hello $name!",
        modifier = modifier
    )
}

// 预览函数：不需要运行 app 即可在 IDE 中看到 UI 效果
// 相当于 SwiftUI 的 #Preview
@Preview(showBackground = true)
@Composable
fun GreetingPreview() {
    HelloKotlinTheme {
        Greeting("Android")
    }
}

2.2.2 逐行解析

kotlin 复制代码

// 1. 包声明
package com.example.hellokotlin
// 作用：标识该文件属于哪个模块，防止命名冲突

// 2. 导入语句 (import)
import android.os.Bundle
// 相当于 iOS 中的 import Foundation

// 3. 类声明
class MainActivity : ComponentActivity()
// class = 定义一个类
// MainActivity = 类名
// : ComponentActivity = 继承 ComponentActivity（相当于 Swift 的 class MainActivity: UIViewController）

// 4. 方法重写
override fun onCreate(savedInstanceState: Bundle?)
// override = 重写父类方法
// fun = 声明函数
// onCreate = 方法名
// savedInstanceState: Bundle? = 可空参数，用于恢复之前保存的状态

// 5. 调用父类方法
super.onCreate(savedInstanceState)
// 先让父类完成必要的初始化

// 6. 设置内容
setContent { /* ... */ }
// Compose 专用方法，设置 UI 内容

// 7. @Composable 注解
@Composable
// 标记该函数用于构建 UI

2.3 组件详细解释

2.3.1 ComponentActivity

kotlin 复制代码

class MainActivity : ComponentActivity()

ComponentActivity 继承自 Activity，是 AndroidX 中推荐的 Activity 基类。它提供了：

对 Jetpack Compose 的支持；
对 Fragment 的兼容性管理；
更现代的生命周期 API。

2.3.2 Bundle 参数

kotlin 复制代码

override fun onCreate(savedInstanceState: Bundle?)

savedInstanceState 是一个数据包，用于恢复 Activity 被系统杀死前的临时状态（例如屏幕旋转）。这类似于 iOS 中 UIViewController 的 init?(coder:) 或 UIApplicationDelegate 中通过 UserDefaults 恢复状态的机制。

第三部分：setContent 详解

3.1 setContent 的本质

setContent 是 Compose 专用的方法，它接收一个用 Kotlin 代码描述 UI 的 Lambda 表达式，并将这段声明式的 UI 描述渲染到屏幕上。

对比 iOS：

UIKit: view.addSubview(...)
SwiftUI: 直接在 body 中返回 View

3.1.1 对比三种 UI 编写方式

kotlin 复制代码

// 1. Compose (现代声明式)
setContent {
    Text("Hello")
}
// 相当于 SwiftUI 的 body: some View { Text("Hello") }

// 2. 传统 XML
setContentView(R.layout.activity_main)
// 相当于从 Storyboard 加载

// 3. 纯代码创建视图
val textView = TextView(this)
textView.text = "Hello"
setContentView(textView)
// 相当于 let label = UILabel(); label.text = "Hello"; view.addSubview(label)

3.2 setContent 的 Lambda 表达式

kotlin 复制代码

setContent {
    // 这个花括号里的是一个 Lambda 表达式（匿名函数）
    Text("Hello")
}

3.2.1 Lambda 基础

kotlin 复制代码

// Lambda 语法：{ 参数 -> 函数体 }
val sum = { a: Int, b: Int -> a + b }
println(sum(1, 2))  // 输出 3

// 作为函数参数传递
fun doSomething(action: () -> Unit) {
    action()
}
doSomething { println("Hello") }

第四部分：HelloKotlinTheme 详解

4.1 什么是 Theme？

Theme 是对整个应用外观的统一配置，确保颜色、字体、形状等保持一致。HelloKotlinTheme 是我们自定义的 Material3 主题。

对比 iOS：

UIAppearance 用于全局外观配置；
SwiftUI 中通过 .environmentObject 或自定义 ViewModifier 实现类似效果。

4.2 Material Design 3 颜色系统

Material3 提供了一套系统的颜色角色，通过 MaterialTheme.colorScheme 访问：

kotlin 复制代码

MaterialTheme.colorScheme.background  // 背景色，类似 UIColor.systemBackground
MaterialTheme.colorScheme.primary     // 主色，类似 UIColor.tintColor
MaterialTheme.colorScheme.secondary   // 次要色，类似 UIColor.secondaryLabel
MaterialTheme.colorScheme.surface     // 表面色，卡片等容器的背景

4.2.1 颜色系统对比表

Material3	iOS (参考)	说明
`primary`	`tintColor`	主色调
`onPrimary`	与主色对比的文字色	主色上的文字
`secondary`	`secondaryLabel`	辅助色
`background`	`systemBackground`	页面背景
`surface`	`systemBackground`	卡片等表面背景
`error`	`systemRed`	错误/警告色
`outline`	`separatorColor`	边框/分割线

第五部分：Surface 详解

5.1 Surface 是什么？

Surface 是 Compose 中的一个基础容器，类似 iOS 中的 UIView。它可以设置背景色、形状、阴影等，并为内部内容提供一个"画布"。

kotlin 复制代码

Surface(
    modifier = Modifier.fillMaxSize(),
    color = MaterialTheme.colorScheme.background
) {
    // 内容
    Greeting("Android")
}

5.2 对比 iOS 的 UIView

kotlin 复制代码

// Android Compose
Surface(
    modifier = Modifier
        .fillMaxSize()
        .padding(16.dp),
    color = Color.White,
    shape = RoundedCornerShape(8.dp)
) {
    Text("Hello")
}

// iOS UIKit 等价代码
let containerView = UIView()
containerView.frame = view.bounds
containerView.autoresizingMask = [.flexibleWidth, .flexibleHeight]
containerView.backgroundColor = .white
containerView.layer.cornerRadius = 8
containerView.layoutMargins = UIEdgeInsets(top: 16, left: 16, bottom: 16, right: 16)

let label = UILabel()
label.text = "Hello"
label.frame = containerView.bounds
label.autoresizingMask = [.flexibleWidth, .flexibleHeight]
containerView.addSubview(label)
view.addSubview(containerView)

第六部分：Modifier 详解

6.1 Modifier 是什么？

Modifier 是 Compose 中的"修饰符"，它以声明式的方式为 UI 组件添加样式和行为。

对比 iOS：

UIKit 中的 frame、backgroundColor、layer.cornerRadius 等属性；
SwiftUI 中的 .padding()、.background()、.frame() 等修饰符。

6.1.1 Modifier 的链式调用

kotlin 复制代码

// Android Compose
Modifier
    .fillMaxSize()                        // 填满父容器
    .padding(16.dp)                       // 内边距
    .background(Color.Blue)               // 蓝色背景
    .clip(RoundedCornerShape(8.dp))       // 圆角裁剪

// iOS SwiftUI 等价写法
.padding(16)
.background(Color.blue)
.cornerRadius(8)
.frame(maxWidth: .infinity, maxHeight: .infinity)

6.1.2 常用 Modifier 一览表

kotlin 复制代码

// ========== 尺寸修饰符 ==========
Modifier.fillMaxSize()            // 填满父容器（宽度和高度）
Modifier.fillMaxWidth()           // 宽度填满
Modifier.fillMaxHeight()          // 高度填满
Modifier.size(100.dp)             // 固定尺寸
Modifier.width(100.dp)            // 固定宽度
Modifier.height(100.dp)           // 固定高度

// ========== 间距修饰符 ==========
Modifier.padding(16.dp)                          // 四周内边距
Modifier.padding(horizontal = 16.dp)             // 左右内边距
Modifier.padding(vertical = 8.dp)                // 上下内边距

// ========== 装饰修饰符 ==========
Modifier.background(Color.Blue)                  // 纯色背景
Modifier.background(brush = Brush.linearGradient(...)) // 渐变背景
Modifier.border(2.dp, Color.Red)                 // 边框
Modifier.shadow(4.dp, RoundedCornerShape(8.dp))  // 阴影
Modifier.clip(RoundedCornerShape(8.dp))          // 圆角裁剪

// ========== 布局修饰符 ==========
Modifier.align(Alignment.Center)                 // 对齐方式
Modifier.weight(1f)                              // 权重（在 Row 或 Column 中）
Modifier.offset(x = 10.dp, y = 20.dp)            // 偏移

// ========== 交互修饰符 ==========
Modifier.clickable { /* 点击处理 */ }
Modifier.pointerInput(Unit) { /* 手势处理 */ }

6.1.3 对比 iOS SwiftUI

Android Modifier	iOS SwiftUI	说明
`.fillMaxSize()`	`.frame(maxWidth: .infinity, maxHeight: .infinity)`	填满父容器
`.padding(16.dp)`	`.padding(16)`	内边距
`.background(Color.Blue)`	`.background(Color.blue)`	背景色
`.clip(RoundedCornerShape(8.dp))`	`.cornerRadius(8)`	圆角裁剪
`.shadow(4.dp, shape)`	`.shadow(color: .gray, radius: 4)`	阴影
`.align(Alignment.Center)`	`.frame(maxWidth: .infinity, alignment: .center)`	对齐

第七部分：@Composable 详解

7.1 @Composable 是什么？

@Composable 是 Compose 的核心理念之一，它告诉编译器：这个函数是用来描述 UI 的，而不是执行常规的副作用。

对比 iOS：

在 SwiftUI 中，所有 View 的 body 都是隐式的"可组合"函数；
使用 @ViewBuilder 也可以手动构建类似能力。

7.1.1 普通函数 vs @Composable 函数

kotlin 复制代码

// 普通函数：执行操作并返回值
fun add(a: Int, b: Int): Int = a + b

// @Composable 函数：描述 UI，不返回有意义的值
@Composable
fun ShowText(name: String) {
    Text("Hello $name")  // 无 return 语句
}

7.1.2 对比 SwiftUI

swift 复制代码

// SwiftUI
struct Greeting: View {
    let name: String
    var body: some View {
        Text("Hello \(name)!")
    }
}

// Android Compose
@Composable
fun Greeting(name: String) {
    Text("Hello $name!")
}

7.2 @Composable 的规则

7.2.1 规则1：只能在 @Composable 中调用其他 @Composable 函数

kotlin 复制代码

@Composable
fun Parent() {
    Child()  // ✅ 可以调用另一个 @Composable 函数
    regularFunction()  // ✅ 可以调用普通函数（println 等）
}

fun regularFunction() {
    // Child()  // ❌ 普通函数中不能调用 @Composable
}

核心： @Composable 函数只能在 @Composable 上下文中被调用，反过来，@Composable 函数内可以自由调用普通函数。

7.2.2 规则2：自动追踪状态

kotlin 复制代码

@Composable
fun Counter() {
    var count by remember { mutableStateOf(0) }
    // 当 count 变化时，Compose 自动重组这部分 UI
    Button(onClick = { count++ }) {
        Text("点击了 $count 次")
    }
}

第八部分：@Preview 详解

8.1 @Preview 是什么？

@Preview 允许你在不运行 app 的情况下直接在 Android Studio 中预览 UI，极大提升了开发效率。

对比 iOS：

Storyboard 的 Canvas 预览；
SwiftUI 的 #Preview 宏。

8.1.1 @Preview 的参数

kotlin 复制代码

// 基础预览
@Preview
@Composable
fun SimplePreview() {
    Text("Hello")
}

// 显示背景
@Preview(showBackground = true)
@Composable
fun WithBackgroundPreview() {
    Text("Hello")
}

// 多尺寸预览
@Preview(name = "小屏幕", widthDp = 320, heightDp = 480)
@Preview(name = "大屏幕", widthDp = 600, heightDp = 800)
@Composable
fun MultiplePreviews() {
    Text("Hello")
}

8.1.2 对比 SwiftUI

swift 复制代码

// SwiftUI #Preview (iOS 17+)
#Preview {
    Greeting(name: "iOS")
}

// Android Compose
@Preview(showBackground = true)
@Composable
fun GreetingPreview() {
    HelloKotlinTheme {
        Greeting("Android")
    }
}

第九部分：完整对比总结

9.1 概念对应总表

Android	iOS (对应概念)	说明
`MainActivity`	`UIViewController`	页面/控制器
`ComponentActivity`	`UIViewController`	现代 Activity 基类
`Application`	`AppDelegate`	应用级代理
`AndroidManifest.xml`	`Info.plist`	应用清单
`setContent {}`	`view.addSubview(...)`	设置 UI 内容
`Surface`	`UIView`	基础容器
`Modifier`	`ViewModifier`	修饰符
`@Composable`	SwiftUI 的 `View` 协议	UI 构建函数
`@Preview`	`#Preview` / `PreviewProvider`	IDE 预览
`MaterialTheme`	`UIAppearance`	全局主题
`onCreate()`	`viewDidLoad()`	创建时调用
`onStart()`	`viewWillAppear()`	即将显示
`onResume()`	`viewDidAppear()`	已经显示
`onPause()`	`viewWillDisappear()`	即将消失
`onStop()`	`viewDidDisappear()`	已经消失
`onDestroy()`	`deinit`	销毁

9.2 代码结构对比

kotlin 复制代码

// Android Compose
class MainActivity : ComponentActivity() {
    override fun onCreate(savedInstanceState: Bundle?) {
        super.onCreate(savedInstanceState)
        setContent {
            MaterialTheme {
                Surface {
                    Greeting("Android")
                }
            }
        }
    }
}

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

swift 复制代码

// iOS SwiftUI
@main
struct MyApp: App {
    var body: some Scene {
        WindowGroup {
            Greeting(name: "iOS")
        }
    }
}

struct Greeting: View {
    let name: String
    var body: some View {
        Text("Hello \(name)!")
    }
}

第十部分：练习与实践

10.1 练习：创建并跳转到第二个页面

要求：

新建一个 SecondActivity，并编写简单的 Compose UI；
在 AndroidManifest.xml 中注册该 Activity；
从 MainActivity 通过按钮跳转到 SecondActivity。

参考实现：

kotlin 复制代码

// ========== MainActivity.kt ==========
package com.example.hellokotlin

import android.content.Intent
import android.os.Bundle
import androidx.activity.ComponentActivity
import androidx.activity.compose.setContent
import androidx.compose.foundation.layout.Column
import androidx.compose.foundation.layout.padding
import androidx.compose.material3.*
import androidx.compose.runtime.Composable
import androidx.compose.ui.Modifier
import androidx.compose.ui.unit.dp

class MainActivity : ComponentActivity() {
    override fun onCreate(savedInstanceState: Bundle?) {
        super.onCreate(savedInstanceState)
        setContent {
            MaterialTheme {
                MainScreen(
                    onNavigate = {
                        // 创建 Intent，指定从当前 Activity 跳转到 SecondActivity
                        val intent = Intent(this, SecondActivity::class.java)
                        startActivity(intent)
                    }
                )
            }
        }
    }
}

@Composable
fun MainScreen(onNavigate: () -> Unit) {
    Column(modifier = Modifier.padding(16.dp)) {
        Text("第一个页面", style = MaterialTheme.typography.headlineSmall)
        Button(onClick = onNavigate) {
            Text("跳转到第二页")
        }
    }
}

kotlin 复制代码

// ========== SecondActivity.kt ==========
package com.example.hellokotlin

import android.os.Bundle
import androidx.activity.ComponentActivity
import androidx.activity.compose.setContent
import androidx.compose.material3.*

class SecondActivity : ComponentActivity() {
    override fun onCreate(savedInstanceState: Bundle?) {
        super.onCreate(savedInstanceState)
        setContent {
            MaterialTheme {
                Text("第二个页面", style = MaterialTheme.typography.headlineMedium)
            }
        }
    }
}

xml 复制代码

<!-- AndroidManifest.xml 中添加 -->
<activity
    android:name=".SecondActivity"
    android:exported="false"
    android:parentActivityName=".MainActivity" />

10.2 思考题

为什么 Android 需要 AndroidManifest.xml，而 iOS 不需要这样一个单独的文件？

因为 Android 的组件模型（Activity、Service、BroadcastReceiver、ContentProvider）必须在清单中显式声明，系统才能在运行时创建和管理它们；iOS 的组件类型相对较少，其配置分散在 Info.plist 和代码中。
Activity 和 UIViewController 的生命周期有何本质差异？

Activity 的生命周期由系统严格管理，并区分了可见和可交互的状态（onStart vs onResume）；UIViewController 的生命周期主要聚焦于视图的加载和显示，不直接处理系统级别的进程状态。
为什么 Compose 需要显式的 @Composable 注解，而 SwiftUI 不需要？

SwiftUI 的所有 View 都符合 View 协议，编译器天然知道它们是 UI 构建函数；Compose 运行在 Kotlin 之上，需要借助注解向编译器表明该函数具有特殊的 UI 构建语义，并需要专门的编译器插件支持。

希望这份详尽的解释能帮助你彻底理解 Android 应用从启动到界面呈现的全过程，以及每个核心组件背后的设计思想。如果你有任何疑问，欢迎随时继续交流！