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.0

  account.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);

  // 重写父类方法
  @override
  void 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 {
  @override
  void speak() {
    print('Meow');
  }
}

class Dog extends Animal {
  @override
  void speak() {
    print('Woof');
  }
}

void makeAnimalSpeak(Animal animal) {
  animal.speak(); // 多态：传入不同子类，调用各自的实现
}

void main() {
  makeAnimalSpeak(Cat()); // 输出：Meow
  makeAnimalSpeak(Dog()); // 输出：Woof
}

Flutter 实战场景中的封装/继承/多态应用

✅ 封装组件逻辑

class CustomButton extends StatelessWidget {
  final String text;
  final VoidCallback onPressed;

  const CustomButton({required this.text, required this.onPressed});

  @override
  Widget 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;

  @override
  Widget build(BuildContext context) {
    return Text('Count: $count');
  }
}

这里 StatefulWidget 是 Flutter 的内建类，通过继承实现组件生命周期管理。

✅ 多态：统一处理不同组件行为

abstract class Shape {
  void draw();
}

class Circle extends Shape {
  @override
  void draw() => print('Drawing Circle');
}

class Rectangle extends Shape {
  @override
  void draw() => print('Drawing Rectangle');
}

void renderShape(Shape shape) {
  shape.draw(); // 多态调用
}

void main() {
  renderShape(Circle());     // 输出：Drawing Circle
  renderShape(Rectangle());  // 输出：Drawing Rectangle
}

📘 拓展：抽象类与接口

抽象类 abstract

abstract class Vehicle {
  void drive(); // 抽象方法
}

class Car extends Vehicle {
  @override
  void drive() {
    print('Car is driving');
  }
}

接口实现（Dart 中接口就是类）

class Flyable {
  void fly() => print('Flying...');
}

class Bird implements Flyable {
  @override
  void 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 {
  @override
  void 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 {
  @override
  void 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 {
  @override
  void 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 {
  @override
  void pay(double amount) {
    print('使用微信支付 $amount 元');
  }
}

class AliPay implements PaymentService {
  @override
  void 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);

  @override
  Widget build(BuildContext context) {
    return Scaffold(
      appBar: AppBar(title: Text(runtimeType.toString())),
      body: buildBody(context),
    );
  }
}

使用：

class HomePage extends BasePage {
  @override
  Widget buildBody(BuildContext context) {
    return Center(child: Text('欢迎来到首页'));
  }
}

✅ Mixin + 抽象类结合：功能注入

mixin LoadingMixin {
  void showLoading() => print('加载中...');
}

abstract class BaseController with LoadingMixin {
  void loadData();
}

class UserController extends BaseController {
  @override
  void 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`	多继承功能混入	多功能类组合
模块结构划分	可维护性	大中型项目组织核心