嵌入式鸿蒙方向课件 第一部份 基础语法到分支结构与函数
鸿蒙 HarmonyOS 开发入门（一）：认识鸿蒙、环境搭建与第一次上机
系列定位：零基础 → 能独立做鸿蒙应用。本篇是系列第一篇，讲清楚三件事： ① 鸿蒙是什么、能干什么、有没有前途（含工业布局与未来场景）；② 开发环境怎么装；③ 动手跑通第一个 App。在工业及跨界智能化领域，鸿蒙系统与 PLC 的融合正成为落地亮点：传统 PLC 多局限于单机控制， 接入鸿蒙后可依托分布式能力，实现与传感器、机械臂、手持终端、云端系统的跨设备实时协同， 工人用鸿蒙平板就能现场调试多台 PLC 参数， 无需反复连接数据线；针对老旧 PLC 改造，加装鸿蒙网关即可低成本实现数据上云， 避免整体更换硬件的高额投入。此外，跨界场景同样具备吸引力，比如智能家居中基于鸿蒙编写简易梯形图逻辑， 可让家电实现工业级精准联动，如温湿度异常时自动触发地暖与新风系统协同工作；农业大棚里，鸿蒙连接 PLC 控制灌溉、通风设备， 支持手机远程调整参数，适配中小农户的轻量化智能化需求。这些场景既体现了鸿蒙对传统工业控制的升级价值， 也为跨界技术学习者提供了可直接对接市场的应用方向。
适用场景：
对于嵌入式和自动化从业者来说，鸿蒙已经成为必须掌握的 “能力放大器”。当下嵌入式开发者早已不满足于基础硬件驱动，不少人开始用嵌入式自主开发 PLC 控制器、搭建 FOC 电机驱动系统，但传统方案往往面临跨设备通信复杂、多终端协同难的问题。而鸿蒙能直接补齐这块短板，基于鸿蒙的分布式软总线，嵌入式开发的 PLC、FOC 电机可以和车间触摸屏、远程监控终端无缝连接，不用再单独开发多套通信协议；自动化从业者熟悉的梯形图、逻辑控制逻辑，也能和鸿蒙的分布式能力结合，让传统自动化设备快速升级为智能协同终端。现在不管是做嵌入式硬件开发，还是搞自动化系统集成，掌握鸿蒙都能让项目从 “单机可用” 变成 “系统智能”，大幅提升产品竞争力和市场适配度。一、开发环境准备
1.1 这是什么
鸿蒙物联网应用开发基于 HarmonyOS NEXT 系统，使用 ArkTS 语言（TypeScript 的超集）和声明式 UI 开发范式。开发者需要安装官方 IDE —— DevEco Studio。
1.2 怎么实现
下载并安装 DevEco Studio（官网：https://developer.huawei.com/consumer/cn/deveco-studio/）
配置 HarmonyOS SDK 和模拟器
创建一个新项目，选择
Empty Ability模板项目结构核心目录说明：
entry/src/main/ets/ ├── entryability/ # 入口 Ability（应用生命周期） ├── pages/ # 页面目录 │ └── Index.ets # 主页面 └── components/ # 自定义组件（自己创建） resources/ └── base/element/ # 颜色、字体、尺寸等样式资源
第一次怎么安装模拟器
右上解先点appandlyer 然后在这儿中如果是第一次会显示新建模拟器，因为我也经建好了所以才出现，pura 90
在以下先择机型就可以安装机型了！！
然后新建工程，这个时候会默认出现一个工程代的初始化代码，，，以下图
一、鸿蒙场景介绍：鸿蒙到底是什么？
1.1 一句话理解鸿蒙
鸿蒙（HarmonyOS）是华为自主研发的全场景分布式操作系统。
注意两个关键词：
-
全场景：它不是只给手机用的系统，而是手机、平板、手表、电视、车机、音箱、门锁、工业设备……一套系统跑所有设备。
-
分布式：多台设备装上鸿蒙之后，在系统底层就"互相认识"，可以像一台设备一样协同工作。手机视频通话可以一键转到智慧屏，平板可以直接调用手机的摄像头。
1.2 "1+8+N" 全场景战略
华为把鸿蒙要覆盖的设备分成三层，叫 "1+8+N"：
表格
| 层级 | 含义 | 设备举例 |
|---|---|---|
| 1 | 核心入口 | 智能手机 |
| 8 | 华为自研的八大类终端 | 平板、PC、智慧屏、手表、耳机、VR 眼镜、车机、音箱 |
| N | 生态伙伴的海量 IoT 设备 | 灯泡、门锁、摄像头、冰箱、空调、扫地机、工业传感器…… |
给学员的大白话：安卓是"给手机做的系统，后来硬搬到别的设备上"；鸿蒙是"从一开始就为所有设备一起设计的系统"。这是设计理念上的代差。
1.3 鸿蒙开发的两个方向（北向 / 南向）
学鸿蒙之前，先搞清楚你要学哪条路：
表格
| 方向 | 名称 | 做什么 | 用什么语言 | 适合谁 |
|---|---|---|---|---|
| 北向开发 | 应用开发 | 做手机/平板/手表上的 App 和元服务 | ArkTS（类似 TypeScript） | 会 JS/Java/前端的人，转行最快 |
| 南向开发 | 设备开发 | 做系统移植、驱动、硬件适配，让鸿蒙跑在某块板子上 | C/C++，OpenHarmony 源码 | 嵌入式、单片机、Linux 驱动背景的人 |
本系列教程以北向应用开发为主线，后续会出南向（驱动、编译）的专题。
二、适用范围：鸿蒙开发能干什么活？
鸿蒙开发的就业/接单场景，可以归纳为五大类：
-
消费应用开发：手机、平板上的 App（社交、电商、工具类），以及不用安装、即点即用的元服务（卡片式轻应用）。
-
政企应用迁移：大量政府、银行、国企的 App 正在做"鸿蒙原生版"重构，这是近两年最大的用人缺口。
-
智能终端配套：手表、耳机、智慧屏、车机上的配套应用与互联功能。
-
智能家居 / 物联网：基于 OpenHarmony 的设备端开发，配合 App 做控制端。
-
行业定制：教育、医疗、工业手持终端等行业的定制系统与应用。
一句话总结适用范围：只要是"带屏的智能设备"或者"需要连手机控制的设备"，就有鸿蒙开发的活。
三、未来发展：现在入场晚不晚？
直接看 2026 年华为开发者大会（HDC 2026）公布的官方数据：
-
HarmonyOS 6 终端设备数突破 6600 万，鸿蒙已成为中国第二大智能手机操作系统；
-
注册开发者超过 1100 万，应用市场可获取的应用和服务突破 40 万；
-
开源底座 OpenHarmony 依托 13 亿生态设备、1.3 万代码贡献者，已发布超过 100 个商用版本；
-
2026 年 6 月，HarmonyOS 7 开发者 Beta 正式启动：鸿蒙智能体框架升级到 2.0，方舟引擎首次搭载性能大模型，系统正式进入"Agent（智能体）时代"；
-
早在鸿蒙 6 发布时，就有超过 3 万个应用及元服务加速开发，覆盖政务、医疗、工业等近 20 个行业，行业报告显示鸿蒙生态面临百万级人才缺口。
我的判断（讲课时可以直接说）：
-
操作系统级别的生态，窗口期是 5~10 年，现在正处于"设备量已起来、人才供给跟不上"的阶段；
-
安卓/iOS 开发岗早已卷成红海，而鸿蒙原生开发岗供小于求；
-
鸿蒙从 HarmonyOS NEXT（鸿蒙 5）开始已彻底去掉 AOSP 代码，是纯自研系统——这意味着它必须重建整个应用生态，所有的 App 都要重做一遍，这就是机会本身。
四、华为在工业的布局：鸿蒙已经"下矿进厂"了
很多人以为鸿蒙只是手机系统——这是最大的误解。鸿蒙真正的下半场在工业。做嵌入式、工控方向的同学，这一节要重点看。
4.1 矿鸿（MineHarmony）：鸿蒙在工业的第一次商用
2021 年 9 月 14 日，华为煤矿军团与国家能源集团联合发布矿鸿操作系统——这是鸿蒙在工业领域的第一个商用系统。
矿鸿解决什么痛点？ 过去矿山井下的设备来自几十个厂家，操作系统有 Linux、Unix、Windows，各说各话，协议不通、数据是孤岛，想统一管控一台设备都要分别和各家厂商协调。矿鸿的做法是：
-
统一协议：制定了"鸿蒙煤炭协议（HCP）"，让井下所有设备用同一接口传输和汇聚数据——设备"同讲一种话"，数据"同走一张网"；
-
一机控全域：基于分布式软总线，一个终端就能管控井下全部设备，设备之间还能互相通信、自动预警；
-
无人化作业：配合 5G，实现巡检机器人、无人驾驶矿卡、远程操控掘进机协同作业，把矿工从高危岗位上撤下来。
五年成绩单（截至 2026 年 4 月）：矿鸿生态伙伴超过 200 家、OSV（操作系统供应商）伙伴 29 家、认证设备累计 935 款，已覆盖采煤、掘进、运输、供电、通风、排水、安全检测等煤矿核心生产场景。
落地效果有多实在？看两个真实案例：
表格
| 煤矿 | 改造效果 |
|---|---|
| 神东乌兰木伦煤矿 | 1808 台设备完成矿鸿化改造，巡检效率提升 50%、隐患排查准确率提升 80%、综合运维成本降低 18% |
| 皖北麻地梁煤矿 | 设备调试从两周缩到 1 天，单班作业人员从 13 人减到 7 人，综采面设备在线管理率从 60% 提升到 100% |
按《矿鸿生态发展白皮书 2026》的规划：未来 3~5 年生态伙伴突破 500 家、认证设备突破 2000 款、覆盖 300 座矿山，并向非煤矿山延伸。
4.2 不止矿山：一批"行业鸿蒙"正在出现
华为明确表态：鼓励各企业基于 OpenHarmony 开发面向各行各业的操作系统发行版，矿鸿只是第一个样板。目前已经在跑的就有：
-
华龙讯达 HualongOS：基于开源鸿蒙的工业操作系统，配套全国产 PLC、HMI 人机交互、SCADA 数据采集监控系统；
-
中软国际 KaihongOS：用于 15 英寸工业中控屏，IP65 防护、耐高低温，已交付多家工业机构；
-
矿鸿组态屏：厦门贝启科技的 10.1 寸工控屏，2025 年底成为业内首批通过"矿鸿认证 + OpenHarmony 兼容性"双认证的矿山终端；
-
软通动力等 OpenHarmony 核心共建者已完成 60+ 矿鸿资质认证项目，适配认证设备近 100 款。
大白话：工控屏、PLC、工业网关这些以前跑 WinCE、嵌入式 Linux 的设备，正在批量换成鸿蒙。这就是"嵌入式鸿蒙"岗位的来源。
4.3 华为的智能工业打法："工业新四化"
华为对整个工业领域的战略主张叫"工业新四化"：
表格
| 四化 | 含义 | 例子 |
|---|---|---|
| 工业装备数字化 | 给设备装上"芯片 + 操作系统 + 网络 + 边缘智能"的底座 | 鸿蒙化智能采煤机：单台设备故障率降低 40%、维护成本下降 30% |
| 工业网络全连接 | 5G + Wi-Fi 6 + TSN 融合，打造确定性的"工业高速公路" | 电子车间 AGV 小车高精度导航，控制信号微秒级时延 |
| 工业软件云化 | 软件从"买工具"变成"订服务" | 飞机翼型 AI 仿真：从 10 分钟缩到 25 秒，大幅减少风洞试验 |
| 工业数据价值化 | 数据从"沉睡资产"变"核心生产力" | 数字孪生平台"元图工坊"已覆盖矿山、能源、冶炼等 12 个行业、服务 100 多家客户 |
4.4 这对学鸿蒙的人意味着什么？
工业鸿蒙岗位 = 嵌入式功底 + 鸿蒙系统 + 工控协议的交叉技能，正好是嵌入式开发者转型的最近路径：
-
南向做设备：OpenHarmony 移植、驱动适配、矿鸿/行业发行版认证（C/C++）；
-
北向做应用：工控屏上位机、设备管控 App、巡检应用（ArkTS）；
-
集成做方案：工业网关、数据采集、边缘计算对接。
传统 PLC/单片机工程师 + 鸿蒙，就是工业数字化转型里最缺的那类人。
五、未来场景：全息操作与"一个工厂一个人"
最后把眼光放远一点。华为在《智慧园区 2030》《智能世界 2035》两份报告里，已经把鸿蒙生态的未来场景画出来了——这些不是科幻，是正在施工中的 roadmap。
5.1 全息园区：从"看屏幕"到"隔空操作"
华为《智慧园区 2030》提出十大未来场景，排在第一位的就是全息 AIOC（智能运营中心）：管理者面前不再是满墙监控屏，而是悬浮在空中的全息三维园区——楼宇、能耗、安防、设备状态全部以数字孪生的方式立体呈现，挥手就能调取、旋转、下钻任何一层数据。同列的场景还包括：超时空智慧办公、超沉浸互动、元宇宙生活、万兆高可靠生产等。
支撑这些场景的三项关键技术：
-
智能孪生：物理世界在数字空间的实时镜像（数字孪生 + 智能认知）；
-
空间交互：人机协同、沉浸体验、空间计算——手势、语音、AR 眼镜取代鼠标键盘；
-
泛在智联：多维感知 + 通感一体 + 边缘智能，海量终端低时延接入。
5.2 智能工厂：具身智能体当"生产伙伴"，人做"全局编排者"
《智能世界 2035》描绘的未来工厂里：
-
机械臂、灵巧手等具身智能体内置芯片和工业通信模组，通过边缘计算实时处理传感器数据，结合云端数字孪生持续训练，焊接、精密装配等作业模式可以分钟级切换；
-
人类的角色从"操作工"升级为"全局编排者"，出现"一个工厂一个人"的新型生产模式；
-
工程师戴上 MR 混合现实眼镜，在三维数字孪生空间里"所见即所得"地编排机器人工作流；每个智能体的操作经验通过云端实时同步，形成全球共享的工艺数据库。
5.3 鸿蒙在这些未来场景里扮演什么角色？
一句话：鸿蒙是全息世界和元宇宙的"数字地基"。
-
全息操作、AR 巡检、远程专家指导，本质都是"多台设备实时协同"——眼镜、手机、工业设备、云端之间要毫秒级同步数据，这正是分布式软总线的看家本领；
-
数字孪生要实时采集物理世界数据，前提是设备都"上网且说同一种语言"——这正是矿鸿/工业鸿蒙在干的事；
-
元宇宙的落地点不在虚拟社交，而在实体经济数字化：用鸿蒙连接真实设备，用孪生技术仿真、监控、优化。
所以学习路线很清晰：先学会鸿蒙应用开发（本系列），再往设备端、工业端延伸，你站的位置就是这条技术演进路线的起点。
六、技术特性：鸿蒙凭什么和安卓不一样？
鸿蒙的系统架构自下而上分四层：内核层 → 系统服务层 → 框架层 → 应用层。对开发者来说，重点记住下面六个特性。
4.1 一次开发，多端部署
写一套代码，系统自动适配手机、折叠屏、平板、手表、车机等不同屏幕和交互方式。靠的是 ArkUI 的响应式布局 + 一套工程多设备编译的能力。
4.2 ArkTS + ArkUI 声明式开发
-
ArkTS：鸿蒙的主力开发语言，是 TypeScript 的超集。会 JS/TS 的人一周就能上手。
-
ArkUI：声明式 UI 框架。写法是"描述界面长什么样"，而不是"一步步命令界面怎么变"，和前端 Vue/React 的思路一致。
TypeScript
// 声明式写法：数据变了，界面自动跟着变
@State count: number = 0; // 状态数据
build() {
Button(`点了 ${this.count} 次`) // 界面直接"绑定"数据
.onClick(() => {
this.count++; // 只改数据，不用手动刷新界面
})
}4.3 分布式软总线（超级终端的底座）
鸿蒙最硬核的技术。它把 WiFi、蓝牙、NFC 等不同通信方式在底层"抹平"，让多台设备之间像同一台设备内部总线一样互传数据、互调硬件。手机调平板的摄像头、手表调手机的 GPS，都是它在做支撑。
4.4 元服务（原子化服务）
不用下载安装、即点即用的轻应用，可以变成桌面卡片、负一屏服务。比如"健康码""快递查询"这种低频刚需场景，特别适合元服务。对开发者来说，这是比 App 成本更低的上架入口。
4.5 方舟引擎（Ark Compiler）
把 ArkTS/TS 代码直接编译成机器码运行（而不是边解释边执行），启动速度和流畅度是系统级优化的。HarmonyOS 7 中方舟引擎还首次引入了性能大模型做调度优化。
4.6 星盾安全（StarShield）
从源头管控的安全架构：应用必须签名上架、权限最小化、敏感数据不出端。做政企项目时，这是客户最关心的卖点。
七、开发环境搭建：安装 DevEco Studio
鸿蒙应用开发只用一款官方 IDE：DevEco Studio（基于 IntelliJ IDEA 打造，用安卓 Studio 的人会非常眼熟）。
好消息：新版 DevEco Studio 是开箱即用的，HarmonyOS SDK、Node.js、Hvigor（构建工具）、OHPM（包管理）、模拟器平台全部打包在一起，不用像早年那样逐个手动配置。
第 1 步：确认电脑配置
表格
| 项目 | Windows 要求 | macOS 要求 |
|---|---|---|
| 操作系统 | Windows 10 / 11（64 位） | macOS 11~15（X86 或 ARM） |
| 内存 | 16GB 及以上 | 8GB 及以上（建议 16GB） |
| 硬盘 | 100GB 及以上可用空间（建议 SSD） | 100GB 及以上 |
| 分辨率 | 1280×800 及以上 | 1280×800 及以上 |
⚠️ 内存小于 16G 的 Windows 电脑跑模拟器会比较吃力，这是新手最常见的卡点。
第 2 步：下载 DevEco Studio
-
打开华为开发者官网下载中心：
https://developer.huawei.com/consumer/cn/download/ -
登录华为账号（没有就先注册一个，后面真机调试也要用）；
-
选择 Windows 或 macOS 版本，下载 DevEco Studio 安装包（约 2GB 以上，耐心等待）。
【此处插入截图：官网下载页，圈出"立即下载"按钮】
第 3 步：安装（以 Windows 为例）
-
双击
deveco-studio-xxxx.exe进入安装向导； -
选择安装路径——建议纯英文、无空格的路径（例如
D:\Huawei\DevEco Studio），然后点"下一步"； -
安装选项界面勾选 DevEco Studio，一路"下一步"直到完成；
-
点 Finish 结束安装。
【此处插入截图：安装路径选择界面】
macOS 用户：直接把DevEco-Studio.app拖进"应用程序"文件夹即可。
第 4 步：首次启动配置
-
首次启动若弹出 Import DevEco Studio Settings，选择 Do not import settings（不导入旧配置）；
-
同意相关协议，等待 IDE 完成初始化；
-
SDK 已经内置在
DevEco Studio\sdk目录下，无需额外下载； -
建议登录华为账号（右上角头像），下载模拟器镜像时需要。
第 5 步：诊断环境（重要！）
在欢迎页点击 Diagnose，或在菜单栏选择 Help > Diagnostic Tools > Diagnose Development Environment，让 IDE 自动检查：电脑配置、网络连通性、依赖工具是否齐全。全部打勾 ✅ 才算环境合格，有红叉就按提示修复。
【此处插入截图：Diagnose 诊断全部通过的界面】
八、安装内置模拟器（不用买真机也能开发）
没有鸿蒙手机也能学习——DevEco Studio 内置了手机模拟器（Emulator）。
创建模拟器的步骤
-
打开菜单 Tools > Device Manager（设备管理器）；
-
登录华为账号（首次使用必须登录才能下载镜像）；
-
点击 New Emulator（新建模拟器）；
-
选择设备型号，比如 Phone（如 Mate/Pura 系列机型模板），点 Next；
-
选择系统镜像（HarmonyOS 最新 API 版本），点 下载图标 下载镜像（几个 GB，建议网速好时操作）；
-
下载完成后点 Next > Finish，模拟器就创建好了；
-
在 Device Manager 里点模拟器右侧的 ▶️ 启动按钮，稍等片刻，一个"虚拟手机"就出现在屏幕上。
【此处插入截图：Device Manager 创建模拟器的界面】
💡 提示：模拟器首次启动较慢（1~3 分钟），之后启动会快很多。如果模拟器黑屏/卡死，先检查电脑是否开启了虚拟化（BIOS 里的 VT-x/AMD-V）。
九、第一次上机：跑通你的第一个鸿蒙 App
环境装好了，现在做每个程序员入行都绕不开的事——Hello World。整个上机分四步：建项目 → 认结构 → 改代码 → 跑起来。
第 1 步：创建项目
-
在 DevEco Studio 欢迎页点 Create Project（创建项目）；
-
选择 Application（应用）→ Empty Ability（空模板），点 Next；
-
填写项目信息：
-
Project name：
HelloHarmony（项目名） -
Bundle name：
com.example.helloharmony（应用唯一标识，反域名写法） -
Save location：选一个英文路径
-
Compile SDK：选最新版本
-
Model：选 Stage（新模型，必选）
-
-
点 Finish，等待工程同步完成（右下角进度条走完）。
【此处插入截图：创建项目的配置界面】
第 2 步：认识工程目录结构
同步完成后，左侧目录重点只看这几个文件（先不用全懂）：
plain
HelloHarmony/
├── entry/ # 主模块（一个应用至少有一个 entry）
│ └── src/main/
│ ├── ets/
│ │ ├── entryability/
│ │ │ └── EntryAbility.ets # 应用入口：负责启动和加载首页
│ │ └── pages/
│ │ └── Index.ets # 首页界面 ← 我们今天就改它
│ ├── resources/ # 资源：图片、字符串、颜色
│ └── module.json5 # 模块配置：声明权限、入口信息
├── AppScope/
│ └── app.json5 # 应用全局配置：应用名、图标、版本号
└── build-profile.json5 # 工程级构建配置记忆口诀：
Index.ets 画页面，EntryAbility 管启动，module.json5 报户口，resources 放素材。第 3 步：读懂并改造首页代码
打开
entry/src/main/ets/pages/Index.ets，模板自带代码如下（注释是我加的）：TypeScript
// @Entry：告诉系统"这是入口页面"
// @Component：声明这是一个 UI 组件
@Entry
@Component
struct Index {
// @State：状态装饰器——被它标记的变量一旦变化，界面自动刷新
@State message: string = 'Hello World';
// build()：描述这个页面长什么样（声明式 UI 的核心方法）
build() {
// RelativeContainer：相对布局容器（子元素可以互相参照定位）
RelativeContainer() {
Text(this.message) // 文本组件，显示 message 的内容
.id('HelloWorld') // 给组件起个 id，方便定位参照
.fontSize($r('app.float.page_text_font_size')) // 字号（引用资源）
.fontWeight(FontWeight.Bold) // 加粗
.alignRules({ // 对齐规则：水平居中 + 垂直居中
center: { anchor: '__container__', align: VerticalAlign.Center },
middle: { anchor: '__container__', align: HorizontalAlign.Center }
})
}
.height('100%') // 容器高度占满全屏
.width('100%') // 容器宽度占满全屏
}
}现在把它改成一个可以点击的计数器，体验一下"状态驱动界面"：
TypeScript
@Entry
@Component
struct Index {
@State message: string = 'Hello HarmonyOS'; // 显示的文本
@State count: number = 0; // 计数器
build() {
Column({ space: 20 }) { // 纵向排列，子组件间距 20
Text(this.message)
.fontSize(28)
.fontWeight(FontWeight.Bold)
Text(`你已经点了 ${this.count} 次`) // 模板字符串，嵌入变量
.fontSize(20)
.fontColor(Color.Gray)
Button('点我 +1') // 按钮组件
.width(160)
.height(48)
.onClick(() => { // 点击事件：只改数据，界面自动刷新
this.count++;
})
}
.justifyContent(FlexAlign.Center) // 纵向居中对齐
.height('100%')
.width('100%')
}
}这段代码的核心思想（一定要理解）： 你从头到尾没有写过一句"刷新界面"的代码。你只是把
count 改成 count + 1，因为 count 被 @State 标记了，框架发现数据变了，就自动把显示它的 Text 重画一遍。这就是声明式 UI：程序员管数据，框架管界面。第 4 步：运行到模拟器
-
确认模拟器已启动（Tools > Device Manager 里 ▶️ 启动）；
-
点 DevEco Studio 右上角的绿色 ▶️ Run 按钮（或按 Shift+F10）；
-
选择你的模拟器设备，等待编译安装；
-
模拟器里 App 自动打开：显示"Hello HarmonyOS"，点按钮，数字 +1。🎉
【此处插入截图：模拟器中运行计数器 App 的效果图】
✅ 到这里，你已经完成了鸿蒙开发的"Hello World 闭环"：装环境 → 建项目 → 写页面 → 跑起来。后面所有学习都是在这个闭环上叠加知识。
十、本篇总结
关键知识点回顾
表格
| 问题 | 答案 |
|---|---|
| 鸿蒙是什么？ | 华为自研的全场景分布式操作系统 |
| 能干什么？ | 手机/平板/穿戴/车机/IoT 应用与设备开发（北向 ArkTS、南向 C/C++） |
| 有没有前途？ | 6600 万+设备、1100 万开发者、百万级人才缺口，红利期进行中 |
| 工业上有什么布局？ | 矿鸿已覆盖煤矿核心生产场景（200+伙伴、935款认证设备），华龙OS、KaihongOS 等行业发行版跟进，"工业新四化"全面推进 |
| 未来场景什么样？ | 全息 AIOC 园区、MR 数字孪生编排、具身智能体进厂、"一个工厂一个人"，鸿蒙是这一切的数字地基 |
| 核心技术？ | 一次开发多端部署、ArkTS/ArkUI 声明式 UI、分布式软总线、元服务、方舟引擎、星盾安全 |
| 开发工具？ | DevEco Studio（开箱即用，SDK 内置） |
| 没真机怎么办？ | 内置模拟器 Emulator |
记住这 10 个关键字
全场景、分布式、矿鸿、工业新四化、数字孪生、ArkTS、ArkUI、@State、一次开发多端部署、DevEco Studio
第二部份，基础语法
第二部份，基础语法
鸿蒙开发 ArkTS 基础语法完全指南
适用场景：HarmonyOS / OpenHarmony 应用开发入门
目标读者：有 C/Java/JavaScript 基础，想快速上手 ArkTS 的开发者
阅读建议：每看完一节，自己动手敲一遍代码，再进入下一节
一、ArkTS 是什么
ArkTS 是鸿蒙生态主推的开发语言，它在 TypeScript 基础上做了增强和约束：
表格
| 特性 | 说明 |
|---|---|
| 静态类型 | 变量必须先声明类型，编译期就能发现错误 |
| 严格模式 | 禁止 any 滥用，提升代码健壮性 |
| 声明式 UI | 专为 ArkUI 框架设计，语法更贴近鸿蒙开发习惯 |
| 兼容 TS/JS | 大部分 TypeScript 语法可直接使用 |
一句话总结：ArkTS = TypeScript 的超集 + 鸿蒙开发规范。
二、变量定义：let、const、var
2.1 三种声明方式对比 常量不可变
TypeScript
// 1. let：块级作用域，可重新赋值（推荐默认使用） let userName: string = "张三" userName = "李四" // ✅ 允许 // 2. const：常量，声明时必须初始化，不可重新赋值 const PI: number = 3.14159 // PI = 3.14 // ❌ 报错：常量不能修改 // 3. var：函数作用域，存在变量提升（ArkTS 中不推荐，建议避免） var oldStyle: number = 100
2.2 命名规范（ArkTS 官方推荐）
TypeScript
// ✅ 正确：小驼峰，语义清晰 let userAge: number = 25 let isLogin: boolean = true let productList: string[] = [] // ❌ 错误：无意义命名、中文拼音、下划线开头 // let a = 10 // let mingzi = "老王" // let _private = 0 // ArkTS 不推荐下划线开头
本节总结
关键八字：let可变，const常量，拒绝var。
三、数据类型：ArkTS 的类型系统
3.1 基础类型（Primitive Types）
TypeScript
// 1. 数字类型：number（包含整数和浮点数）
let age: number = 25
let price: number = 19.99
// 2. 字符串类型：string（单引号、双引号、模板字符串均可）
let userName: string = "鸿蒙开发者"
let greeting: string = `你好，${userName}！` // 模板字符串，支持变量插值
// 3. 布尔类型：boolean
let isOnline: boolean = true
let hasPermission: boolean = false
// 4. 空类型：null 和 undefined
let emptyValue: null = null // 表示"空值"
let notAssigned: undefined = undefined // 表示"未定义"
// 5. 联合类型：一个变量可以是多种类型之一
let userId: string | number = "U1001" // 可以是字符串
userId = 1001 // 也可以是数字
// userId = true // ❌ 报错：只能是 string 或 number
3.2 特殊类型
TypeScript
// 1. 枚举类型 enum：用于定义一组有名字的常量
enum Color {
RED, // 默认值为 0
GREEN, // 默认值为 1
BLUE // 默认值为 2
}
let myColor: Color = Color.RED
// 2. 任意类型 any（ArkTS 中强烈不推荐，会失去类型保护）
let flexible: any = 10
flexible = "hello" // 不会报错，但失去了类型检查
// 3. 未知类型 unknown（比 any 安全，使用前必须类型断言）
let inputData: unknown = "100"
// let len = inputData.length // ❌ 报错：unknown 类型不能直接调用属性
if (typeof inputData === "string") {
let len = inputData.length // ✅ 类型收窄后可以使用
}
本节总结
关键八字：先声明类型，再赋值使用；联合灵活，any慎用。
四、运算符与条件判断
4.1 常用运算符
TypeScript
let a: number = 10 let b: number = 3 // 算术运算符 let sum: number = a + b // 13 let diff: number = a - b // 7 let product: number = a * b // 30 let quotient: number = a / b // 3.333... let remainder: number = a % b // 1 取模（求余数） // 比较运算符（结果都是 boolean） let isEqual: boolean = (a === b) // false，严格相等（推荐） let isNotEqual: boolean = (a !== b) // true，严格不相等 let isGreater: boolean = (a > b) // true let isLessOrEqual: boolean = (a <= b) // false // 逻辑运算符 let condition1: boolean = true let condition2: boolean = false let andResult: boolean = condition1 && condition2 // false，逻辑与（两边都真才真） let orResult: boolean = condition1 || condition2 // true，逻辑或（一边为真就真） let notResult: boolean = !condition1 // false，逻辑非（取反）
4.2 if / else if / else 条件判断
TypeScript
let score: number = 85
// 单分支判断
if (score >= 90) {
console.log("优秀")
} else if (score >= 80) {
// 走到这里，因为 85 >= 80 且 85 < 90
console.log("良好")
} else if (score >= 60) {
console.log("及格")
} else {
console.log("不及格")
}
// 多条件组合判断
let isLogin: boolean = true
let isVip: boolean = true
if (isLogin && isVip) {
console.log("欢迎 VIP 用户")
} else if (isLogin && !isVip) {
console.log("普通用户，请开通 VIP")
} else {
console.log("请先登录")
}
4.3 三元运算符（简化版 if-else）
TypeScript
let age: number = 20 // 语法：条件 ? 条件为真时的值 : 条件为假时的值 let status: string = age >= 18 ? "成年人" : "未成年人" console.log(status) // 输出：成年人 // 嵌套三元（不建议超过两层，影响可读性） let score: number = 75 let level: string = score >= 90 ? "A" : (score >= 60 ? "B" : "C")
4.4 switch 多分支选择
TypeScript
let day: number = 3
let dayName: string
switch (day) {
case 1:
dayName = "星期一"
break // 跳出 switch，不再执行后续 case
case 2:
dayName = "星期二"
break
case 3:
dayName = "星期三" // 匹配到这里
break
case 4:
case 5:
dayName = "周四或周五"
break
default:
dayName = "周末"
break
}
console.log(dayName) // 输出：星期三
本节总结
关键八字：if多分支，switch等值判，三目简写。
五、循环结构：重复执行的艺术
5.1 for 循环（最常用，知道次数时用）
TypeScript
// 基础 for 循环：打印 0 到 4
// 语法：for (初始化; 条件判断; 迭代操作)
for (let i: number = 0; i < 5; i++) {
console.log(`当前索引：${i}`)
}
// 输出：0, 1, 2, 3, 4
// 计算 1 到 100 的累加和
let total: number = 0
for (let i: number = 1; i <= 100; i++) {
total += i // 等价于 total = total + i
}
console.log(`1到100的和：${total}`) // 5050
5.2 while 循环（不知道次数，满足条件就执行）
TypeScript
// 基础 while：只要条件为真，就一直循环
let count: number = 0
while (count < 5) {
console.log(`while 循环第 ${count + 1} 次`)
count++ // 别忘了自增，否则会死循环
}
// do...while：先执行一次，再判断条件（至少执行一次）
let num: number = 0
do {
console.log("do...while 至少执行一次")
num++
} while (num < 0) // 条件为假，但上面已经执行过一次了
5.3 for...of 循环（遍历数组/字符串，最简洁）
TypeScript
let fruits: string[] = ["苹果", "香蕉", "橙子"]
// 直接拿到数组的每一个值
for (let fruit of fruits) {
console.log(fruit)
}
// 输出：苹果, 香蕉, 橙子
// 遍历字符串
let message: string = "Harmony"
for (let char of message) {
console.log(char) // 逐个输出：H, a, r, m, o, n, y
}
5.4 循环控制：break 与 continue
TypeScript
// break：立即终止整个循环
for (let i: number = 0; i < 10; i++) {
if (i === 5) {
break // 遇到 5，直接跳出循环，后续不再执行
}
console.log(i) // 输出：0, 1, 2, 3, 4
}
// continue：跳过当前这一次，继续下一次循环
for (let i: number = 0; i < 5; i++) {
if (i === 2) {
continue // 跳过 i=2，不执行下面的 console
}
console.log(i) // 输出：0, 1, 3, 4
}
本节总结
关键八字：for知次数，while看条件，of遍历爽，break跳出。
六、函数定义：代码的复用单元
6.1 普通函数声明
TypeScript
// 语法：function 函数名(参数: 类型): 返回值类型 { 函数体 }
// 示例1：无参数，无返回值（返回值类型为 void）
function sayHello(): void {
console.log("你好，鸿蒙！")
}
sayHello() // 调用函数
// 示例2：有参数，有返回值
function add(a: number, b: number): number {
// a 和 b 是形参（形式参数），调用时传入的是实参（实际参数）
let result: number = a + b
return result // return 把结果抛出去
}
let sum: number = add(10, 20) // sum = 30
console.log(sum)
6.2 可选参数与默认参数
TypeScript
// 可选参数：用 ? 标记，调用时可传可不传
function greetUser(name: string, greeting?: string): void {
// 如果 greeting 没传，给个默认值
let msg: string = greeting || "你好"
console.log(`${msg}，${name}！`)
}
greetUser("张三") // 输出：你好，张三！
greetUser("李四", "早上好") // 输出：早上好，李四！
// 默认参数：直接在参数列表里给默认值（更推荐）
function createUser(name: string, age: number = 18): string {
return `用户${name}，年龄${age}`
}
console.log(createUser("王五")) // 用户王五，年龄18
console.log(createUser("赵六", 25)) // 用户赵六，年龄25
6.3 剩余参数（接收不定个数）
TypeScript
// ...numbers 表示接收任意个数的 number 类型参数，内部当作数组处理
function sumAll(...numbers: number[]): number {
let total: number = 0
for (let num of numbers) {
total += num
}
return total
}
console.log(sumAll(1, 2, 3)) // 6
console.log(sumAll(10, 20)) // 30
console.log(sumAll()) // 0
本节总结
关键八字：参数定类型，return 抛结果，可选加?，默认直接给。
七、箭头函数：更简洁的函数写法
7.1 基本语法
TypeScript
// 普通函数写法
function addNormal(a: number, b: number): number {
return a + b
}
// 箭头函数写法：把 function 换成 =>，更简洁
const addArrow = (a: number, b: number): number => {
return a + b
}
// 如果函数体只有一行 return，可以进一步简写（省略 {} 和 return）
const addSimple = (a: number, b: number): number => a + b
// 如果只有一个参数，小括号也可以省略
const square = (x: number): number => x * x
console.log(addArrow(2, 3)) // 5
console.log(addSimple(2, 3)) // 5
console.log(square(4)) // 16
7.2 箭头函数在回调中的使用（高频场景）
TypeScript
let numbers: number[] = [1, 2, 3, 4, 5]
// 用箭头函数作为 forEach 的回调
numbers.forEach((item: number, index: number) => {
console.log(`索引${index}，值${item}`)
})
// 用箭头函数作为 filter 的回调：筛选出偶数
let evens: number[] = numbers.filter((num: number) => num % 2 === 0)
console.log(evens) // [2, 4]
// 用箭头函数作为 map 的回调：每个数乘以 2
let doubled: number[] = numbers.map((num: number) => num * 2)
console.log(doubled) // [2, 4, 6, 8, 10]
本节总结
关键八字：=>替function，单行省return，回调最顺手。
八、this 指向：箭头函数与普通函数的区别
8.1 普通函数的 this：调用时决定
TypeScript
class Person {
name: string = "张三"
// 普通方法
sayNormal() {
console.log("普通方法里的 this.name：" + this.name)
}
// 普通函数作为回调，this 会丢失
delayedSpeak() {
setTimeout(function() {
// ❌ 这里的 this 指向 setTimeout 的调用者（通常是 window 或 undefined），不是 Person
// console.log(this.name) // 报错或 undefined
console.log("普通函数回调里，this 丢失了")
}, 100)
}
}
8.2 箭头函数的 this：定义时决定（继承外层）
TypeScript
class Person {
name: string = "张三"
// 箭头函数作为回调，this 继承外层
delayedSpeakArrow() {
setTimeout(() => {
// ✅ 箭头函数没有自己的 this，它继承自外层 delayedSpeakArrow 的 this
// 而外层方法的 this 指向 Person 实例
console.log("箭头函数回调里，this.name：" + this.name) // 输出：张三
}, 100)
}
}
let p = new Person()
p.delayedSpeakArrow()
8.3 开发建议
TypeScript
// 在鸿蒙 ArkTS 开发中，组件内的事件回调强烈建议用箭头函数
// 这样可以确保 this 指向组件实例，方便访问组件的状态和方法
@Entry
@Component
struct MyPage {
@State message: string = "鸿蒙页面"
// ✅ 正确：箭头函数，this 指向 MyPage 组件
onButtonClick = () => {
console.log(this.message) // 可以正常访问组件状态
}
build() {
Button("点我")
.onClick(this.onButtonClick) // 安全传递
}
}
本节总结
关键八字：普通看调用，箭头看定义，回调用箭头，this不丢失。
九、数组操作：数据的集合管理
9.1 数组的定义与基本操作
TypeScript
// 1. 声明数组：类型 + [] let scores: number[] = [85, 92, 78, 90, 88] // 2. 泛型写法（效果一样，ArkTS 中两种都可以） let names: Array<string> = ["张三", "李四", "王五"] // 3. 访问元素：通过索引（从 0 开始） console.log(scores[0]) // 85，第一个元素 console.log(scores[2]) // 78，第三个元素 // 4. 修改元素 scores[1] = 95 console.log(scores) // [85, 95, 78, 90, 88] // 5. 获取数组长度 console.log(scores.length) // 5
9.2 数组的增删改查方法
TypeScript
let fruits: string[] = ["苹果", "香蕉"]
// 1. 在末尾添加：push
fruits.push("橙子") // ["苹果", "香蕉", "橙子"]
// 2. 在开头添加：unshift
fruits.unshift("葡萄") // ["葡萄", "苹果", "香蕉", "橙子"]
// 3. 删除末尾：pop
let last: string | undefined = fruits.pop() // "橙子"被删除，last = "橙子"
// 4. 删除开头：shift
let first: string | undefined = fruits.shift() // "葡萄"被删除，first = "葡萄"
// 5. 指定位置删除/插入：splice(起始索引, 删除个数, 插入元素...)
let colors: string[] = ["红", "黄", "蓝", "绿"]
colors.splice(1, 2) // 从索引1开始删2个：["红", "绿"]
colors.splice(1, 0, "紫") // 在索引1插入"紫"：["红", "紫", "绿"]
// 6. 查找索引：indexOf
let index: number = fruits.indexOf("香蕉") // 返回索引，找不到返回 -1
// 7. 判断是否包含：includes
let hasApple: boolean = fruits.includes("苹果") // true
9.3 数组的高阶方法（函数式编程）
TypeScript
let numbers: number[] = [1, 2, 3, 4, 5]
// 1. forEach：遍历数组，无返回值
numbers.forEach((num: number) => {
console.log(num * 2)
})
// 2. map：映射，每个元素处理后返回新数组（原数组不变）
let doubled: number[] = numbers.map((num: number) => num * 2)
// doubled = [2, 4, 6, 8, 10]
// 3. filter：过滤，返回满足条件的元素组成的新数组
let evens: number[] = numbers.filter((num: number) => num % 2 === 0)
// evens = [2, 4]
// 4. find：查找第一个满足条件的元素
let firstOver3: number | undefined = numbers.find((num: number) => num > 3)
// firstOver3 = 4
// 5. reduce：归约，把数组汇总成一个值
let sum: number = numbers.reduce((acc: number, curr: number) => acc + curr, 0)
// acc 是累加器，curr 是当前元素，0 是初始值
// sum = 15
// 6. sort：排序（会改变原数组！）
let unsorted: number[] = [3, 1, 4, 1, 5]
unsorted.sort((a: number, b: number) => a - b) // 升序：[1, 1, 3, 4, 5]
// 如果是字符串排序，直接用 unsorted.sort()
9.4 多维数组
TypeScript
// 二维数组：数组的数组
let matrix: number[][] = [
[1, 2, 3],
[4, 5, 6],
[7, 8, 9]
]
console.log(matrix[1][2]) // 6，第2行第3列
// 遍历二维数组
for (let row of matrix) {
for (let item of row) {
console.log(item)
}
}
本节总结
关键八字：push尾加，pop尾删，map映射，filter筛选。
十、ArkTS 语言特性进阶
10.1 类型推断（Type Inference）
TypeScript
// ArkTS 可以根据赋值自动推断类型，不用每次都写类型注解
let autoNum = 100 // 自动推断为 number
let autoStr = "hello" // 自动推断为 string
let autoFlag = true // 自动推断为 boolean
// 但建议复杂场景显式声明，增强可读性
let userInfo: { name: string; age: number } = {
name: "张三",
age: 20
}
10.2 接口 interface（定义对象结构）
TypeScript
// 定义一个接口：描述对象应该长什么样
interface User {
name: string
age: number
isVip?: boolean // ? 表示可选属性
}
// 使用接口约束对象
let user1: User = {
name: "李四",
age: 25
}
// 函数参数也可以用接口约束
function printUserInfo(user: User): void {
console.log(`姓名：${user.name}，年龄：${user.age}`)
}
printUserInfo(user1)
10.3 类型别名 type（给类型起别名）
TypeScript
// 用 type 给复杂类型起个短名字
type ID = string | number // ID 可以是字符串或数字
type Point = { x: number; y: number }
let userId: ID = "U1001"
let origin: Point = { x: 0, y: 0 }
10.4 泛型 Generic（让函数/类支持多种类型）
TypeScript
// 泛型函数：T 是占位符，调用时传入具体类型
function identity<T>(arg: T): T {
return arg
}
// 调用时指定类型
let numResult: number = identity<number>(100)
let strResult: string = identity<string>("hello")
// 泛型也可以用于接口
interface ResponseData<T> {
code: number
message: string
data: T // data 的类型由调用时决定
}
// 使用
let userResponse: ResponseData<User> = {
code: 200,
message: "成功",
data: { name: "王五", age: 30 }
}
本节总结
关键八字：interface定结构，type起别名，泛型T占位，代码更通用。
十一、完整综合案例：学生成绩管理系统
把上面的语法串起来，写一个完整的小例子：
TypeScript
// 定义学生接口
interface Student {
id: number
name: string
scores: number[] // 多门成绩
}
// 创建学生数据
let students: Student[] = [
{ id: 1, name: "张三", scores: [85, 90, 78] },
{ id: 2, name: "李四", scores: [92, 88, 95] },
{ id: 3, name: "王五", scores: [60, 65, 70] }
]
// 计算每个学生的平均分
function getAverage(scores: number[]): number {
let sum: number = scores.reduce((a: number, b: number) => a + b, 0)
return sum / scores.length
}
// 筛选出优秀学生（平均分 >= 80）
let excellentStudents: Student[] = students.filter((stu: Student) => {
let avg: number = getAverage(stu.scores)
return avg >= 80
})
// 输出结果
excellentStudents.forEach((stu: Student) => {
let avg: number = getAverage(stu.scores)
console.log(`${stu.name} 的平均分是 ${avg.toFixed(2)}，被评为优秀学生`)
})
// 输出：
// 张三 的平均分是 84.33，被评为优秀学生
// 李四 的平均分是 91.67，被评为优秀学生
十二、全文总结速查表
表格
| 知识点 | 关键记忆 |
|---|---|
| 变量声明 | let 可变，const 常量，不用 var |
| 基础类型 | number string boolean null undefined |
| 条件判断 | if/else 通用，switch 等值，?: 简写 |
| 循环结构 | for 知次数，while 看条件，for...of 遍历 |
| 函数定义 | 参数标类型，return 返回值，可选加 ? |
| 箭头函数 | => 替 function，回调场景最常用 |
| this 指向 | 普通看调用，箭头看定义，回调用箭头防丢失 |
| 数组操作 | push/pop 首尾，map/filter 函数式 |
| 接口泛型 | interface 定结构，T 泛型占位复用 |
下一步学习建议：掌握本文语法后，还需要了解一下常用工具库，比如日期，字符，正则，以后建议才能进入 ArkUI 声明式 UI 开发，学习@State、@Component、build()等鸿蒙页面开发核心概念，把数据和页面绑定起来，先不用了解多线程，异步，面向对象，先将业务玩起来再来学细节，不要一缀而就，就是不用一开始就大量细节。
鸿蒙开发 ArkTS 进阶语法指南：类、模块、装饰器与工具库
前置要求：已掌握变量、类型、函数、循环、数组等基础语法
目标：理解面向对象编程、组件化开发、模块化组织代码的核心能力
一、对象与类（Class）：面向对象编程
1.1 类的定义与实例化
TypeScript// 定义一个类：类是对象的模板，描述一类事物共有的属性和行为 class Student { // 成员属性（实例变量）：每个对象独立拥有一份 name: string age: number // 构造函数：new 的时候自动调用，用于初始化对象 constructor(name: string, age: number) { this.name = name // this 指向当前创建的实例 this.age = age } // 成员方法：描述对象能做什么 introduce(): string { return `大家好，我是${this.name}，今年${this.age}岁` } } // 实例化：根据类创建具体对象 let stu1: Student = new Student("张三", 20) let stu2: Student = new Student("李四", 22) console.log(stu1.introduce()) // 大家好，我是张三，今年20岁 console.log(stu2.introduce()) // 大家好，我是李四，今年22岁1.2 访问修饰符：控制权限
TypeScriptclass BankAccount { // public：公开的，任何地方都能访问（默认就是 public，可省略） public owner: string = "张三" // private：私有的，只能在类内部访问，外部不能直接读写 private _balance: number = 1000 // protected：受保护的，类内部和子类可以访问，外部不行 protected accountType: string = "储蓄卡" // 类内部的方法可以访问 private 和 protected getBalance(): number { return this._balance // ✅ 内部访问 private 属性 } deposit(amount: number): void { if (amount > 0) { this._balance += amount } } } let myAccount: BankAccount = new BankAccount() console.log(myAccount.owner) // ✅ public 可以访问 console.log(myAccount.getBalance()) // ✅ 通过公开方法间接访问私有属性 // console.log(myAccount._balance) // ❌ 报错：private 属性外部不可访问1.3 Getter 与 Setter：属性的安全读写
TypeScriptclass Product { private _price: number = 0 // getter：像属性一样读取，但内部可以执行逻辑 get price(): number { return this._price } // setter：像属性一样赋值，但内部可以校验 set price(value: number) { if (value < 0) { console.log("价格不能为负数") this._price = 0 } else { this._price = value } } } let phone: Product = new Product() phone.price = 2999 // 调用 setter console.log(phone.price) // 调用 getter，输出 2999 phone.price = -100 // 调用 setter，触发校验，输出"价格不能为负数" console.log(phone.price) // 输出 01.4 静态成员 static：属于类本身，不属于实例
TypeScriptclass MathTool { // static 属性：所有实例共享，通过类名直接访问 static PI: number = 3.14159 // static 方法：工具函数，不需要创建对象就能用 static add(a: number, b: number): number { return a + b } static max(a: number, b: number): number { return a > b ? a : b } } // 不需要 new，直接通过类名调用 console.log(MathTool.PI) // 3.14159 console.log(MathTool.add(2, 3)) // 5 console.log(MathTool.max(10, 20)) // 201.5 继承 extends：代码复用，子类扩展父类
TypeScript// 父类：定义通用属性和方法 class Animal { name: string constructor(name: string) { this.name = name } move(): void { console.log(`${this.name}在移动`) } } // 子类：继承父类，拥有父类所有内容，同时可以扩展自己的特性 class Dog extends Animal { breed: string // 子类新增属性 constructor(name: string, breed: string) { // super() 必须放在子类构造函数第一行，调用父类构造器 super(name) this.breed = breed } // 子类重写（override）父类方法 move(): void { console.log(`${this.name}在奔跑`) } // 子类新增方法 bark(): void { console.log(`${this.name}：汪汪汪！`) } } let myDog: Dog = new Dog("旺财", "金毛") myDog.move() // 旺财在奔跑（调用子类重写的方法） myDog.bark() // 旺财：汪汪汪！1.6 抽象类 abstract（进阶）
TypeScript// abstract 类：不能直接 new，只能被继承，强制子类实现某些方法 abstract class Shape { abstract getArea(): number // 抽象方法：只有声明，没有实现 printArea(): void { console.log(`面积是：${this.getArea()}`) } } class Circle extends Shape { radius: number constructor(radius: number) { super() // 抽象类也有构造器，需要调用 this.radius = radius } // 必须实现父类的抽象方法，否则报错 getArea(): number { return MathTool.PI * this.radius * this.radius } } let c: Circle = new Circle(5) c.printArea() // 面积是：78.53975本节总结
关键八字：class是模板，new造对象，extends继承，static属类。
二、模块导入导出：代码的模块化组织
2.1 导出 export：把代码暴露出去
TypeScript// 文件：utils/Calculator.ts // 1. 命名导出：可以导出多个，导入时要用相同名字 export function add(a: number, b: number): number { return a + b } export function subtract(a: number, b: number): number { return a - b } // 2. 导出变量/常量/类 export const VERSION: string = "1.0.0" export class Calculator { multiply(a: number, b: number): number { return a * b } } // 3. 默认导出（default）：一个文件只能有一个，导入时可以起任意名字 export default function sayHello(): void { console.log("欢迎使用工具库") }2.2 导入 import：使用其他文件的代码
TypeScript// 文件：pages/Index.ets // 1. 导入默认导出：名字可以自定义 import welcome from '../utils/Calculator' // 2. 导入命名导出：名字必须和导出时一致，用花括号 import { add, subtract, VERSION, Calculator } from '../utils/Calculator' // 3. 导入并重命名（解决命名冲突） import { add as addFunc } from '../utils/Calculator' // 4. 批量导入所有内容到一个命名空间 import * as Calc from '../utils/Calculator' // 使用 welcome() // 调用默认导出 console.log(add(1, 2)) // 3 console.log(VERSION) // 1.0.0 let calc: Calculator = new Calculator() console.log(calc.multiply(3, 4)) // 12 console.log(Calc.subtract(10, 5)) // 52.3 鸿蒙系统模块导入（@ohos 命名空间）
TypeScript// 鸿蒙系统提供了大量 @ohos.xxx 模块，用于访问系统能力 // 页面路由跳转 import router from '@ohos.router' // 弹窗提示 import promptAction from '@ohos.promptAction' // 网络请求 import http from '@ohos.net.http' // 数据存储 import preferences from '@ohos.data.preferences' // 使用示例：页面跳转 function goToDetail(): void { router.pushUrl({ url: 'pages/DetailPage' }) } // 使用示例：弹出提示 function showToast(): void { promptAction.showToast({ message: "操作成功", duration: 2000 // 毫秒 }) }本节总结
关键八字：export暴露，import引入，default随意，@ohos系统库。
三、装饰器（Decorator）：鸿蒙开发的核心魔法
装饰器是 ArkTS 的灵魂，它通过@符号给类、方法、属性添加特殊能力。3.1 页面与组件装饰器
TypeScript// @Entry：标记这是一个页面的入口，必须有且只有一个 // @Component：标记这是一个自定义组件 @Entry @Component struct IndexPage { build() { Column() { Text("这是一个页面") .fontSize(20) } .width('100%') .height('100%') } }3.2 状态管理装饰器：数据驱动 UI
TypeScript@Entry @Component struct StateDemo { // @State：组件内部状态，数据变化会自动刷新 UI // 只能在组件内部使用，不能跨组件传递 @State message: string = "你好鸿蒙" @State count: number = 0 build() { Column() { Text(this.message) .fontSize(20) Button("点击+1") .onClick(() => { // 修改 @State 变量，页面会自动重新渲染 this.count++ this.message = `当前点击了 ${this.count} 次` }) } } }3.3 父子组件通信装饰器
TypeScript// 子组件：接收父组件传进来的数据 @Component struct ChildComp { // @Prop：单向同步，父变子变，子变父不变 // 子组件可以修改，但不会影响父组件 @Prop title: string // @Link：双向同步，父子互相影响 // 必须用 $ 符号传递，且不能初始化默认值 @Link isShow: boolean build() { Column() { Text(this.title) Button("切换显示") .onClick(() => { this.isShow = !this.isShow // 双向同步会修改父组件的值 }) } } } // 父组件 @Entry @Component struct ParentComp { @State parentTitle: string = "父组件标题" @State showDialog: boolean = false build() { Column() { // 传 @Prop：直接传值 ChildComp({ title: this.parentTitle }) // 传 @Link：必须用 $ 符号绑定 ChildComp({ title: this.parentTitle, isShow: $showDialog }) } } }3.4 跨层级状态共享
TypeScript// @Provide / @Consume：跨越多层组件直接共享状态 // 避免了层层传递的麻烦（爷爷 → 爸爸 → 儿子） @Entry @Component struct GrandParent { // @Provide：提供状态，后代组件都可以用 @Consume 接收 @Provide("themeColor") theme: string = "#007DFF" @Provide("userInfo") user: {name: string, age: number} = { name: "张三", age: 20 } build() { Column() { ParentLevel() } } } @Component struct ParentLevel { build() { ChildLevel() // 中间层不需要传递任何参数 } } @Component struct ChildLevel { // @Consume：通过相同的 key 找到祖先的 @Provide @Consume("themeColor") theme: string @Consume("userInfo") user: {name: string, age: number} build() { Column() { Text(`用户名：${this.user.name}`) .fontColor(this.theme) // 直接使用祖先提供的数据 } } }3.5 状态监听 @Watch
TypeScript@Entry @Component struct WatchDemo { @State @Watch("onCountChange") count: number = 0 // 当 count 变化时，自动调用这个方法 onCountChange(): void { console.log(`count 变了，新值是：${this.count}`) if (this.count > 10) { promptAction.showToast({ message: "超过10了！" }) } } build() { Button(`当前：${this.count}`) .onClick(() => { this.count++ }) } }3.6 构建函数 @Builder
TypeScript@Entry @Component struct BuilderDemo { // @Builder：封装一段 UI 结构，可以复用 @Builder MyCard(title: string, content: string) { Column() { Text(title).fontSize(18).fontWeight(FontWeight.Bold) Text(content).fontSize(14).fontColor(Color.Gray) } .padding(16) .backgroundColor("#F5F5F5") .borderRadius(8) .width('90%') } build() { Column({ space: 12 }) { // 像函数一样调用，复用 UI 结构 this.MyCard("今日任务", "完成鸿蒙学习文档") this.MyCard("明日计划", "练习 ArkTS 语法") this.MyCard("本周目标", "完成第一个鸿蒙应用") } } }3.7 常用装饰器速查表
表格
装饰器 作用 使用场景 @Entry标记页面入口 每个页面必须有 @Component标记自定义组件 所有组件必须有 @State组件内部状态 页面自己的数据 @Prop单向同步（父→子） 子组件只读展示 @Link双向同步（父↔子） 子组件需要修改父数据 @Provide祖先提供状态 跨层级共享数据 @Consume后代消费状态 接收祖先的数据 @Watch监听状态变化 数据变化时执行副作用 @Builder封装复用 UI 重复使用的布局结构 @Styles封装复用样式 统一样式提取 @Extend扩展组件样式 给系统组件加自定义样式 本节总结
关键八字：@State自管理，@Prop单向传，@Link双向绑，@Provide跨层穿。
四、常用工具库与系统 API
4.1 JSON 处理：数据序列化与反序列化
TypeScript// 对象转 JSON 字符串（用于存储或网络传输） let userObj: object = { name: "张三", age: 25, isVip: true } let jsonStr: string = JSON.stringify(userObj) console.log(jsonStr) // {"name":"张三","age":25,"isVip":true} // JSON 字符串转对象（用于解析服务器返回的数据） let parseStr: string = '{"name":"李四","age":30}' let parseObj: object = JSON.parse(parseStr) console.log(parseObj['name']) // 李四 // 格式化输出（带缩进，方便调试） let prettyStr: string = JSON.stringify(userObj, null, 2) console.log(prettyStr)4.2 Date 日期时间处理
TypeScript// 获取当前时间 let now: Date = new Date() console.log(now.toString()) // 完整时间字符串 console.log(now.getFullYear()) // 年：2026 console.log(now.getMonth() + 1) // 月：0-11，所以要 +1 console.log(now.getDate()) // 日 console.log(now.getHours()) // 时 console.log(now.getMinutes()) // 分 console.log(now.getSeconds()) // 秒 console.log(now.getTime()) // 时间戳（毫秒） // 格式化时间戳为字符串 function formatDate(date: Date): string { let y: number = date.getFullYear() let m: string = (date.getMonth() + 1).toString().padStart(2, '0') let d: string = date.getDate().toString().padStart(2, '0') return `${y}-${m}-${d}` } console.log(formatDate(now)) // 2026-08-014.3 Math 数学工具
TypeScriptconsole.log(Math.PI) // 3.141592653589793 console.log(Math.abs(-10)) // 10，绝对值 console.log(Math.round(3.6)) // 4，四舍五入 console.log(Math.floor(3.9)) // 3，向下取整 console.log(Math.ceil(3.1)) // 4，向上取整 console.log(Math.max(1, 5, 3)) // 5，最大值 console.log(Math.min(1, 5, 3)) // 1，最小值 console.log(Math.random()) // 0-1 之间的随机小数 // 生成 1-100 的随机整数 let randomNum: number = Math.floor(Math.random() * 100) + 14.4 定时器：延迟与循环执行
TypeScript// setTimeout：延迟执行一次（单位：毫秒） let timeoutId: number = setTimeout(() => { console.log("2秒后执行一次") }, 2000) // 取消延迟任务 clearTimeout(timeoutId) // setInterval：每隔一段时间执行一次 let count: number = 0 let intervalId: number = setInterval(() => { count++ console.log(`第 ${count} 次执行`) if (count >= 5) { clearInterval(intervalId) // 执行5次后停止 } }, 1000) // 每秒执行一次4.5 字符串常用方法
TypeScriptlet str: string = " Hello HarmonyOS " console.log(str.length) // 19，字符串长度 console.log(str.trim()) // "Hello HarmonyOS"，去除首尾空格 console.log(str.toLowerCase()) // 转小写 console.log(str.toUpperCase()) // 转大写 console.log(str.includes("Harmony")) // true，是否包含 console.log(str.indexOf("H")) // 2，首次出现位置（考虑前面空格） console.log(str.replace("Harmony", "HongMeng")) // 替换 console.log(str.split(" ")) // 按空格分割成数组 console.log(str.substring(2, 7)) // "Hello"，截取索引 2 到 7（不含7） // 模板字符串（前面讲过，再强调） let name: string = "张三" let age: number = 25 let info: string = `姓名：${name}，年龄：${age}`4.6 鸿蒙系统常用 API 速查
TypeScript// 1. 路由跳转（页面导航） import router from '@ohos.router' // 跳转到新页面 router.pushUrl({ url: 'pages/DetailPage', params: { id: 100 } }) // 返回上一页 router.back() // 替换当前页面（不能返回） router.replaceUrl({ url: 'pages/HomePage' }) // 2. 弹窗提示 import promptAction from '@ohos.promptAction' promptAction.showToast({ message: "保存成功", duration: 2000 }) promptAction.showDialog({ title: "确认删除", message: "删除后不可恢复", buttons: [ { text: "取消", color: "#999999" }, { text: "确认", color: "#FF0000" } ] }).then((result) => { if (result.index === 1) { console.log("用户点击了确认") } }) // 3. 网络请求 import http from '@ohos.net.http' let httpRequest = http.createHttp() httpRequest.request( "https://api.example.com/data", { method: http.RequestMethod.GET, header: { 'Content-Type': 'application/json' } } ).then((response) => { console.log("返回结果：" + response.result) }).catch((err) => { console.error("请求失败：" + JSON.stringify(err)) }) // 4. 本地数据存储（轻量级） import dataPreferences from '@ohos.data.preferences' async function saveData(): Promise<void> { let context = getContext(this) let pref = await dataPreferences.getPreferences(context, "my_app") await pref.put("username", "张三") await pref.flush() // 提交保存 } async function readData(): Promise<void> { let context = getContext(this) let pref = await dataPreferences.getPreferences(context, "my_app"