🔹 Dart 中的 class 基本语法
class ClassName {// 属性（字段）数据类型 属性名;// 构造函数ClassName(this.属性名);// 方法返回类型 方法名() {// 方法体}
}✅ 示例：创建一个简单的 Person 类
class Person {// 属性String name;int age;// 构造函数Person(this.name, this.age);// 命名构造函数（可选）Person.named({required this.name, required this.age});// 方法void introduce() {print('Hello, my name is $name and I am $age years old.');}
}- 使用该类：
void main() {// 使用普通构造函数var person1 = Person('Alice', 30);person1.introduce();// 使用命名构造函数var person2 = Person.named(name: 'Bob', age: 25);person2.introduce();
}类的详细组成说明
| 成员 | 说明 |
|---|---|
| 字段（属性） | 类中用于保存数据的变量。可以有默认值。 |
| 构造函数 | 创建对象时调用的函数，可使用 this.属性名 快速赋值。 |
| 命名构造函数 | 可以定义多个构造函数，提高灵活性。 |
| 方法 | 类中的函数，用于实现功能逻辑。 |
| 工厂构造函数 | 用于控制实例的创建（比如单例）。 |
| Getter / Setter | 控制属性的读取与赋值方式。 |
工厂构造函数示例（单例模式
class Logger {static final Logger _instance = Logger._internal();factory Logger() {return _instance;}Logger._internal();void log(String message) {print('LOG: $message');}
}void main() {var logger1 = Logger();var logger2 = Logger();print(logger1 == logger2); // true（同一个实例）logger1.log('This is a singleton logger');
}Getter / Setter 示例
class BankAccount {double _balance = 0.0;double get balance => _balance;set balance(double value) {if (value >= 0) {_balance = value;} else {print('余额不能为负数');}}
}void main() {var account = BankAccount();account.balance = 100.0;print(account.balance); // 100.0account.balance = -50; // 输出：余额不能为负数
}Dart class 的关键点
| 特性 | 用法 |
|---|---|
| 类定义 | class ClassName {} |
| 构造函数 | ClassName(this.prop) |
| 命名构造 | ClassName.name() |
| 工厂构造 | factory ClassName() {} |
| getter/setter | get name => _name; |
| 继承 | class Child extends Parent {} |
| 接口实现 | class A implements B {} |
| 抽象类 | abstract class A {} |
封装（Encapsulation）
封装是将数据（属性）和行为（方法）绑定到一个类中，并通过访问控制（如 private _）隐藏内部实现
✅ 示例：封装银行账户类
class BankAccount {// 私有字段（用 _ 开头）double _balance = 0;// 公共方法：存钱void deposit(double amount) {if (amount > 0) {_balance += amount;}}// 公共方法：取钱void withdraw(double amount) {if (amount <= _balance) {_balance -= amount;}}// 只读余额double get balance => _balance;
}void main() {var account = BankAccount();account.deposit(500);account.withdraw(200);print(account.balance); // 输出: 300.0
}- 私有属性 _balance 隐藏了实现细节。
- 外部只能通过暴露的方法来访问或修改数据。
二、继承（Inheritance）
子类通过 extends 继承父类，复用父类的方法和属性。
✅ 示例：动物类和子类
class Animal {String name;Animal(this.name);void speak() {print('$name makes a sound.');}
}class Dog extends Animal {Dog(String name) : super(name);// 重写父类方法@overridevoid speak() {print('$name says: Woof!');}
}void main() {var dog = Dog('Buddy');dog.speak(); // 输出：Buddy says: Woof!
}- 子类可以使用父类的方法、属性
- 可使用 super 调用父类构造或方法。
- 可使用 @override 重写方法。
三、多态（Polymorphism）
多态指一个接口有多种实现方式，运行时动态决定具体行为。
✅ 示例：多种动物统一处理
class Animal {void speak() {print('Animal speaks.');}
}class Cat extends Animal {@overridevoid speak() {print('Meow');}
}class Dog extends Animal {@overridevoid speak() {print('Woof');}
}void makeAnimalSpeak(Animal animal) {animal.speak(); // 多态：传入不同子类，调用各自的实现
}void main() {makeAnimalSpeak(Cat()); // 输出：MeowmakeAnimalSpeak(Dog()); // 输出：Woof
}Flutter 实战场景中的封装/继承/多态应用
✅ 封装组件逻辑
class CustomButton extends StatelessWidget {final String text;final VoidCallback onPressed;const CustomButton({required this.text, required this.onPressed});@overrideWidget build(BuildContext context) {return ElevatedButton(onPressed: onPressed,child: Text(text),);}
}你就可以在任何页面中这样调用：
CustomButton(text: '点击我',onPressed: () {print('按钮被点击');},
);✅ 继承 StatefulWidget / StatelessWidget
class MyWidget extends StatefulWidget {@override_MyWidgetState createState() => _MyWidgetState();
}class _MyWidgetState extends State<MyWidget> {int count = 0;@overrideWidget build(BuildContext context) {return Text('Count: $count');}
}这里 StatefulWidget 是 Flutter 的内建类，通过继承实现组件生命周期管理。
✅ 多态：统一处理不同组件行为
abstract class Shape {void draw();
}class Circle extends Shape {@overridevoid draw() => print('Drawing Circle');
}class Rectangle extends Shape {@overridevoid draw() => print('Drawing Rectangle');
}void renderShape(Shape shape) {shape.draw(); // 多态调用
}void main() {renderShape(Circle()); // 输出：Drawing CirclerenderShape(Rectangle()); // 输出：Drawing Rectangle
}📘 拓展：抽象类与接口
抽象类 abstract
abstract class Vehicle {void drive(); // 抽象方法
}class Car extends Vehicle {@overridevoid drive() {print('Car is driving');}
}接口实现（Dart 中接口就是类）
class Flyable {void fly() => print('Flying...');
}class Bird implements Flyable {@overridevoid fly() {print('Bird is flying');}
}✅ 总结
| 特性 | 描述 | 示例关键字 |
|---|---|---|
| 封装 | 隐藏实现，暴露接口 | _private, getter, setter |
| 继承 | 代码复用，扩展功能 | extends, super, @override |
| 多态 | 统一接口，多种实现 | abstract, implements, 方法重写 |
class中高级关键词，这些关键词控制类的行为、内存管理、访问方式等
🔹 1. static —— 静态变量 / 方法
✅ 用法：
- 属于类本身，而不是某个实例。
- 直接通过类名访问。
class Counter {static int count = 0;static void increment() {count++;}
}void main() {Counter.increment();print(Counter.count); // 输出: 1
}- 用途：工具函数、常量、缓存、单例等。
🔹 2. final —— 只能赋值一次
✅ 用法：
- 变量一旦赋值后不可再更改。
- 运行时确定
class Person {final String name;Person(this.name);
}void main() {final now = DateTime.now();// now = DateTime(2023); ❌ 错误：不可重新赋值
}🔹 3. const —— 编译时常量（更严格）
✅ 用法：
- 值在 编译时就已确定。
- 可修饰对象和构造函数。
const pi = 3.14;class Circle {final double radius;const Circle(this.radius);
}void main() {const circle = Circle(10);
}对比
| 关键字 | 是否编译时常量 | 是否只能赋值一次 |
|---|---|---|
final | ❌ 否 | ✅ 是 |
const | ✅ 是 | ✅ 是 |
🔹 4. late —— 延迟初始化
✅ 用法
- 声明但不立刻赋值。
- 保证使用前会赋值。
class User {late String token;void init() {token = 'abc123';}
}🔹 5. this —— 当前实例引用
- 解决变量名冲突或调用本类方法
class User {String name;User(String name) : this.name = name;
}class Rectangle {double width, height;Rectangle(this.width, this.height);double area() => this.width * this.height;
}🔹 6. super —— 父类引用
- 调用父类构造函数或方法。
class Animal {void speak() => print('Animal speaks');
}class Dog extends Animal {@overridevoid speak() {super.speak();print('Dog barks');}
}🔹 7. factory —— 工厂构造函数
- 控制类实例化流程，如返回已有对象（单例）或缓存。
class Singleton {static final Singleton _instance = Singleton._internal();factory Singleton() {return _instance;}Singleton._internal();
}常用于：单例、缓存池、实例复用、工厂模式。
🔹 8. abstract —— 抽象类
- 不能实例化，只能继承实现。
abstract class Animal {void speak(); // 抽象方法
}class Cat extends Animal {@overridevoid speak() => print('Meow');
}🔹 9. extends —— 继承父类
class A {}
class B extends A {}🔹 10. implements —— 实现接口（类）
class Logger {void log(String message) => print(message);
}class FileLogger implements Logger {@overridevoid log(String message) {print('写入文件：$message');}
}- extends 是“继承”，只能继承一个父类；implements 是“实现”，可实现多个接口。
11. with —— 混入 mixin（多功能复用）
mixin Logger {void log(String msg) => print('[LOG] $msg');
}class Service with Logger {}汇总表：关键词快速对照
| 关键词 | 含义/用途 | 备注 |
|---|---|---|
static | 静态变量/方法 | 属于类，不属于实例 |
final | 运行时常量 | 只能赋值一次 |
const | 编译时常量 | 性能更高 |
late | 延迟初始化 | 不需要立即赋值 |
this | 当前类实例 | 解决变量冲突 |
super | 父类成员 | 调用父类构造或方法 |
factory | 工厂构造函数 | 返回已有实例/逻辑处理 |
abstract | 抽象类 | 不能实例化，只能被继承 |
extends | 继承父类 | 单继承 |
implements | 实现接口 | 可实现多个类 |
with | 使用 Mixin | 多功能注入 |
🔹 一、Mixin（混入）—— 多重继承的替代方案
Dart 不支持多重继承，但支持 mixin（混入） 来复用多个类的功能。
✅ 基本语法
mixin Fly {void fly() => print('Flying...');
}mixin Swim {void swim() => print('Swimming...');
}class Duck with Fly, Swim {}void main() {Duck().fly(); // 输出：Flying...Duck().swim(); // 输出：Swimming...
}特点
- with 后可接多个 mixin
- 没有构造函数
- 通常用于添加功能，而不是当成完整类
✅ Flutter 场景应用：封装复用逻辑
mixin Logger {void log(String message) => print('[LOG]: $message');
}class MyService with Logger {void fetchData() {log('Fetching data...');}
}🔹 二、抽象类设计模式 —— 架构利器
抽象类定义接口/规范，不提供完整实现，由子类去实现。可用于：
| 场景 | 示例 |
|---|---|
| 定义业务接口 | PaymentService |
| 统一组件行为 | BasePage |
| 解耦依赖 | Repository 模式 |
✅ 示例：支付服务接口
abstract class PaymentService {void pay(double amount);
}class WeChatPay implements PaymentService {@overridevoid pay(double amount) {print('使用微信支付 $amount 元');}
}class AliPay implements PaymentService {@overridevoid pay(double amount) {print('使用支付宝支付 $amount 元');}
}void processPayment(PaymentService service) {service.pay(100.0); // 多态调用
}🔹 三、代码结构封装（Flutter 实战架构）
在实际开发中，随着代码增长，良好的 组织结构和模块封装 是必须的
✅ 推荐结构（按功能划分）
/lib├── main.dart├── core/ # 全局工具、配置、mixin├── models/ # 数据模型（如 User）├── services/ # 网络、数据库、第三方服务封装├── ui/ │ ├── screens/ # 页面（如 login_page.dart）│ ├── widgets/ # 可复用组件（如 custom_button.dart）│ └── themes/ # 主题样式└── controllers/ # 状态管理、逻辑处理（如 UserController）✅ 组件封装实例：BasePage 模板
abstract class BasePage extends StatelessWidget {const BasePage({super.key});Widget buildBody(BuildContext context);@overrideWidget build(BuildContext context) {return Scaffold(appBar: AppBar(title: Text(runtimeType.toString())),body: buildBody(context),);}
}- 使用：
class HomePage extends BasePage {@overrideWidget buildBody(BuildContext context) {return Center(child: Text('欢迎来到首页'));}
}✅ Mixin + 抽象类结合：功能注入
mixin LoadingMixin {void showLoading() => print('加载中...');
}abstract class BaseController with LoadingMixin {void loadData();
}class UserController extends BaseController {@overridevoid loadData() {showLoading();print('加载用户数据...');}
}| 插件 | 用途 |
|---|---|
get_it | 依赖注入 |
provider / riverpod | 状态管理 |
freezed + json_serializable | 模型自动生成 |
flutter_hooks | 简化 Stateful 组件逻辑 |
实战架构建议：
| 建议 | 说明 |
|---|---|
| 用抽象类定义接口 | 解耦 UI 与业务（如 Repository 接口） |
| 用 Mixin 抽取逻辑 | 如 Logger、生命周期监听、权限检查等 |
| 用 service 层封装 API | UserService、OrderService |
| 用 base widget / base controller 模板化 | 保持统一结构与风格 |
| 把页面按“功能模块”分包 | /home, /login, /profile |
最后总结
| 概念 | 功能 | 应用场景 |
|---|---|---|
mixin | 行为复用 | 日志、权限、监听、动画等 |
abstract class | 接口约束 | 统一风格/功能规范 |
with | 多继承功能混入 | 多功能类组合 |
| 模块结构划分 | 可维护性 | 大中型项目组织核心 |
)
