一、引言

很多开发者初次接触鸿蒙原生开发时，会下意识地把它类比为"Android 用 Kotlin + Jetpack Compose"或"iOS 用 Swift + SwiftUI"。这个类比在表面成立，但在架构层面，鸿蒙原生开发有着本质的不同。

这不是又一套 UI 框架 + 语言组合，而是一个面向万物互联的操作系统原生开发范式。它的核心差异在于三个字：分布式。

本文将用对比的视角，深入剖析鸿蒙原生开发在架构、应用模型、跨设备能力、安全模型等方面与移动端传统开发的本质区别。

---

二、架构对比：鸿蒙 vs Android vs iOS

2.1 宏观架构

Android                      iOS                      HarmonyOS
┌──────────────────┐  ┌──────────────────┐  ┌──────────────────────┐
│   Applications    │  │   Applications    │  │   Applications (HAP) │
├──────────────────┤  ├──────────────────┤  ├──────────────────────┤
│   Java API        │  │   Cocoa Touch     │  │   ArkTS API          │
│   Framework       │  │   (UIKit/SwiftUI) │  │   System API         │
├──────────────────┤  ├──────────────────┤  ├──────────────────────┤
│   Android Runtime │  │   Core Services   │  │   ArkCompiler        │
│   (ART)           │  │                   │  │   (AOT+JIT)          │
├──────────────────┤  ├──────────────────┤  ├──────────────────────┤
│   Linux Kernel    │  │   XNU Kernel      │  │   HarmonyOS 微内核    │
└──────────────────┘  └──────────────────┘  └──────────────────────┘

2.2 关键差异维度

维度	Android	iOS	HarmonyOS
内核	Linux (宏内核)	XNU (宏内核)	鸿蒙微内核
语言	Kotlin/Java	Swift/ObjC	ArkTS (基于 TS)
UI 框架	Jetpack Compose	SwiftUI	ArkUI (声明式)
编译器	D8/R8 (JIT+AOT)	SwiftC (AOT)	ArkCompiler (AOT+JIT)
应用模型	Activity/Fragment	ViewController	Stage 模型
包格式	APK (ZIP)	IPA (ZIP)	HAP (ZIP)
分布式	❌ 无原生支持	❌ 无原生支持	✅ 系统级内置
跨设备	❌ 需三方库	❌ 需三方库	✅ 天生支持
安全模型	沙箱 + 权限	沙箱 + 权限	星盾 + 微内核 + 分级权限

---

三、Stage 应用模型：不只是 Activity 的翻版

3.1 核心差异

Android 的 Activity 和 iOS 的 ViewController 都是以页面为中心的模型，而鸿蒙的 Stage 模型 是以能力和任务为中心的模型。

Android Activity 模型：
用户操作 → Activity 启动 → 页面显示 → 返回销毁

HarmonyOS Stage 模型：
用户意图 → UIAbility 调度 → 多任务协同 → 跨设备流转

3.2 UIAbility：比 Activity 更抽象的能力单元

// UIAbility 不仅是"页面"，而是"能力入口"
export default class ShareAbility extends UIAbility {
  onCreate(want: Want) {
    // want 包含了调用方的意图和参数
    const action = want.actions;    // 要做什么
    const uri = want.uri;           // 操作对象
    const params = want.parameters; // 额外参数
  }
}

关键区别：

场景	Android	HarmonyOS
启动应用	startActivity(intent)	startAbility(want)
后台任务	Service/WorkManager	ServiceExtension + 后台任务
数据共享	ContentProvider	DataShareExtension
跨设备	需自研	want 可指定 deviceId
多端协同	不支持	系统级分布式调度

3.3 ExtensionAbility：鸿蒙独有的扩展机制

ExtensionAbility 是 Stage 模型中最有特色的设计之一，它允许应用以轻量级的方式提供后台能力：

// 后台服务
export default class MyService extends ServiceExtension {
  onRequest(want: Want, startId: number) {
    // 处理后台任务
  }
}

// 数据共享
export default class MyDataShare extends DataShareExtension {
  query(uri: string, columns: string[], predicates: DataSharePredicates) {
    // 提供数据查询
  }
}

// 自定义广播
export default class MyStaticSubscriber extends StaticSubscriberExtension {
  onReceiveEvent(event: string, data: CommonEventData) {
    // 接收系统广播
  }
}

---

四、分布式原生：Android/iOS 做不到的事

4.1 分布式不是"功能"，而是系统级能力

在 Android/iOS 上实现跨设备通信，需要：

1. 引入三方 SDK
2. 自建通信协议
3. 处理设备发现 / 配对
4. 处理网络状态变化
5. 处理数据同步冲突

在鸿蒙上，分布式是系统原生的基础设施：

┌──────────────────────────────────────────────┐
│              分布式软总线                        │
├──────────────────────────────────────────────┤
│  设备发现  │  连接管理  │  数据传输  │  安全认证 │
├──────────────────────────────────────────────┤
│  WiFi │ 蓝牙 │ 星闪 │ 以太网 │ NFC           │
└──────────────────────────────────────────────┘

4.2 分布式能力矩阵

// 1. 分布式文件系统 — 访问其他设备的文件
let file = await fs.open(
  `datashare://{deviceId}/com.example.app/data/file.txt`
);

// 2. 分布式数据对象 — 多设备数据自动同步
@Observed
class SharedData {
  count: number = 0;
  text: string = '';
}
let dataObj = distributedDataObject.create(this.context, new SharedData());
// 数据变化自动同步到所有关联设备

// 3. 分布式任务调度 — 在另一设备上执行任务
let want: Want = {
  deviceId: remoteDeviceId,  // 远程设备 ID
  bundleName: 'com.example.task',
  abilityName: 'ComputeAbility'
};
startAbility(want);

// 4. 分布式键值表 — 多设备共享存储
let kvStore = await distributedKVStore.getKVStore('app_store');
await kvStore.put('key', 'value'); // 自动同步

4.3 跨设备迁移

这是鸿蒙原生开发最独特的场景——用户正在做的事情，可以在不同设备间无缝流转：

场景：用户用手机看视频，走到客厅
┌───────┐                    ┌───────┐
│  手机  │ ─── 迁移 ────────→ │ 智慧屏 │
│       │                    │       │
│ 视频   │    进度/状态/数据    │ 视频   │
│ 播放中  │ ─── 自动同步 ────→ │ 继续播放│
└───────┘                    └───────┘

// 支持迁移的页面
@Recreatable
struct VideoPlayerPage {
  @State position: number = 0; // 自动保存和恢复

  build() {
    Video({ src: this.videoUrl })
      .onPosition((pos) => {
        this.position = pos; // 状态变化自动同步
      })
  }
}

---

五、ArkCompiler：不只是 AOT/JIT 的选择题

5.1 编译架构

ArkTS 源码
    │
    ▼
ArkCompiler TypeScript 前端
    │
    ├─→ AOT 编译 (预编译)
    │      │
    │      ▼
    │  机器码 → 直接执行 (启动快)
    │
    └─→ JIT 编译 (运行时)
           │
           ▼
       优化编译 → 热点代码 (运行快)

5.2 与 Android ART 的对比

维度	Android ART	ArkCompiler
输入语言	Java 字节码	ArkTS/TS/JS
AOT	安装时编译	构建时 + 安装时
JIT	运行时热点编译	运行时热点编译
类型系统	静态 + 动态	渐进类型 (TypeScript)
内存管理	GC (并发标记)	方舟 GC (分代 + 并发)
跨语言调用	JNI (C++)	NAPI (C/C++ 直接调用)

5.3 渐进类型的优势

ArkTS 基于 TypeScript，但它不是简单的"JS 加上类型"：

// 开发阶段 — 静态类型，IDE 智能提示
@State
count: number = 0;

// 编译阶段 — AOT 生成类型专用机器码
// number 类型 → 直接用数字指令，无需装箱拆箱

// 运行时 — 类型信息辅助 GC 优化
// 知道是 number → 快速分配和回收

对比 Android 的 Kotlin/Java：

维度	Kotlin (JVM)	ArkTS (ArkCompiler)
装箱成本	基本类型 ↔ 对象	无装箱 (类型直接映射)
元数据	运行时保留大量元数据	最小化元数据
启动时间	类加载 + 字节码验证	预编译机器码直接执行
包体积	classes.dex + 资源	更小的 HAP 包

---

六、星盾安全架构：系统级信任模型

6.1 不只是权限弹窗

Android/iOS 的安全模型是 “先授权、后使用”，鸿蒙的星盾架构是 “最小化、可追溯、系统强控”：

Android/iOS:
应用请求权限 → 用户同意 → 应用可随意访问

HarmonyOS 星盾:
用户操作 → 系统授权 → 应用只可访问本次选定的数据
           ↓
访问行为全程记录 → 可视化展示

6.2 安全访问机制

// Android 风格：声明权限，安装时/运行时授权
<uses-permission android:name="android.permission.READ_MEDIA_IMAGES" />

// HarmonyOS 风格：用户选择具体的文件
// 应用不需要声明读取所有图片的权限
// 而是通过系统 FilePicker 让用户选择
let uris = await picker.select({
  type: 'image/*',
  maxCount: 5  // 用户选几张，应用就只能访问几张
});

6.3 禁止的九类不合理权限

编号	权限类型	说明
1	读取已安装应用列表	防止应用收集安装信息
2	访问所有文件	改为文件选择器
3	读取短信/彩信	禁止后台读取
4	读取通话记录	隐私敏感数据
5	读取联系人	改为联系人选择器
6	读取日历事件	改为日历选择器
7	获取设备 IMEI/SN	防止设备追踪
8	后台启动 Activity	防止恶意弹窗
9	悬浮窗权限	系统级管控

---

七、开发范式对比：Hello World 背后

7.1 三端对比

维度	Android (Jetpack Compose)	iOS (SwiftUI)	HarmonyOS (ArkUI)
语言	Kotlin	Swift	ArkTS
入口	MainActivity.kt	App.swift	EntryAbility.ets
页面	@Composable fun	View {}	@Component struct
状态	remember { mutableStateOf() }	@State	@State
布局	Column/Row/Box	VStack/HStack/ZStack	Column/Row/Stack
列表	LazyColumn	List {}	List {} / ForEach
导航	Navigation Compose	NavigationStack	Navigation / router
构建	Gradle	Xcode Build	Hvigor
包管理	Maven Central	CocoaPods/SPM	ohpm

7.2 同一个页面，三种写法

需求：显示 “Hello”，点击按钮文字变色。

Android (Jetpack Compose):

@Composable
fun HelloPage() {
    var isRed by remember { mutableStateOf(false) }
    Column {
        Text("Hello", color = if (isRed) Color.Red else Color.Black)
        Button(onClick = { isRed = !isRed }) { Text("变色") }
    }
}

iOS (SwiftUI):

struct HelloPage: View {
    @State private var isRed = false
    var body: some View {
        VStack {
            Text("Hello")
                .foregroundColor(isRed ? .red : .black)
            Button("变色") { isRed.toggle() }
        }
    }
}

HarmonyOS (ArkUI):

@Component
struct HelloPage {
  @State isRed: boolean = false

  build() {
    Column() {
      Text('Hello')
        .fontColor(this.isRed ? Color.Red : Color.Black)
      Button('变色')
        .onClick(() => { this.isRed = !this.isRed })
    }
  }
}

架构差异的本质：

维度	Compose	SwiftUI	ArkUI
Composable 本质	函数	结构体	struct + 装饰器
状态粒度	重组范围	视图刷新	组件级差分
跨设备	不内置	不内置	系统级分布式
原生调用	JNI	C FFI	NAPI (零开销)

---

7.3 实战对比：带网络请求的列表页面

需求： 从 API 获取 GitHub 用户列表，展示用户名和头像，支持下拉刷新和加载状态。

Android (Jetpack Compose + Retrofit + ViewModel):

// 1. 数据层 — Retrofit 接口
interface GitHubApi {
    @GET("users")
    suspend fun getUsers(): List<User>
}

data class User(val login: String, val avatarUrl: String)

// 2. ViewModel — 管理状态和网络请求
class UserViewModel : ViewModel() {
    // Compose 用 StateFlow 驱动 UI 重组
    private val _uiState = MutableStateFlow<UiState<List<User>>>(UiState.Loading)
    val uiState: StateFlow<UiState<List<User>>> = _uiState

    init { fetchUsers() }

    fun fetchUsers() {
        _uiState.value = UiState.Loading
        viewModelScope.launch {
            try {
                val users = RetrofitClient.api.getUsers()
                _uiState.value = UiState.Success(users)
            } catch (e: Exception) {
                _uiState.value = UiState.Error(e.message ?: "Unknown error")
            }
        }
    }
}

// 3. UI 层 — Composable 函数
@Composable
fun UserListScreen(viewModel: UserViewModel = viewModel()) {
    val uiState by viewModel.uiState.collectAsState()

    when (val state = uiState) {
        is UiState.Loading -> CircularProgressIndicator(modifier = Modifier.fillMaxSize())
        is UiState.Error -> Text("Error: ${state.message}", color = Color.Red)
        is UiState.Success -> {
            LazyColumn {
                items(state.data) { user ->
                    UserRow(user)  // 列表项
                }
            }
        }
    }
}

@Composable
fun UserRow(user: User) {
    Row(modifier = Modifier.padding(8.dp)) {
        AsyncImage(model = user.avatarUrl, contentDescription = null,
                   modifier = Modifier.size(48.dp).clip(CircleShape))
        Spacer(modifier = Modifier.width(8.dp))
        Text(user.login, fontSize = 16.sp)
    }
}
// 关键差异：ViewModel 生命周期独立于 Composable，StateFlow 驱动重组

iOS (SwiftUI + async/await + ObservableObject):

// 1. 数据模型
struct User: Codable, Identifiable {
    let id: Int
    let login: String
    let avatarUrl: String
}

// 2. ViewModel — @MainActor 确保 UI 更新在主线程
@MainActor
class UserViewModel: ObservableObject {
    @Published var users: [User] = []
    @Published var isLoading = false
    @Published var errorMessage: String?

    func fetchUsers() async {
        isLoading = true
        errorMessage = nil
        do {
            let url = URL(string: "https://api.github.com/users")!
            let (data, _) = try await URLSession.shared.data(from: url)
            users = try JSONDecoder().decode([User].self, from: data)
        } catch {
            errorMessage = error.localizedDescription
        }
        isLoading = false
    }
}

// 3. UI 层 — SwiftUI View
struct UserListView: View {
    @StateObject private var viewModel = UserViewModel()

    var body: some View {
        Group {
            if viewModel.isLoading {
                ProgressView()
            } else if let error = viewModel.errorMessage {
                Text("Error: \(error)").foregroundColor(.red)
            } else {
                List(viewModel.users) { user in
                    UserRow(user: user)
                }
                .refreshable {  // 下拉刷新
                    await viewModel.fetchUsers()
                }
            }
        }
        .task {  // 视图出现时自动加载
            await viewModel.fetchUsers()
        }
    }
}

struct UserRow: View {
    let user: User
    var body: some View {
        HStack {
            AsyncImage(url: URL(string: user.avatarUrl)) { image in
                image.resizable().scaledToFit()
            } placeholder: {
                ProgressView()
            }
            .frame(width: 48, height: 48)
            .clipShape(Circle())
            Text(user.login).font(.body)
        }
    }
}
// 关键差异：@Published 驱动 SwiftUI 自动刷新，.task 管理异步生命周期

HarmonyOS (ArkUI + @State + http):

// 1. 数据模型
interface User {
  id: number;
  login: string;
  avatarUrl: string;
}

// 2. 页面组件 — 状态和 UI 合为一体
@Component
struct UserListPage {
  @State users: User[] = [];
  @State isLoading: boolean = false;
  @State errorMessage: string = '';

  // 网络请求方法
  async fetchUsers() {
    this.isLoading = true;
    this.errorMessage = '';
    try {
      // 使用系统 http 模块发起请求
      let response = await http.createHttp().request(
        'https://api.github.com/users',
        { method: http.RequestMethod.GET }
      );
      if (response.responseCode === 200) {
        this.users = JSON.parse(response.result as string) as User[];
      } else {
        this.errorMessage = `HTTP ${response.responseCode}`;
      }
    } catch (e) {
      this.errorMessage = (e as Error).message;
    }
    this.isLoading = false;
  }

  // 页面生命周期钩子
  aboutToAppear() {
    this.fetchUsers();
  }

  build() {
    Column() {
      if (this.isLoading) {
        LoadingProgress().width('100%').height('100%')
      } else if (this.errorMessage !== '') {
        Text('Error: ' + this.errorMessage).fontColor(Color.Red)
      } else {
        List() {
          ForEach(this.users, (user: User) => {
            ListItem() {
              UserRow({ user: user })
            }
          }, (user: User) => user.id.toString())
        }
        .refreshable({ onRefresh: () => { this.fetchUsers(); } })
      }
    }
    .width('100%')
    .height('100%')
  }
}

@Component
struct UserRow {
  @Prop user: User;  // 从父组件传入

  build() {
    Row() {
      Image(this.user.avatarUrl)
        .width(48).height(48)
        .borderRadius(24)  // 圆形裁剪
      Text(this.user.login)
        .fontSize(16)
        .margin({ left: 8 })
    }
    .padding(8)
    .width('100%')
  }
}
// 关键差异：@State 直接驱动 UI 刷新，无需 ViewModel 层；http 模块为系统内置

三端实现的关键差异总结：

维度	Android (Compose)	iOS (SwiftUI)	HarmonyOS (ArkUI)
状态管理	ViewModel + StateFlow	ObservableObject + @Published	@State 装饰器
网络请求	Retrofit (三方库)	URLSession (系统内置)	http 模块 (系统内置)
异步模型	viewModelScope.launch	async/await + .task	async/await + aboutToAppear
列表渲染	LazyColumn + items	List + 隐式 ForEach	List + ForEach
下拉刷新	需引入 pullRefresh 修饰符	.refreshable 原生支持	.refreshable 原生支持
图片加载	Coil (三方库)	AsyncImage (系统内置)	Image 直接加载 URL (系统内置)
生命周期	Composable 重组	View 结构体重建	组件级 aboutToAppear

核心洞察： ArkUI 的设计哲学更接近 SwiftUI——声明式、状态驱动、系统内置能力丰富。但 ArkUI 的 @State 装饰器比 SwiftUI 的 @Published 更简洁，且网络请求和图片加载均为系统原生支持，无需引入三方依赖。而 Compose 则更依赖 ViewModel 层做状态托管，三方库生态更成熟但集成成本更高。

八、为什么选择鸿蒙原生开发

8.1 适合的场景

场景	推荐方案	原因
纯鸿蒙应用	原生开发	最佳性能，最全能力
分布式应用	必须原生	只有原生能调用分布式 API
IoT / 全场景	原生开发	系统级设备发现和协同
安全敏感应用	原生开发	星盾架构 + 微内核安全
高帧率游戏	原生开发	方舟引擎 + NPU 调度
AI 应用	原生开发	MindSpore Lite + 端侧推理

8.2 原生 vs 跨平台的选择边界

需要分布式能力？ ─── 是 ──→ 必须原生开发
需要调用全部系统 API？ ─ 是 ──→ 原生开发
对性能有极致要求？ ──── 是 ──→ 原生开发
以上都不需要，但需要多端覆盖 ──→ 可考虑跨平台方案

---

九、总结：鸿蒙原生开发的本质

九、迁移建议与学习路径

9.1 从 Android 开发者视角迁移

思维转变	Android 旧认知	HarmonyOS 新认知
应用入口	Activity + AndroidManifest.xml	UIAbility + module.json5
页面管理	FragmentManager 管理回退栈	Navigation + NavPathStack 管理路由
状态管理	ViewModel + LiveData/StateFlow	@State + @Prop + @Link 装饰器
网络请求	Retrofit + OkHttp (三方库)	http 模块 (系统内置)
图片加载	Glide / Coil (三方库)	Image 组件直接加载 URL
数据库	Room / SQLite	@ohos.data.relationalStore (RDB)
依赖注入	Hilt / Dagger	暂无官方 DI 框架，手动管理
后台任务	WorkManager / Service	ServiceExtension + BackgroundTaskManager
跨进程通信	Binder + AIDL	Want + CommonEvent + DataShareExtension
构建工具	Gradle (Groovy/Kotlin DSL)	Hvigor (TypeScript DSL)
包管理	Maven Central / Google Maven	ohpm (OpenHarmony Package Manager)

关键思维转变：

1. 从"页面"到"能力"：不再以 Activity/Fragment 作为基本单元，而是以 UIAbility 和 ExtensionAbility 作为能力入口，系统负责调度和生命周期。
2. 从"三方库"到"系统内置"：鸿蒙系统内置了大量常用能力（网络、图片、数据库、分布式），优先使用系统 API 而非引入三方依赖。
3. 从"异步回调"到"async/await"：ArkTS 全面拥抱 async/await，告别回调地狱，代码更线性可读。
4. 从"单设备"到"多设备"：开发时就要考虑应用可能在不同设备间流转，状态管理需要支持序列化和恢复。

9.2 从 iOS 开发者视角迁移

思维转变	iOS 旧认知	HarmonyOS 新认知
应用入口	@main App + SceneDelegate	UIAbility + module.json5
页面管理	NavigationStack + NavigationLink	Navigation + NavPathStack
状态管理	@State + @Published + ObservableObject	@State + @Prop + @Link + @Observed
网络请求	URLSession (系统内置)	http 模块 (系统内置)
图片加载	AsyncImage (系统内置)	Image 组件直接加载 URL
数据持久化	CoreData / SwiftData / UserDefaults	@ohos.data.preferences + @ohos.data.relationalStore
并发模型	async/await + Task	async/await + Promise
依赖管理	Swift Package Manager / CocoaPods	ohpm
UI 框架	SwiftUI (声明式)	ArkUI (声明式)
动画	.animation() + withAnimation	.animation() + animateTo
安全区域	safeAreaInset / safeAreaPadding	expandSafeArea 属性

关键思维转变：

1. ArkUI 与 SwiftUI 高度相似：两者都是声明式、状态驱动、组件化，迁移成本相对较低。@State 装饰器用法几乎一致。
2. 生命周期不同：SwiftUI 的 onAppear/onDisappear 对应 ArkUI 的 aboutToAppear/aboutToDisappear；但 ArkUI 没有 SwiftUI 的 @SceneStorage 和 @AppStorage，需用 Preferences 替代。
3. 导航系统差异：SwiftUI 的 NavigationStack 是隐式路由，ArkUI 的 Navigation 需要显式管理 NavPathStack，更接近 UIKit 的 UINavigationController。
4. 系统 API 更丰富：鸿蒙的分布式能力、星盾安全、多设备协同是 iOS 不具备的，需要额外学习。

9.3 官方学习资源清单

入门阶段：

资源名称	链接	说明
鸿蒙开发文档（官方）	https://developer.huawei.com/consumer/cn/doc/	最权威的 API 参考和开发指南
ArkTS 语言快速入门	https://developer.huawei.com/consumer/cn/doc/harmonyos-guides/arkts-get-started	从 TypeScript 到 ArkTS 的语法速览
ArkUI 声明式开发指南	https://developer.huawei.com/consumer/cn/doc/harmonyos-guides/arkui-overview	组件、布局、动画、交互完整教程
Stage 模型开发指南	https://developer.huawei.com/consumer/cn/doc/harmonyos-guides/application-model-overview	UIAbility、ExtensionAbility 详解

进阶阶段：

资源名称	链接	说明
分布式开发指南	https://developer.huawei.com/consumer/cn/doc/harmonyos-guides/distributed-overview	分布式软总线、数据管理、任务调度
安全开发指南	https://developer.huawei.com/consumer/cn/doc/harmonyos-guides/security-overview	星盾安全、权限管理、数据加密
ArkCompiler 原理	https://developer.huawei.com/consumer/cn/doc/harmonyos-guides/arkcompiler	编译优化、性能调优
性能优化指南	https://developer.huawei.com/consumer/cn/doc/harmonyos-guides/performance-overview	启动优化、渲染优化、内存优化

实战练习：

资源名称	链接	说明
HarmonyOS Codelabs	https://developer.huawei.com/consumer/cn/codelabs/	官方手把手教程，从简单到复杂
示例应用（Sample）	https://gitee.com/openharmony/app_samples	官方开源示例项目，覆盖常见场景
开发者社区	https://developer.huawei.com/consumer/cn/forum/	问答、技术分享、最佳实践
鸿蒙生态博客	https://developer.huawei.com/consumer/cn/blogs/	官方技术博客，持续更新

推荐学习路径：

第 1 周：ArkTS 语法基础 + ArkUI 基本组件（Text、Button、Column/Row）
第 2 周：状态管理（@State、@Prop、@Link）+ 列表渲染（List + ForEach）
第 3 周：页面导航（Navigation）+ 网络请求（http 模块）
第 4 周：Stage 模型（UIAbility + ExtensionAbility）+ 生命周期
第 5 周：数据持久化（Preferences + RDB）+ 多媒体（Image、Video）
第 6 周：分布式能力入门（分布式数据对象 + 跨设备迁移）
第 7 周：安全与权限（星盾架构 + 权限申请）
第 8 周：性能优化 + 发布上架（HAP 打包 + AppGallery Connect）

建议：如果你是 SwiftUI 开发者，可以从第 1 周直接跳到第 3 周，因为声明式 UI 的概念高度相通。如果你是 Android 开发者，建议按顺序学习，重点理解 Stage 模型与 Activity 模型的差异。

鸿蒙原生开发与 Android/iOS 开发的本质区别，不在于语言或 UI 框架，而在于：

1. 内核不同 — 微内核 vs 宏内核，安全模型完全不同
2. 分布式原生 — 跨设备不是功能，而是系统基础设施
3. 应用模型不同 — Stage 模型以能力和任务为中心，而非页面
4. 编译思路不同 — ArkCompiler 的渐进类型 + AOT/JIT 混合策略
5. 安全架构不同 — 星盾架构的最小授权 + 可追溯设计

一句话总结：Android 和 iOS 是"单设备操作系统"，鸿蒙是"天生多设备的操作系统"。在鸿蒙上做原生开发，本质上是在一个以互联为默认假设的系统上构建应用。

---

参考资源：

• 华为开发者联盟 — 鸿蒙开发文档
• ArkUI 框架介绍
• ArkCompiler 介绍
• 星盾安全架构