Dart泛型学习：从入门到实践

本文全面介绍了Dart泛型的基本概念和使用方法，涵盖泛型类、方法和变量的定义，以及如何使用泛型处理列表和映射。文章还深入讲解了泛型约束的应用，并通过实例展示了Dart中常见的泛型类型如Future和Stream。学习Dart泛型不仅能够提高代码的灵活性和可复用性，还能简化异步操作的处理。

什么是泛型

泛型是编程语言中的一个重要特性，它允许在创建类、接口和方法时使用类型参数，从而提高代码的灵活性和可复用性。通过使用泛型，可以编写更通用、更强大的代码，而不需要为每种数据类型都编写特定的实现。泛型在实际应用中广泛用于构建灵活和高效的数据结构和算法。

Dart语言中的泛型基础

在Dart语言中，泛型允许你定义类型参数化的类、方法和接口。当定义一个泛型类或方法时，你需要指定一个或多个类型参数，这些类型参数在使用时会被实际类型替换。例如，List<T>表示一个泛型列表，其中T是一个类型参数，可以被任何具体类型替换，如List<int>或List<String>。

List<int> list1 = [1, 2, 3]; // 使用 List<int> 类型
List<String> list2 = ["a", "b", "c"]; // 使用 List<String> 类型

泛型不仅限于类和方法，还可以用于函数和变量定义。例如，Map<K, V>是一个泛型映射，其中K表示键的类型，V表示值的类型。

Map<int, String> map1 = {1: "one", 2: "two"}; // 使用 Map<int, String> 类型
Map<String, bool> map2 = {"yes": true, "no": false}; // 使用 Map<String, bool> 类型

在Dart中，你可以使用泛型来定义变量的类型。例如，你可以定义一个变量来存储任何类型的对象，并在使用时指定具体的类型。

var list;
list = [1, 2, 3]; // 类型推断为 List<int>
list = ["a", "b", "c"]; // 类型推断为 List<String>

同样，你可以定义一个泛型变量来存储不同类型的对象。

var list;
list = [1, 2, 3]; // list 类型推断为 List<int>
list = ["a", "b", "c"]; // list 类型推断为 List<String>

如何定义泛型类

定义泛型类时，需要在类名后面使用<T>这样的形式来指定类型参数。类型参数可以是一个或多个，用逗号分隔。

class Box<T> {
  T value;

  Box(this.value);

  void display() {
    print("Box value: $value");
  }
}

Box<int> intBox = Box(10);
Box<String> stringBox = Box("hello");

在这个例子中，Box<T>是一个泛型类，T是类型参数，可以在使用时指定具体类型。

如何使用泛型方法

泛型方法可以在类或函数中定义，它们可以接受类型参数作为参数或返回类型。

class Operations<T> {
  T sum(T a, T b) {
    if (a is int && b is int) {
      return a + b;
    } else if (a is double && b is double) {
      return a + b;
    } else {
      throw Exception("Unsupported types");
    }
  }
}

Operations<int> intOps = Operations<int>();
print(intOps.sum(10, 20)); // 输出 30

Operations<double> doubleOps = Operations<double>();
print(doubleOps.sum(10.5, 20.5)); // 输出 31.0

在这个例子中，sum方法是一个泛型方法，可以处理不同的类型。注意，方法内部需要进行类型检查来确保操作的正确性。

泛型约束的概念

泛型约束允许你限制类型参数的范围，以确保类型参数满足特定的条件。这在需要特定类型的方法或类中非常有用。例如，如果你希望类型参数实现某个接口或继承某个基类，你可以使用约束来确保这一点。

如何在代码中实现泛型约束

在定义泛型类或方法时，可以在类型参数后面使用where关键字来添加约束。

class NumberHandler<T extends num> {
  T value;

  NumberHandler(this.value);

  T sum(T a, T b) {
    return a + b;
  }
}

NumberHandler<int> intHandler = NumberHandler(10);
print(intHandler.sum(10, 20)); // 输出 30

NumberHandler<double> doubleHandler = NumberHandler(10.5);
print(doubleHandler.sum(10.5, 20.5)); // 输出 31.0

在这个例子中，NumberHandler<T>是一个泛型类，其中T是类型参数，并且T必须是num的子类型（继承自num）。

泛型在列表操作中的使用

泛型在处理列表操作时非常有用，可以确保列表中的元素类型一致，从而避免类型错误。

void processList<T>(List<T> list) {
  for (var item in list) {
    print("Processing item: $item");
  }
}

List<int> intList = [1, 2, 3];
processList(intList); // 输出 Processing item: 1, Processing item: 2, Processing item: 3

List<String> stringList = ["a", "b", "c"];
processList(stringList); // 输出 Processing item: a, Processing item: b, Processing item: c

在这个例子中，processList函数可以处理任何类型的列表，具体类型由调用时传入的列表决定。

泛型在数据模型中的应用

泛型可以用于定义灵活的数据模型。例如，你可以定义一个可以存储不同类型数据的通用模型。

class DataModel<T> {
  T data;

  DataModel(this.data);

  void display() {
    print("Data: $data");
  }
}

DataModel<int> intModel = DataModel(10);
intModel.display(); // 输出 Data: 10

DataModel<String> stringModel = DataModel("hello");
stringModel.display(); // 输出 Data: hello

在这个例子中，DataModel<T>可以存储任何类型的数据，具体类型由实例化时传入的数据决定。

Future 和 Stream 的泛型使用

在Dart中，Future<T>和Stream<T>是非常常见的泛型类型，用于处理异步操作。

Future<int> fetchFutureData() async {
  await Future.delayed(Duration(seconds: 1));
  return 42;
}

fetchFutureData().then((value) {
  print("Future data: $value"); // 输出 Future data: 42
});

Stream<String> fetchDataStream() async* {
  yield "First item";
  await Future.delayed(Duration(seconds: 1));
  yield "Second item";
}

fetchDataStream().listen((event) {
  print("Stream item: $event"); // 输出 Stream item: First item, Stream item: Second item
});

在这个例子中，fetchFutureData返回一个Future<int>，fetchDataStream返回一个Stream<String>。泛型参数指定了异步操作返回的数据类型。

Map 和 List 的泛型实例

Map<K, V>和List<T>是Dart中最常用的泛型类型，用于存储键值对和列表。

void processMap(Map<String, int> map) {
  for (var entry in map.entries) {
    print("Key: ${entry.key}, Value: ${entry.value}");
  }
}

Map<String, int> map = {"one": 1, "two": 2};
processMap(map); // 输出 Key: one, Value: 1, Key: two, Value: 2

void processList(List<int> list) {
  for (var item in list) {
    print("Item: $item");
  }
}

List<int> list = [1, 2, 3];
processList(list); // 输出 Item: 1, Item: 2, Item: 3

在这个例子中，processMap和processList函数分别处理带有泛型参数的Map和List。

Dart泛型的复习要点

• 泛型允许定义类型参数化的方法、类和接口。
• 泛型可以提高代码的灵活性和可复用性。
• 使用<T>语法定义类型参数。
• 可以使用where关键字添加泛型约束。
• 常见的泛型类型包括Future<T>、Stream<T>、Map<K, V>和List<T>。

实践练习题

1. 定义一个泛型类Box<T>，包含一个类型参数T，并实现一个display方法来显示T类型的值。
2. 实现一个泛型方法sum<T>(T a, T b)，要求T必须是num类型，返回a和b的和。
3. 实现一个泛型函数processList<T>(List<T> list)，遍历并打印list中的每个元素。
4. 实现一个泛型类DataModel<T>，包含一个类型参数T，实现一个display方法来显示T类型的值。
5. 使用Future和Stream处理异步操作，返回特定类型的异步数据。
6. 实现一个泛型方法filter<T>(List<T> list, bool Function(T) predicate)，过滤列表中的元素，返回满足条件的新列表。

这些练习题可以帮助你更好地理解和掌握Dart中的泛型使用。通过这些练习，你可以将泛型应用到实际开发中，编写更通用、更强大的代码。