# 泛型 generices

本文作者：阳九五 (opens new window)

本站地址：https://blog.56321654.xyz (opens new window)

泛型在编译时提供类型安全, 这意味着你可以在编译时捕获类型错误, 而不是在运行时。

# 泛型使用

main(List<String> args) {
  var l = <String>[];
  l.add('aaa');
  l.add('bbb');
  l.add('ccc');
  print(l);

  var m = <int, String>{};
  m[1] = 'aaaa';
  m[2] = 'bbbb';
  m[3] = 'cccc';
  print(m);
}

[aaa, bbb, ccc]
{1: aaaa, 2: bbbb, 3: cccc}

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16

容器对象，在创建对象时都可以定义泛型类型。

# 泛型函数

V addCache<K, V>(K key, V val) {
  print('$key -> $val');
  return val;
}

main(List<String> args) {
  var key = addCache('url', 'https://blog.56321654.xyz/');
  print(key);
}

url -> https://blog.56321654.xyz/
https://blog.56321654.xyz/

1
2
3
4
5
6
7
8
9
10
11
12

# 构造函数泛型

class Phone<T> {
  final T name;
  Phone(this.name);
}

main(List<String> args) {
  var p = Phone<String>('YoungYang');
  print(p.name);
}

YoungYang

1
2
3
4
5
6
7
8
9
10
11

这是大多数情况下使用泛型的场景，在一个类的构造函数中

# 泛型限制

定义

class AndroidPhone {
  void startup() {
    print('Android Phone 开机');
  }
}

// 这个例子Phone只能传入AndroidPhone类
class Phone<T extends AndroidPhone> {
  final T mobile;
  Phone(this.mobile);
}

1
2
3
4
5
6
7
8
9
10
11

实例

main(List<String> args) {
  var ad = AndroidPhone();
  var p = Phone<AndroidPhone>(ad);
  p.mobile.startup();
}

Android Phone 开机

1
2
3
4
5
6
7

通过 extends 关键字可以限定你可以泛型使用的类型