flutter dart class语法说明、示例

🔹 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	多继承功能混入	多功能类组合
模块结构划分	可维护性	大中型项目组织核心