本文详细介绍了Dart泛型的基础概念，包括泛型方法和类的定义与使用，类型约束和自动类型推断等内容。通过多种示例代码，展示了Dart泛型在集合和自定义类中的应用，帮助开发者编写更加通用和安全的代码。Dart泛型的灵活使用能够显著提升代码的重用性和可维护性。

在编程中，泛型是一种允许在编写代码时使用类型变量的特性。通过使用泛型，你可以编写出更具通用性和重用性的代码。在Dart中，泛型使你能够编写适用于任何类型的代码，而无需针对特定类型编写多个不同的版本。

示例代码

以下是一个简单的泛型方法的示例：

void printElement<T>(T element) {
  print(element);
}

void main() {
  printElement<String>('Hello, World!');
  printElement<int>(42);
}

在这个例子中，printElement 是一个泛型方法，它接受一个类型参数 T。你可以使用任何类型来调用这个方法，这使得这个方法更加通用。

泛型在Dart中最常见的使用场景是集合（如 List, Map, Set）和自定义类中。通过使用泛型，你可以指定集合中元素的类型，或者定义一个类能够处理的多种类型。

示例代码

以下是一个使用泛型集合的例子：

void main() {
  List<int> numbers = [1, 2, 3, 4, 5];
  Set<String> names = {'Alice', 'Bob', 'Charlie'};
  Map<String, int> scores = {'Alice': 90, 'Bob': 85, 'Charlie': 95};

  print(numbers);
  print(names);
  print(scores);
}

在这个例子中，List<int> 表示一个只包含整数的列表，Set<String> 表示一个只包含字符串的集合，Map<String, int> 表示一个键为字符串，值为整数的映射。

在Dart中，可以通过使用尖括号 <> 来定义泛型类型。泛型类型可以应用于类、方法和函数。

示例代码

以下是一个定义泛型类的示例：

class Box<T> {
  T content;

  Box(this.content);

  void printContent() {
    print(content);
  }
}

void main() {
  Box<String> stringBox = Box<String>('Hello');
  Box<int> intBox = Box<int>(42);

  stringBox.printContent();
  intBox.printContent();
}

在这个例子中，Box 是一个泛型类，它有一个类型参数 T。你可以创建一个 Box<String> 实例来存储字符串，或者创建一个 Box<int> 实例来存储整数。

在使用泛型类型时，你需要指定类型参数的具体类型。这可以通过在创建对象或调用方法时提供类型参数来完成。

示例代码

以下是一个使用泛型方法的例子：

void printAnything<T>(T value) {
  print(value);
}

void main() {
  printAnything<String>('Hello');
  printAnything<int>(42);
}

在这个例子中，printAnything 是一个泛型方法，它接受一个类型参数 T。你可以使用任何类型来调用这个方法，这使得这个方法更加通用。

有时候，你可能需要限制泛型类型参数的类型。这可以通过使用类型约束（如 where 语句）来实现。

示例代码

以下是一个使用类型约束的例子：

void printLength<T extends Object>(T value) {
  if (value is String) {
    print(value.length);
  } else {
    print('Not a string');
  }
}

void main() {
  printLength('Hello');  // 输出：5
  printLength(42);      // 输出：Not a string
}

在这个例子中，printLength 方法被定义为接受一个 T 类型的参数，但 T 必须是 Object 的子类。在这个方法内部，我们检查了 value 是否为字符串类型，然后输出它的长度。

在定义泛型类或方法时，你可以使用 extends 和 super 关键字来指定泛型类型参数必须或者不能继承某个特定类型。

示例代码

以下是一个使用 extends 关键字的例子：

class Animal {}

class Dog extends Animal {}

class Cat extends Animal {}

void printAnimalInfo<T extends Animal>(T animal) {
  print(animal.runtimeType);
}

void main() {
  printAnimalInfo<Dog>(Dog());
  printAnimalInfo<Cat>(Cat());
}

在这个例子中，printAnimalInfo 方法被定义为接受一个 T 类型的参数，但 T 必须是 Animal 的子类。你可以传递 Dog 或 Cat 类型的对象给这个方法。

在Dart中，编译器可以自动推断泛型类型参数的具体类型。这可以通过使用类型推断来简化代码。

示例代码

以下是一个使用类型推断的例子：

void printAnything(value) {
  print(value);
}

void main() {
  printAnything('Hello');  // 输出：Hello
  printAnything(42);      // 输出：42
}

在这个例子中，printAnything 方法没有指定泛型类型参数，编译器会根据传入的参数自动推断出类型。

如果你希望显式地指定泛型类型参数，可以使用类型注解来强制类型声明。

示例代码

以下是一个使用类型注解的例子：

void printAnything<T>(T value) {
  print(value);
}

void main() {
  printAnything<String>('Hello');  // 输出：Hello
  printAnything<int>(42);          // 输出：42
}

在这个例子中，我们显式地指定了 printAnything 方法的类型参数为 String 和 int，确保了类型安全。

在Dart中，集合（如 List, Map, Set）都可以使用泛型来指定元素的类型，从而确保类型安全。

示例代码

以下是一个使用泛型集合的例子：

void main() {
  List<String> names = ['Alice', 'Bob', 'Charlie'];
  Set<int> numbers = {1, 2, 3, 4, 5};
  Map<String, int> scores = {'Alice': 90, 'Bob': 85, 'Charlie': 95};

  print(names);
  print(numbers);
  print(scores);
}

在这个例子中，List<String> 表示一个只包含字符串的列表，Set<int> 表示一个只包含整数的集合，Map<String, int> 表示一个键为字符串，值为整数的映射。

要创建泛型集合，你需要使用类型参数来指定集合中元素的类型。例如，你可以创建一个只包含整数的 List，或者一个只包含字符串的 Set。

示例代码

以下是一个创建泛型集合的例子：

void main() {
  List<int> intList = [1, 2, 3, 4, 5];
  Set<String> stringSet = {'Alice', 'Bob', 'Charlie'};
  Map<String, double> scoreMap = {'Alice': 90.5, 'Bob': 85.0, 'Charlie': 95.5};

  print(intList);
  print(stringSet);
  print(scoreMap);
}

在这个例子中，我们创建了一个只包含整数的 List，一个只包含字符串的 Set，以及一个键为字符串，值为双精度浮点数的 Map。

在Dart中，你可以定义泛型方法来处理多种类型的参数。通过使用泛型方法，你可以编写更通用的代码，而无需针对特定类型编写多个不同的方法。

示例代码

以下是一个定义泛型方法的例子：

void printElement<T>(T element) {
  print(element);
}

void main() {
  printElement<String>('Hello, World!');
  printElement<int>(42);
}

在这个例子中，printElement 是一个泛型方法，它接受一个类型参数 T。你可以使用任何类型来调用这个方法。

你也可以结合使用泛型类和泛型方法来编写更复杂的代码。通过使用泛型类，你可以创建可重用的类，它们可以在运行时处理多种不同的类型。

示例代码

以下是一个结合使用泛型类和泛型方法的例子：

class Box<T> {
  T content;

  Box(this.content);

  void printContent() {
    print(content);
  }

  void printElement<T>(T element) {
    print(element);
  }
}

void main() {
  Box<String> stringBox = Box<String>('Hello');
  Box<int> intBox = Box<int>(42);

  stringBox.printContent();  // 输出：Hello
  intBox.printContent();     // 输出：42

  stringBox.printElement<String>('Hello, World!');  // 输出：Hello, World!
  intBox.printElement<int>(42);                    // 输出：42
}

在这个例子中，Box 是一个泛型类，它有一个类型参数 T。你可以创建一个 Box<String> 实例来存储字符串，或者创建一个 Box<int> 实例来存储整数。同时，Box 类中定义了一个泛型方法 printElement，可以用来打印任何类型的元素。

通过结合使用泛型类和泛型方法，你可以编写出更加通用和可重用的代码。