Dart中的类修饰符

类修饰符可以用在 class 关键词前面，例如 abstract class 用于定义一个抽象类。
类修饰符种类：

• abstract
• base
• final
• interface
• sealed
• mixin

除 abstract 外，其他修饰符均需要 dart version => 3.0 。
仅有 base 可以出现在 mixin 前面。
修饰符不能其他诸如 enum, typedef, extension 或 extension type 的声明中使用。

无修饰符

对于无修饰符的 class ,允许不受限制地从任何库构造或子类型. 允许以下操作：

• 实例化;
• 扩展一个子类;
• 实现一个类或者一个mixin;
• mixin 一个 mixin 或者 mixin class.

abstract

对于不需要完整实现的,只需要定义接口的场景使用 abstract，abstract class 不允许实例化.

// 声明一个 abstract class 
abstract class Vehicle {
  void moveForward(int meters);
}

import 'a.dart';

// 错误: abstract class 不允许实例化
Vehicle myVehicle = Vehicle();

// ✅被扩展
class Car extends Vehicle {
  int passengers = 4;
  // ···
}

// ✅被实现
class MockVehicle implements Vehicle {
  @override
  void moveForward(int meters) {
    // ...
  }
}

base

允许继承，不允许实现。

// 声明一个 base class
base class Vehicle {
  void moveForward(int meters) {
    // ...
  }
}

import 'a.dart';

// ✅允许实例化
Vehicle myVehicle = Vehicle();

// ✅允许扩展
base class Car extends Vehicle {
  int passengers = 4;
  // ...
}

// ❌不允许实现
base class MockVehicle implements Vehicle {
  @override
  void moveForward() {
    // ...
  }
}

interface

可以被实现，但是不允许扩展。

interface class Vehicle {
  void moveForward(int meters) {
    // ...
  }
}

import 'a.dart';

// ✅允许实例化
Vehicle myVehicle = Vehicle();

// ❌不允许继承
class Car extends Vehicle {
  int passengers = 4;
  // ...
}

// ✅允许被实现
class MockVehicle implements Vehicle {
  @override
  void moveForward(int meters) {
    // ...
  }
}

abstract 和 interface 可以组合使用，abstract interface class。

final

关闭类的结构层次，禁止被扩展和实现。

final class Vehicle {
  void moveForward(int meters) {
    // ...
  }
}

// ✅允许实例化
Vehicle myVehicle = Vehicle();

// ❌不允许被扩展
class Car extends Vehicle {
  int passengers = 4;
  // ...
}

// ❌不允许被实现
class MockVehicle implements Vehicle {
  // ERROR: Can't be implemented.
  @override
  void moveForward(int meters) {
    // ...
  }
}

sealed

用于创建一个可以被穷举的子类合集。

声明一个 sealed class
sealed class Vehicle {}

class Car extends Vehicle {}

class Truck implements Vehicle {}

class Bicycle extends Vehicle {}

// ❌不允许实例化
Vehicle myVehicle = Vehicle();

// ✅子类允许实例化
Vehicle myCar = Car();

String getVehicleSound(Vehicle vehicle) {
  //❌编译错误，switch 缺少子类 Bicycle case，或者 default case.
  return switch (vehicle) {
    Car() => 'vroom',
    Truck() => 'VROOOOMM',
  };
}

组合使用

类修复符允许按如下顺序组合使用：

• （可选）abstract，描述类是否可以包含抽象成员并阻止实例化。
• （可选）base、interface、final 、sealed中的一个，描述对该类进行子类型化的其他库的限制。
• （可选）mixin，描述是否可以 mixin。
• 关键字class本身。

不能组合某些修饰符，因为它们是矛盾的、冗余的或相互排斥的：

• abstract 和 sealed。sealed 类是隐式抽象的。
• interface, final 、sealed 与 mixin。这些修饰符不允许 mixin.

使用场景分析

//TODO

本文链接：