Flutter for OpenHarmony前置知识:Dart 语法核心知识点总结(下)

爱吃大芒果2026-01-21 19:38

Flutter for OpenHarmony前置知识:Dart 语法核心知识点总结(下)

作者：爱吃大芒果

个人主页 爱吃大芒果

本文所属专栏Flutter

更多专栏
Ascend C 算子开发教程（进阶）
鸿蒙集成
OpenAgents
openJiuwen
从0到1自学C++

Dart 基础语法（Flutter 核心开发语言）

Dart 是 Google 开发的面向对象、跨平台的编程语言，也是 Flutter 框架的核心开发语言。它兼具静态类型语言的安全性和动态类型语言的灵活性，掌握 Dart 基础语法是学习 Flutter 的第一步。

相关资料

承接上文:Dart 语法核心知识点总结(上)

十九、Dart中类的定义

Dart 是纯面向对象语言，一切皆对象，类是对象的模板，包含属性和方法。

dart 复制代码 
// 定义类
class Person {
  // 属性（成员变量）
  String name;
  int age;
  
  // 构造函数（初始化属性）
  Person(this.name, this.age);
  
  // 方法
  void sayHello() {
    print("大家好，我是$name，今年$age岁");
  }
}

void main() {
  // 创建对象
  Person p = Person("爱吃大芒果", 19);
  p.sayHello(); // 输出：大家好，我是爱吃大芒果，今年19岁
}

二十、Dart中类的默认构造函数

如果不手动定义构造函数，Dart 会提供一个默认的无参构造函数。手动定义后，默认构造函数失效。

二十一、Dart中类的命名构造函数

一个类可以有多个命名构造函数，用于不同的初始化场景：

dart 复制代码 
class Person {
  String name;
  int age;
  
  // 默认构造函数
  Person(this.name, this.age);
  
  // 命名构造函数1：初始化默认值
  Person.defaultPerson() : name = "未知", age = 0;
  
  // 命名构造函数2：从Map初始化
  Person.fromMap(Map<String, dynamic> map) : 
    name = map["name"], 
    age = map["age"];
  
  void sayHello() {
    print("大家好，我是$name，今年$age岁");
  }
}

void main() {
  Person p1 = Person.defaultPerson();
  p1.sayHello(); // 大家好，我是未知，今年0岁
  
  Person p2 = Person.fromMap({"name": "张三", "age": 20});
  p2.sayHello(); // 大家好，我是张三，今年20岁
}

二十二、Dart中类构造函数的语法糖写法

简化属性初始化，无需手动赋值：

dart 复制代码 
class Person {
  // 直接在构造函数参数前加 this.，自动赋值
  Person(this.name, this.age);
  
  String name;
  int age;
}

二十三、类的公有属性和私有属性

Dart 没有专门的 public/private 关键字，通过标识符命名规则区分公有 / 私有属性 / 方法：

  • 公有成员：以小写字母 / 大写字母开头（如 name、age、sayHello），可被外部访问。
  • 私有成员：以下划线 _ 开头（如 _id、_secret），仅能在当前文件内访问。

核心规则

  1. 私有成员的作用域是文件级，而非类级（即使是不同类，只要在同一文件内就能访问）。
  2. 私有成员无法被其他文件的子类继承 / 访问。
  3. 通常通过公有方法（getter/setter）封装私有成员，控制访问权限。
dart 复制代码 
// person.dart 文件
class Person {
  // 公有属性
  String name;
  
  // 私有属性（下划线开头）
  int _age;
  String _idCard; // 身份证号，隐私数据
  
  // 构造函数
  Person(this.name, this._age, this._idCard);
  
  // 公有方法：访问私有属性（getter）
  int get age => _age;
  
  // 公有方法：修改私有属性（setter，带校验逻辑）
  set age(int newAge) {
    if (newAge >= 0 && newAge <= 120) {
      _age = newAge;
    } else {
      print("年龄不合法");
    }
  }
  
  // 私有方法
  void _checkIdCard() {
    print("校验身份证格式：$_idCard");
  }
  
  // 公有方法调用私有方法
  void showInfo() {
    _checkIdCard(); // 同一类内可访问私有方法
    print("姓名：$name，年龄：$_age");
  }
}

void main() {
  Person p = Person("爱吃大芒果", 19, "110101XXXX");
  
  // 访问公有属性
  print(p.name); // 正常输出：爱吃大芒果
  
  // 直接访问私有属性（编译报错）
  // print(p._age); // Error: The getter '_age' isn't defined for the class 'Person'
  
  // 通过 getter/setter 访问私有属性
  print(p.age); // 输出：19
  p.age = 20; // 合法修改
  print(p.age); // 输出：20
  p.age = -5; // 输出：年龄不合法
  
  // 调用公有方法（间接执行私有逻辑）
  p.showInfo();
}

跨文件访问示例（错误演示）

dart 复制代码 
// test.dart 文件（另一个文件）
import 'person.dart';

void main() {
  Person p = Person("张三", 20, "123456");
  // print(p._age); // 编译报错：私有成员无法跨文件访问
}

二十四、Dart中类的继承

Dart 支持单继承，使用 extends 关键字，子类可以继承父类的属性和方法：

dart 复制代码 
// 父类
class Person {
  String name;
  int age;
  
  Person(this.name, this.age);
  
  void sayHello() {
    print("大家好，我是$name，今年$age岁");
  }
}

// 子类
class Student extends Person {
  // 子类属性
  String school;
  
  // 子类构造函数（必须调用父类构造函数）
  Student(String name, int age, this.school) : super(name, age);
  
  // 重写父类方法
  @override
  void sayHello() {
    super.sayHello(); // 调用父类方法
    print("我在$school上学");
  }
}

void main() {
  Student s = Student("爱吃大芒果", 19, "皮城大学");
  s.sayHello();
  // 输出：
  // 大家好，我是爱吃大芒果，今年19岁
  // 我在皮城大学上学
}

二十五、Dart中类的多态

子类对象可以赋值给父类变量，调用方法时执行子类的实现：

dart 复制代码 
void main() {
  // 多态：父类引用指向子类对象
  Person p = Student("爱吃大芒果", 19, "皮城大学");
  p.sayHello(); // 执行子类重写的方法
}

二十六、Dart中类的多态-抽象和接口实现

Dart 的多态核心是父类引用指向子类对象，而抽象类和接口是实现多态的核心载体。

抽象类（abstract class）

  • 用 abstract 关键字声明，不能被实例化，只能被继承。
  • 可以包含抽象方法（无实现体）和普通方法（有实现体）。
  • 子类必须实现所有抽象方法，否则子类也需声明为抽象类。
适用场景

定义通用规范（如 "动物都能叫"），由子类实现具体逻辑。

dart 复制代码 
// 抽象类：定义规范
abstract class Animal {
  // 抽象方法（无实现体）
  void makeSound();
  
  // 普通方法（有实现体）
  void eat() {
    print("动物吃东西");
  }
}

// 子类1：实现抽象方法
class Dog extends Animal {
  @override
  void makeSound() {
    print("汪汪汪");
  }
}

// 子类2：实现抽象方法
class Cat extends Animal {
  @override
  void makeSound() {
    print("喵喵喵");
  }
  
  // 重写父类普通方法
  @override
  void eat() {
    print("猫吃小鱼干");
  }
}

void main() {
  // 多态：父类引用指向子类对象
  Animal animal1 = Dog();
  Animal animal2 = Cat();
  
  // 调用子类实现的方法
  animal1.makeSound(); // 输出：汪汪汪
  animal2.makeSound(); // 输出：喵喵喵
  
  // 调用方法（子类重写则执行子类逻辑）
  animal1.eat(); // 输出：动物吃东西
  animal2.eat(); // 输出：猫吃小鱼干
}

接口实现（implements）

Dart 没有专门的 interface 关键字，所有类都可以作为接口被实现：

  • 用 implements 关键字实现接口，而非 extends。
  • 必须实现接口类的所有属性和方法（无论是否抽象）。
  • 一个类可以实现多个接口（类似多继承）。
适用场景

定义 "能力规范"（如 "可飞行"、"可游泳"），让不同类具备相同能力。

dart 复制代码 
// 接口1：可飞行
class Flyable {
  void fly() {
    print("默认飞行逻辑");
  }
}

// 接口2：可游泳
class Swimmable {
  void swim() {} // 空实现
}

// 实现多个接口
class Duck implements Flyable, Swimmable {
  // 必须实现 Flyable 的 fly 方法
  @override
  void fly() {
    print("鸭子扑腾翅膀飞");
  }

  // 必须实现 Swimmable 的 swim 方法
  @override
  void swim() {
    print("鸭子划水游泳");
  }
  
  // 自定义方法
  void quack() {
    print("嘎嘎嘎");
  }
}

void main() {
  Duck duck = Duck();
  duck.fly(); // 输出：鸭子扑腾翅膀飞
  duck.swim(); // 输出：鸭子划水游泳
  duck.quack(); // 输出：嘎嘎嘎
  
  // 多态：接口引用指向实现类对象
  Flyable flyable = Duck();
  flyable.fly(); // 仅能调用接口定义的方法
}

抽象类 vs 接口

二十七、Dart中类的混入

Dart 不支持多继承，但可以通过混入（Mixin）实现类似多继承的效果，使用 with 关键字：

dart 复制代码 
// 定义混入类（不能被实例化）
mixin Run {
  void run() {
    print("跑步");
  }
}

mixin Swim {
  void swim() {
    print("游泳");
  }
}

// 使用混入
class Person with Run, Swim {
  String name;
  Person(this.name);
}

void main() {
  Person p = Person("爱吃大芒果");
  p.run(); // 跑步
  p.swim(); // 游泳
}

二十八、Dart中的泛型

泛型（Generic）是指在定义类、函数、接口时不指定具体类型，使用时再确定类型，核心作用：

  1. 类型安全：编译时检查类型，避免运行时类型错误。
  2. 代码复用：一套逻辑适配多种类型，无需重复编写。
  3. 可读性提升：明确代码支持的类型范围。
dart 复制代码 
// 泛型函数：T 是类型参数（可自定义名称，如 E、K、V）
T swap<T>(List<T> list, int index1, int index2) {
  if (index1 < 0 || index2 < 0 || index1 >= list.length || index2 >= list.length) {
    throw ArgumentError("索引越界");
  }
  // 交换元素
  T temp = list[index1];
  list[index1] = list[index2];
  list[index2] = temp;
  return temp;
}

void main() {
  // 适配 int 类型
  List<int> numList = [1, 2, 3];
  swap(numList, 0, 2);
  print(numList); // 输出：[3, 2, 1]
  
  // 适配 String 类型
  List<String> strList = ["a", "b", "c"];
  swap(strList, 1, 2);
  print(strList); // 输出：[a, c, b]
}

二十九、Dart中的异步编程

Dart 是单线程模型，异步编程核心解决耗时操作（网络请求、文件读写）阻塞主线程的问题，核心概念包括：Future、async/await、Stream、Isolate。

（1）Future 状态

  • 未完成（pending）：异步操作还在执行。
  • 已完成（completed）：
    • 成功（value）：返回结果。
    • 失败（error）：抛出异常。

（2）Future 常用方法

三十、Dart中Future的基本使用

Dart 是单线程语言，异步操作主要通过 Future 实现，用于处理耗时操作（如网络请求、文件读写）。

dart 复制代码 
void main() {
  print("开始执行");
  
  // 延迟1秒执行
  Future.delayed(Duration(seconds: 1), () {
    print("异步操作执行");
    return "操作结果";
  });
  
  print("结束执行");
  // 输出顺序：
  // 开始执行
  // 结束执行
  // 异步操作执行
}

异常处理

三十一、Dart中Future的链式调用

使用 then 处理异步操作的结果，支持链式调用：

dart 复制代码 
Future.delayed(Duration(seconds: 1), () => 1)
  .then((num) => num + 1) // 1+1=2
  .then((num) => num * 2) // 2*2=4
  .then((num) => print("结果：$num")); // 输出：结果：4

三十二、Dart中Future的async和await

async/await 是 Future 的语法糖，让异步代码看起来像同步代码，更易读：

dart 复制代码 
void main() async {
  print("开始执行");
  
  // 等待异步操作完成
  String result = await fetchData();
  print("异步结果：$result");
  
  print("结束执行");
  // 输出顺序：
  // 开始执行
  // 异步操作完成
  // 异步结果：成功获取数据
  // 结束执行
}

// 异步函数（返回 Future）
Future<String> fetchData() {
  return Future.delayed(Duration(seconds: 1), () {
    print("异步操作完成");
    return "成功获取数据";
  });
}

异常处理

dart 复制代码 
void main() async {
  try {
    String result = await fetchData();
    print("结果：$result");
  } catch (e) {
    print("异常：$e"); // 输出：异常：请求失败
  }
}

Future<String> fetchData() {
  return Future.delayed(Duration(seconds: 1), () {
    throw "请求失败"; // 抛出异常
    return "成功";
  });
}

总结

  1. 面向对象核心：Dart 纯面向对象，支持类定义、构造函数（默认/命名/语法糖）、访问控制（下划线私有）、单继承、多态，通过抽象类定义规范、接口实现能力、混入（Mixin）模拟多继承。
  2. 泛型：通过类型参数实现代码复用和类型安全，一套逻辑适配多种类型，编译时检查类型错误。
  3. 异步编程 ：基于单线程模型，核心是 Future 处理异步操作，async/await 简化异步代码写法，支持链式调用和 try/catch 异常处理，解决耗时操作阻塞问题。

Dart 作为 Flutter 的核心开发语言，其语法兼具安全性和灵活性。本次学习内容围绕Dart语法入门为主题展开，重点梳理了关键概念、实用方法和操作步骤。掌握这些基础语法是深入学习 Flutter 开发的重要前提。

欢迎加入开源鸿蒙跨平台社区：开源鸿蒙跨平台开发者社区

相关推荐
Ulyanov2 小时前
从桌面到云端：构建Web三维战场指挥系统
开发语言·前端·python·tkinter·pyvista·gui开发
星火开发设计2 小时前
C++ 函数定义与调用：程序模块化的第一步
java·开发语言·c++·学习·函数·知识
cypking2 小时前
二、前端Java后端对比指南
java·开发语言·前端
钟离墨笺2 小时前
Go语言--2go基础--＞map
开发语言·后端·golang
小蜜蜂嗡嗡2 小时前
【flutter better_player_plus实现普通播放器功能】
flutter
lsx2024062 小时前
DOM CDATA
开发语言
Tony Bai2 小时前
Go 语言的“魔法”时刻：如何用 -toolexec 实现零侵入式自动插桩？
开发语言·后端·golang
AI_零食3 小时前
鸿蒙跨端框架 Flutter 学习 Day 6：异步编程：等待的艺术
学习·flutter·华为·交互·harmonyos·鸿蒙
Coding茶水间3 小时前
基于深度学习的交通标志检测系统演示与介绍(YOLOv12/v11/v8/v5模型+Pyqt5界面+训练代码+数据集)
开发语言·人工智能·深度学习·yolo·目标检测·机器学习
热门推荐
01GitHub 镜像站点02OpenCode 入门教程：介绍 · 安装 · 配置第三方 API (如 Claude)032025 Telegram 最新免费社工库机器人（LetsTG可[特殊字符]）搭建指南（含 Python 脚本）04UV安装并设置国内源05在VSCode配置Java开发环境的保姆级教程（适配各类AI编程IDE）06安娜的档案(Anna’s Archive) 镜像网站/国内最新可访问入口（持续更新）07Claude Code Skills 实用使用手册08AI 规范驱动开发“三剑客”深度对比：Spec-Kit、Kiro 与 OpenSpec 实战指南09BongoCat - 跨平台键盘猫动画工具10Linux下V2Ray安装配置指南