Dart语言之旅（完全翻译版）

最早发表于nucode.cn(重建中)，Herbert部落格，NUCOSC开源

本文于2020/1/27修订，2018/12/02首次发表，为Dart语言之旅的完整翻译

写在前面

本文是参考了Dart官网 的教程、参考的机翻以及对于其他语言学习的经验来翻译的本入门教程，译者精力和学历有限，如有不妥之处欢迎指正。

本文出于知识共享的目的，转载请注明出处

在线编译

DartPad

概念

• Dart变量中的内容都是对象，对象都是类的实例，所有对象都是从Object类继承的
• Dart要求规定类型，但是可以自行推断类型。var num = 10; 就可以推断其类型为int（不需要类型之dynamic）
• Dart之泛型类型List (整数列表)or List （任何类型的对象列表）
• 主函数main(),支持自定义函数和函数嵌套
• 支持全局变量，私有变量。实例的变量可以称为字段或者属性
• 不具备数据保护相关的关键字，用（_)开头确定私有
• 标识符可以以字母或者（_）下划线开头，后面字母和数字任意组合

关键字

关键字列表
abstract 2	dynamic 2	implements 2	show 1
as 2	else	import 2	static 2
assert	enum	in	super
async 1	export 2	interface 2	switch
await 3	external 2	is	sync 1
break	extends	library 2	this
case	factory 2	mixin 2	throw
catch	false	new	true
class	final	null	try
const	finally	on 1	typedef 2
continue	for	operator 2	var
covariant 2	Function 2	part 2	void
default	get 2	rethrow	while
deferred 2	hide 1	return	with
do	if	set 2	yield 3

避免使用关键字作为标识符，如果有必要标数字的关键字可以作为标识符：

1. 上下文关键字标识符，仅在特定位置有含义
2. 内置标识符，简化js转移dart的工作，不能作为类或者类型的标识符，不能用作导入前缀
3. dart 1.0发布后添加的异步支持相关的更新，有限的保留字。不能使用await or yield作为任何函数体中的标识符标记async,async* or sync*

变量

* var（属于Object）& dynamic的辨析

• var可以被解析为任意类型，但是一旦确定就不可更改！
• dynamic的值不可以被编译器解析或者类型检查
• dynamic编译到Object中，dynamic编译时存在，运行时不存在

默认值

未初始化的默认值都为null，断言assert(condition);

final & const

不打算更改变量的值用final或者const定义变量。final变量只能被设置一次；const变量是编译时常量（const变量是隐式final的）。final的全局变量和类变量第一次使用的时候要被初始化。

注意：在实例变量中只可以用final而非const。必须在构造函数体之前初始化final变量（在变量声明，构造函数参数或者构造函数的初始化列表中。）

示例：

  final name = 'Bob';//无法再更改值

如果const变量在类内，请标记为static const,const属于Object类

  const bar = 1000000;//压力单位(dynes/cm2)
  const double atm = 1.01325*bar;//标准大气压

const不仅仅可以声明常变量，也可以用来创建常量值constant values，以及声明常量值的构造函数，任何变量都可以具有常量值。

  var foo = const [];
  final bar = const [];
  const baz = [];//与"const []"等价

• 可以省略声明const的初始化表达式，如上所示。不要冗余使用const！
• 你可以修改非final，非const变量的值，即使变量曾用过const的值

  foo = [1,2,3];√
  baz = [1,2,3];×

内置类型

• 数字
• 字符串
• 布尔型
• 列表（数组）
• 地图map
• 符文runes（用于在字符串中表示Unicode字符）
• 符号symbols

因为Dart中的每个变量都引用一个对象 - 一个类的实例 - 您通常可以使用构造函数来初始化变量。一些内置类型有自己的构造函数。例如，您可以使用Map()构造函数来创建地图。 ——来源于官网引用

数字

• int

  整数值不大于64位，具体视平台而定

• double

  64位双精度浮点数，IEEE 754标准

  int & double都属于数字这一类型，数字基本运算符有+、-、*、/之类的，也包括abs()、ceil()、floor()和其他方法。（类似于">>"的位运算符，在int类中被定义），如果在num及其子类中没有要找的，去dart:math库中看看！

int示例

  int x = 1;
  int hex = 0xDEADBEEF;

double示例

  double y = 1.1;
  double exponents = 1.42e5;

以下是字符串如何转化为数字，反之亦然

  // String -> int
  var one = int.parse('1');
  assert(one == 1);

  // String -> double
  var onePointOne = double.parse('1.1');
  assert(onePointOne == 1.1);

  // int -> String
  String oneAsString = 1.toString();
  assert(oneAsString == '1');

  // double -> String
  String piAsString = 3.14159.toStringAsFixed(2);
  assert(piAsString == '3.14');

int类型指定移位操作（<<、>>）,AND（&）和OR（|）运算符。

  assert((3<<1)==6);// 0011 << 1 == 0110
  assert((3>>1)==1);// 0011 >> 1 == 0001
  assert((3|4)==7);// 0011 | 0100 == 0111

Literal numbers（能力有限，不知道如何翻译）是编译时常量，很多的算术表达式也是编译时的常量，只要它们的操作数是编译为数字的编译时常量——引用自dart官网

  const msPerSecond = 1000;
  const secondsUntilRetry = 5;
  const msUntilRetry = secondsUntilRetry*msPerSecond;

字符串

Dart字符串是一系列的UTF-16代码单元，可以使用 ‘’ or “” 创建字符串。

示例

  var s1 = 'Single quotes work well for string literals.';
  var s2 = "Double quotes work just as well.";
  var s3 = 'It\'s easy to escape the string delimiter.'; // 译者注\'是转译输出'
  var s4 = "It's even easier to use the other delimiter.";

你可以将表达式的值置入字符串中通过使用${expression}。如果表达式是标识符，你可以跳过{}（就是省略{}）。要获取会对象对应的字符串，Dart会调用对象的toString()方法。

  var s = 'string interpolation';

  assert('Dart has $s, which is very handy.' == 'Dart has string interpolation, ' + 'which is very handy.');
  assert('That deserves all caps. ' + '${s.toUpperCase()} is very handy!' == 'That deserves all caps. ' + 'STRING INTERPOLATION is very handy!');

"=="运算符是测试两个对象是否是等价的，如果它们包含相同的代码单元序列，那么就是等价的。

你可以使用运算符’+'连接字符串（译者省略了演示代码）

另一种创建多行字符串的方法是：使用三个单引号或者双引号

  var s1 = '''
  多行字符串1
  ''';

  var s2 = """
  多行字符串2
  """;

你可以通过添加前缀r来创建原始字符串（在原始字符串中，字符串是不会被特殊处理的）

  var s = r'这是一个原始字符串';

有关如何在字符串中表示Unicode字符的详细信息，请参阅Runes。

只要任何插值表达式是一个编译时常量，其值为null或数值，字符串或布尔值；文字字符串即为编译时常量。

演示代码

  // 常字符串
  const aConstNum = 0;
  const aConstBool = true;
  const aConstString = 'a constant string';

  // 并非常字符串
  var aNum = 0;
  var aBool = true;
  var aString = 'a string';

  const aConstList = [1, 2, 3];
  const validConstString = '$aConstNum $aConstBool $aConstString';
  // const invalidConstString = '$aNum $aBool $aString $aConstList';

获取更多的字符串的使用信息，请参考字符串与正则表达式

布尔型

Dart用bool类表示布尔值，只有两个对象true、false，它们都是编译时常量。

Dart的类型安全意味着你不能使用类似于if(非布尔值)或者assert(非布尔值)的语句，不过可以明确地检查值，如示例：

  // 检查空字符串
  var fullName = '';
  assert(fullName.isEmpty);

  // 检查零
  var hitPoints = 0;
  assert(hitPoints <= 0);

  // 检查null
  var unicorn;
  assert(unicorn == null);

  // 检查NaN
  var iMeantToDoThis = 0 / 0;
  assert(iMeantToDoThis.isNaN);

列表

几乎每种语言中最常见的是数组或者有序对象组。在Dart中数组是List对象，因此大多人也称为列表。

Dart列表看起来想JavaScript数组。示例：

  var list = [1,2,3];

分析器推断list类型为list。如果将非int类型对象加入此列表，会引发错误。获取更多的信息，阅读有关 类型推断。

列表从零开始索引，0是列表的第一个元素索引，list.length - 1是列表的最后一个元素索引。可以像JavaScript那样获取一个列表的长度并引用元素。

  var list = [1,2,3];
  assert(list.length == 3);
  assert(list[1] == 2);

  list[1] == 1;
  assert(list[1] == 1);

创建一个编译时常量列表，在列表文字前添加const：

  var constantList = const [1,2,3]
  // 同样，值不可以更改

List类型有很多方便的方法来操作列表。有关更多信息，请参阅 泛型Generics 和 集合Collections 。

地图型Maps

译者注：根据译者对于其他语言的学习和开发经验，Dart语言的Maps型和Python中的字典是一样的，其中键就是key，值就是value。

通常，map型是一个有键值对构成的对象。键和值可以是任意类型的对象。键不能重复，而同样的值是可以的。Dart对于map的支持是通过地图文字和Map类型。

以下是一些简单使用map文字创建的Dart maps：

  var gifts = {
    // key:value
    'first': 'partridge',
    'second': 'turtledoves',
    'fifth': 'golden rings',
  };

  var nobleGases = {
    2: 'helium',
    10: 'neon',
    18: 'argon',
  };

解析推断gifts类型为Map，nobleGases的类型为Map。如果尝试去添加非对应类型的值，解析器或者运行的时候会报错。获取更多的信息，请参阅 类型推断 。

你也可以使用构造函数Map()创建相同的对象：

  var gifts = Map();
  gifts['first'] = 'partridge';
  gifts['second'] = 'turtledoves';

  // 不想写了，省略···

你可能想看到的是new Map()，而非Map()。从Dart 2开始，new关键字是可选的。有关详细信息，请参阅 使用构造函数 。

跟在JavaScript中一样，将新的键值对加到现有的地图中（译者注：在python的字典中其实也是这样的···）

  var gifts = {'first': 'partridge'};
  gifts['fourth'] = 'calling birds';

跟在JavaScript中一样的方式在地图中检索值，不在就返回null：（译者注：译者懒得注了）

  var gifts = {'first': 'partridge'};
  assert(gifts['first'] == 'partridge');
  assert(gifts['fifth'] == null);

使用.length获取map中键值对的数目

  var gifts = {'first': 'partridge'};
  gifts['fourth'] = 'calling birds';
  assert(gifts.length == 2);

常地图，定义与上面相似，不写了···

  final constantMap = const {
    2: 'helium',
    10: 'neon',
    18: 'argon',
  };
  // const改都报错，后面就不写了

获取更多的信息，请参阅 泛型Generics 和 地图型Maps

符文

在Dart中，符文是字符串中UTF-32代码点

Unicode为世界上所有书写系统中的每一个字母、数字、符号都定义了唯一的数值。由于Dart字符串是一系列的UTF-16代码单元，因此在字符串中表示32位要用特殊的语法。

表达Unicode代码点的常用的方法是\uXXXX，其中XXXX是4位十六进制值。例如心（）是\u2665。要指定多于或者少于4个十六进制值，请将值放在大括号里。例如，笑脸（）是\u{1f600}。

该字符串类有几个属性，你可以用它来提取符文信息。codeUnitAt和codeUnit属性返回16位编码单元。使用该runes属性获取字符串的符文。

以下示例说明了符文，16位代码单元和32位代码点之间的关系。

  main()
  {
    var clapping = '\u{1f44f}';
    print(clapping);
    print(clapping.codeUnits);
    print(clapping.runes.toList());

    Runes input = new Runes(
      '\u2665  \u{1f605}  \u{1f60e}  \u{1f47b}  \u{1f596}  \u{1f44d}');
    print(new String.fromCharCodes(input));
  }

注意：使用列表操作符文要小心，这种方法容易分解，具体取决于特定的语言，字符集和操作。更多信息，请在Stack Overflow上参阅 如何在Dart中反转字符串？ ——引用自dart官网

符号Symbols

符号对象表示Dart程序的操作或者声明。你可能不会去使用符号对象，但是它们对于API通过名称引用是非常有用的，因为缩小会更改标识符名称而不会更改标识符符号。（译者并不清楚官网这句话的具体含义，引用自Dart官网）

请使用符号文字获取标识符的符号（#后面跟着标识符）：

  #radix
  #bar

符号文字是编译时常量！

函数Function

Dart是一门面向对象的语言，即便是函数也是对象，并且具有类型 Function 。这意味着函数可以被赋值给变量，或者作为参数传递给其他函数。你也可以跟调用函数一样，调用Dart类的实例。有关信息请参阅 可调用类Callable classes 。

以下是一个实现函数的示例：

  bool isNoble(int atomicNumber){
    return _nobleGases[atomicNumber] != null;
  }

虽然Effective Dart建议 为公共API键入注释 ，但是省略类型，函数还是有效的

  isNoble(atomicNumber){
    return _nobleGases[atomicNumber] != null;
  }

对于只含有一个表达式的函数，可以使用简写的语法：

  bool isNoble(int atomicNumber) => _nobleGases[atomicNumber] != null;

该语法是速记，有时候称为 箭头语法 。=> expr {return expr;}

只有 表达式 而非 语句 可以出现在 “=>” 和 “;” 之间。例如，不能在其中放入if语句，但可以使用条件表达式。 （译者注：也就是类似于其他语言也有的条件判断表达式比如 ? : 和 if语句的区别）

函数可以有两种类型的参数：必需和可选。首先列出所需的参数，然后列出任何可选参数。命名的可选参数也可以标记为 @required 。有关详细信息，参阅下一节。

可选参数

可选参数可以是位置参数，也可以是命名参数，不局限于这些。

可选命名参数

调用函数的时候，可以使用 paramName: value 指定的命名参数。例如：

  enableFlags(bold: true, hidden: false);

定义函数时，使用 {param1, param2, …} 指定命名参数：

  // 设置[bold]和[hidden]标志flags...
  void enableFlags({bool bold, bool hidden}){...}

Flutter 实例创建表达式变得会更复杂，因此窗口小部件构造函数仅使用命名参数，使实例创建表达式更易于阅读。

可以使用 @required 在任何Dart代码（不仅仅是Flutter）中注释命名参数，以指示它是 必需参数 。例如：

  const Scrollbar({Key key, @required Widget child})

当一个构造Scrollbar，分析器会报错child不存在。

必需Required 在 元meta 包中被定义。可以直接导入 package:meta/meta.dart ，也可以导入另一个导出的包 meta，例如Flutter的包 package:flutter/material.dart 。

可选位置参数

包装一组函数参数在[]内标记它们作为可选位置参数：

  String say(String from, String msg, [String device]){
    var result = '$from says $msg';
    if (device != null){
      result = '$result with a $device';
    }
    return result;
  }

下面是一个没有可选参数情况下调用此函数的示例：

  assert(say('Bob', 'Howdy') == 'Bob says Howdy');

下面是一个带有第三个参数情况下调用此函数的示例：

  assert(say('Bob', 'Howdy', 'smoke signal') == 'Bob says Howdy with a smoke signal');

默认参数值

你的函数可以使用 “=” 给命名或者位置参数定义默认值。默认值必须是编译时常量。如果未设默认值，则默认值为null。

这是一个为命名参数设置默认值的示例：

  // 设置[bold]和[hidden]flag
  void enableFlags({bool bold = false,bool hidden = false}) {...}

  // bold值为true hidden为false
  enableFlags(bold: true);

在老代码中使用冒号取代等号设置命名参数，原因是原生的问题。只有冒号支持命名参数。这种支持遭到了反对，建议使用等号设置默认值。

这个示例演示了如何去给位置参数设置默认值

  String say(String from, String msg, [String device = 'carrier pigeon', String mood]){
    var result = '$from says $msg';
    if (device != null){
      result = '$result with a $device';
    }
    if (mood != null){
      result = '$result (in a $mood mood)';
    }
    return result;
  }

  assert(say('Bob', 'Howdy') == 'Bob says Howdy with a carrier pigeon');

你也可以将列表或者地图作为默认值传递。下面的示例定义了一个doStuff()的函数，为list参数指定了一个默认的列表，为gifts参数指定了一个默认的地图。

  void doStuff(
  {List list = const [1, 2, 3],
    Map gifts = const {
      'first': 'paper',
      'second': 'cotton',
      'third': 'leather'
    }
  }){
    print('list: $list');
    print('gifts: $gifts');
  }

main()函数

每一个app都必须有个顶级函数main()，相当于是app的入口。main()函数返回void并且有一个可选的List参数。

这是一个web app的main()函数示例：

  void main(){
    querySeletor('#sample_text_id')
      ..text = 'Click me!'
      ..onClick.listen(reverseText);
  }

…这个先于代码的语法称为 级联 。使用级联，你可以对单个对象的成员执行多个操作。

下面是一个带参数的main函数()的命令行app示例：

  // 像这样运行app：dart args.dart 1 test
  void main(List arguments){
    print(arguments);

    assert(arguments.length == 2);
    assert(int.parse(arguments[0]) == 1);
    assert(arguments[1] == 'test');
  }

你可以使用 args库 去定义和分析命令行参数。

函数作为第一类对象

你可以将一个函数作为参数传递给其他函数。比如：

  void printElement(int element){
    print(element);
  }

  var list = [1, 2, 3];

  // printElement作为参数传递
  list.forEach(printElement);

你也可以将函数分配给一个变量。比如：

  var loudify = (msg) => '!!! ${msg.toUpperCase()} !!!';
  assert(loudify('hello') == '!!! HELLO !!!');

这个例子使用了一个匿名函数。想了解更多，请看下节教程。

匿名函数

大多的函数都是被命名过的，比如main()或者printElement()。你也可以创建一个无名函数叫做 匿名函数 ，有时候也叫做 lambda 或者 closure 。比如你可以给一个变量指定一个匿名函数，以便你可以从一个集合中添加或者删除。

匿名函数和一个命名函数看起来很相似——没有或者数个参数，在逗号和括号之间用逗号和可选类型注释分隔。

下面的代码块包含了函数的主体

  ([Type] param1[, ...]){
    codeBlock;
  };

下面的例子中定义了一个带有未指定类型参数 item 的匿名函数。为列表中的每个项调用的函数将打印一个字符串，该字符串包含指定索引处的值。

  var list = ['apples', 'bananas', 'oranges'];
  list.forEach((item){
    print('${list.indexOf(item)}: $item');
    });

写入程序的输出结果为：

1. 0: apples
2. 1: bananas
3. 2: oranges

如果函数只包含了一个语句，你可以使用箭头表示法让代码更短。复制下面的代码到DartPad，然后点击run证明它在功能上是等价的。

  list.forEach(
    (item) => print('${list.indexOf(item): $item}')
    );

词汇作用域Lexical scope

Dart是一个有词汇作用域的语言，就意味着变量的作用域是静态定义的，只需通过代码的布局。你可以 “顺着花冠向外” （译者觉得这可能是一个比喻）去看变量是否在作用域范围内。

以下是在每个范围级别具有变量的嵌套函数的示例：

  bool topLevel = true;

  void main() {
    var insideMain = true;

    void myFunction() {
      var insideFunction = true;

      void nestedFunction() {
        var insideNestedFunction = true;

        assert(topLevel);
        assert(insideMain);
        assert(insideFunction);
        assert(insideNestedFunction);
      }
    }
  }

注意 nestedFunction()是如何使用每一级的变量，一直到顶级。

词汇闭包Lexical closures

闭包closure 是一个在它的词汇范围有权访问变量的函数对象，即使函数原来的范围之外。

函数关闭在周围定义的变量。在下面的示例中，makeAdder()捕获变量addBy。无论返回的函数在哪里，它都会记住addBy。

  // 返回一个函数，它为函数的参数添加[addBy]
  Function makeAdder(num addBy){
    return (num i) => addBy + i;
  }

  void main(){
    // 创造一个函数添加2
    var add2 = makeAdder(2);

    // 创造一个函数添加4
    var add4 = makeAdder(4);

    assert(add2(3) == 5);
    assert(add4(3) == 7);
  }

测试函数是否等价

下面是一个测试顶级函数，静态方法，实例方法等价性的例子：

  void foo() {} // 顶级函数
  class A {
    static void bar() {} // 静态方法
    void baz() {} // 实例方法
  }

  void main() {
    var x;

    // 比较顶级函数
    x = foo;
    assert(foo == x);

    // 比较静态方法
    x = A.bar;
    assert(A.bar == x);

    // 比较实例方法
    var v = A(); // A的实例#1
    var w = A(); // A的实例#2
    var y = w;
    x = w.baz;

    // 这些闭合参照的是一个实例（#2），所以它们是等价的
    assert(y.baz == x);

    // 这些闭合参照的是不同的实例，所以它们不等价
    assert(v.baz != w.baz);
  }

返回值

所有的函数都会返回值。如果没有返回值被指定，表达式返回null；隐式添加到函数体。

  foo() {}
  assert(foo() == null);

运算符

Dart定义了下述表格中的运算符。你可重载部分的运算符，在 重载运算符 中具体介绍。

类型	运算符
一元后缀	expr++ expr-- () [] . ?.
一元前缀	-expr !expr ~expr ++expr --expr
乘式	* / % ~/
和式	+ -
移位	<< >>
位与	&
位异或	^
位或	丨
	译者注：由于markdown的制表和位或运算的符号发生冲突，故使用的是丨（gun）代替
关系与类型测试	>= > <= as is is!
等价	== !=
逻辑与	&&
逻辑或	丨丨
	译者注：同上
如果null	??
控制表达式	expr1 ? expr2 : expr3
级联	…
赋值	= *= /= ~/= %= += -= <<= >>= &= ^= 丨= ??=

使用运算符可以创建表达式，下面是几个例子：

  a++
  a + b
  a = b
  a == b
  c ? a : b
  a is T

在 运算符表 中，每个运算符的优先级都高于后一行的优先级。例如 % 高于 == ，而 == 高于 && 。就意味着下面两行的代码执行方式是相同的。

  // 圆括号提高了可读性
  if ((n % i == 0) && (d % i == 0)) ...

  // 难读，但是是等价的
  if (n % i == 0 && d % i == 0)

注意：对于处理两个操作数的运算符，最左边的操作数确定运算符。——引用自官网

算术运算符

Dart支持通用的算术运算符，具体如下表：

运算符	意义
+	加
-	减
-expr	一元减号，也表示否定（反转表达式符号）
*	乘
/	除
~/	除，返回整数结果
%	取余

  // ** 译者在此省略了部分演示代码**
  assert(5 / 2 == 2.5);
  assert(5 ~/ 2 == 2);
  assert(5 % 2 == 1);

  assert('5/2 = ${5 ~/ 2} r ${5 % 2}' == '5/2 = 2 r 1');

Dart也支持带前缀和后缀的自加或自减运算 （具体的优先级及取值参照其他语言的基础）

等价与关系运算符

运算符	意义
==	等于；看下面讨论
!=	不等于
>	大于
<	小于
>=	不小于
<=	不大于

去测试两个对象 x、y 代表相同的东西，使用 == 运算符。（在极少数的情况下，你需要知道两个对象是不是同一个对象，使用identical()函数代替。）下面展示了 == 是如何工作的。

1. 如果 x 或者 y 为null，如果他俩都是null返回true，不然返回false
2. 返回方法调用的结果 x.==(y)。（这样是正确的，如同 == 的运算符是在第一个操作数上被调用的方法。你可以重载一些运算符，包括 == ，具体参考 重载运算符 ）

（举例略）

键入测试运算符

在程序运行的时候，as、is、is!运算符用于检查类型。

运算符	意义
as	类型转换
is	如果是指定类型返回true
is!	如果不是指定类型返回true

使用as运算符将对象强制转换为特定的类型。通常，应该使用它作为is对使用该对象的表达式后跟对象的测试的简写。

  if(emp is Person){
    // 检查类型
    emp.firstName = 'Bob';
  }

  // 你可以使用as让代码短一点
  (emp as Person).firstName = 'Bob';

这两个写法是不等价的，如果emp为null或者不是Person，第一个例子啥都不干，第二个例子抛出异常。

赋值运算符

（译者在这一部分省略了大量与其他语言重复的部分，只针对个别特殊的符号加以解析）

  b ??= value; // 如果b为null，值将会赋给b；如果不为空，b还是原来的值

（组合赋值运算符，略）

逻辑运算符

运算符	意义
!expr	非运算
丨丨	或运算
&&	与运算

按位和移位运算符

（运算之前，将值转化为二进制）

（译者按照 1为真，0为假编写解释）

运算符	意义
&	全真则真，一假则假
丨	一真则真，全假为假
^	位异或运算，同为假，异为真
~expr	假为真，真为假
<<	左移位
>>	右移位

条件表达式

Dart有两种运算符，可以简明使用if-else表达式

condition ? expr1 : expr2

真返回1结果，假返回2结果

expr1 ?? expr2

如果expr1非空，返回它的值；否则，返回2的结果

通过布尔表达式控制赋值，考虑?:

如果布尔表达式是用来测试是否为空的，考虑??

  String playerName(String name) => name ?? 'Guest';

前面的例子至少可以使用两种方式来编写，但是不简洁：

  // 精简使用?:
  String playerName(String name) => name != null ? name : 'Guest';

  // 使用if-else表达式写
  String playerName(String name){
    if (name != null){
      return name;
    }else{
      return 'Guest';
    }
  }

级联符号（…）

级联（…）允许你对同一个对象进行一系列的操作。除了函数的调用之外，你还可以访问同一对象上的字段。这通常可以节省创建临时变量的步骤，让代码书写更流畅。

  querySeletor('#confirm') // 获取一个对象
    ..text = 'Confirm' // 使用它的一个成员
    ..classes.add('important')
    ..onClick.listen((e) => window.alert('Confirmed!'));

第一个方法调用，querySeletor()，返回一个选择器对象。级联表示法后面的代码对此对象进行操作，忽略可能返回的后续值。

前面的示例相当于：

  var button = querySeletor('#confirm');
  button.text = 'Confirm';
  button.classes.add('import');
  button.onClick.listen((e) => window.alert('Confirmed!'));

你也可以嵌套你的级联：

  final addressBook = (AddressBookBuilder()
        ..name = 'jenny'
        ..email = '[email protected]'
        ..phone = (PhoneNumberBuilder()
              ..number = '415-555-0100'
              ..label = 'home')
            .build())
      .build();

注意在返回实际函数的对象上构造级联。比如，以下代码失败：

  var sb = StringBuffer();
  sb.write('foo')
    ..write('bar'); // error:write方法没有定义为void

sb.write()调用返回void，你不能在void这一类函数上构造级联。

注：严格意义上来说，对于级联的两点符号并不是运算符，只是Dart语法的一部分。

其他类型运算符

在其他的示例中，你已经见过大多的剩余的运算符了：

运算符	名称	意义
()	函数应用	表示函数的调用
[]	列表访问	引用列表中指定索引处的值
.	成员访问权限	指表达式的属性；示例：fool.bar从表达式foo中选择了属性bar
?.	条件成员访问	跟 ‘.’ 类似，但是运算符的左边可以为null，比如：foo?.bar 从foo中选择了bar属性即使foo为空（在这种情况下，foo?.bar的值为null）

了解更多的信息关于 . ，?. ，和 . 运算符，看 类Classes 。

流程控制语句

你可以用下述的Dart代码控制流程：

• if和else
• for循环
• while和do-while循环
• break和continue
• switch和case
• assert

你也可以使用try-catch和throw影响控制流程，在 异常Exceptions 中介绍。

if-else语句

Dart支持带有可选else的if语句，在下个例子中有演示。另见 条件表达式 。

  if (isRaining()){
    you.bringRainCoat();
  } else if (isSnowing()){
    you.wearJacket();
  } else {
    car.putTopDown();
  }

不像JavaScript，条件必须是布尔值，不能为其他。具体信息看 布尔 。

for循环

你可以使用标准的for循环迭代。

  var message = StringBuffer('Dart is fun');
  for (var i = 0; i < 5; i++){
    message.write('!');
  }

在Dart中for循环内部的闭包捕获了索引的值，避免了JavaScript中常见的陷阱。

  var callbacks = [];
  for (var i = 0; i < 2; i++){
    callbacks.add(() => print(i));
  }
  callbacks.forEach((c) => c());

如预期那样，先输出0后1。相反在JavaScript中这个例子先2后2。

如果迭代的对象是可迭代的，你可以使用forEach()方法。如果你不需要当前的迭代计数器，使用forEach()是个不错的选择。

  candidates.forEach((candidate) => candidate.interview());

类似于列表和集合这样的可迭代类也支持迭代的for-in结构：

  var collection = [0, 1, 2];
  for (var x in collection){
    print(x); // 0 1 2
  }

while和do-while

while控制条件在循环之前

  while (!isDone()) {
    doSomething();
  }

do-while控制条件在循环之后

  do{
    printLine();
  } while(!atEndOfPage());

break和continue

使用break停止循环

  while(true){
    if (shutDownRequested()) break;
    processIncomingRequests();
  }

使用continue跳到下一个循环迭代

  for (int i = 0; i < candidates.length; i++){
    var candidate = candidates[i];
    if (candidate.yearsExperience < 5){
      continue;
    }
    candidate.interview();
  }

如果你使用类似于列表、集合的 迭代 ，你可以以不同的方式写示例：

  candidates
      .where((c) => c.yearsExperience >= 5)
      .forEach((c) => c.interview());

switch和case

（跟C语言的结构并没有什么本质的区别，略，case内局部变量只在内部有效）

断言assert

如果布尔值为false，使用assert语句将中断程序的正常执行。你可以在这愉快之旅中的例子中感受assert语句的用法。

  // 确认变量有个非空的值
  assert(text != null);

  // 确认值比100小
  assert(number < 100);

  // 确认是个https链接
  assert(urlString.startsWith('https'));

注：断言语句对生产代码并没有什么影响；它们只是用于开发。Flutter允许断言在 debug模式 。仅限开发的工具（比如dartdevc）通常默认支持断言。一些工具如dart,dart2js通过命令行标志支持断言：–enable-asserts

将消息加到断言，添加字符串作为第二参数。

  assert(urlString.startsWith('https'),'URL ($urlString) should start with "https".');

第一个参数assert可以是任何解析为布尔值的表达式。如果表达式的值为true，则断言成功并继续执行。如果为false，则断言失败并抛出异常（一个 断言错误 ）

异常Exceptions

Dart代码可以抛出和捕获异常，异常是指意外事件发生的错误。如果未能捕获异常，则会暂停引发异常的隔离，并且通常会终止隔离和程序。

与Java相比，所有的Dart异常都是未检查的异常。方法不会声明它们会抛出的异常，你也没必要捕获异常。

Dart提供了 异常 和 错误 两种类型，以及许多预定义的子类型，当然也可以自己定义的意外情况。Dart程序可以抛出任何非空对象-不仅仅是异常和错误对象-作为例外。

抛出throw

一个抛出或者引发异常的示例：

  throw FormatException('Expected at least 1 section');

你也可以任意对象：

  throw 'Out of llamas!';

注：生成有质量的代码通常会抛出 异常 和 错误 。

因为抛出异常是一种表达，你可以使用 => 语句抛出异常，在任何可以表达的地方：

  void distanceTo(Point other) => throw UnimplementedError();

捕获Catch

捕获，会阻止异常的传播（除非重新抛出异常）。捕获异常使有机会处理它：

  try{
    breedMoreLlamas();
  } on OutOfLlamasException {
    buyMoreLlamas();
  }

要处理可能抛出多种异常的代码，可以指定多个捕获子句。与抛出对象类型匹配的第一个子句处理异常。如果捕获子句未指定类型，则该子句可以处理任何异常：

  try{
    breedMoreLlamas();
  } on OutOfLlamasException {
    // 一个指定异常
    buyMoreLlamas();
  } on Exception catch (e) {
    // 其他任何异常
    print('Unkown exception: $e');
  } catch (e) {
    // 没有指定类型，可以处理所有
    print('Someting really unkown: $e');
  }

如上面的代码所示，你可使用on或catch，或者一起用。使用on时需要指定异常的类型。使用catch时，你的异常处理程序需要异常对象。

你可以指定一个或者两个catch()参数。第一个抛出异常，第二个是堆栈跟踪（StackTrace 对象）

  try{
    // ...
  } on Exception catch (e) {
    print('Exception details:\n $e');
  } catch (e, s) {
    print('Exception details:\n $e');
    print('Stack trace:\n $s');
  }

要处理部分异常，并允许它传播，请使用关键字rethrow。

  void misbehave() {
    try {
      dynamic foo = true;
      print(foo++); // runtime错误
    } catch (e) {
      print('misbehave() partially handled ${e.runtimeType}.');
      rethrow; // 允许调用者查看异常
    }
  }

  void main(){
    try{
      misbehave();
    } catch (e) {
      print('main() finished handling ${e.runtimeType}.');
    }
  }

最后Finally

无论是否抛出异常，要确保某些代码的运行，请使用finally子句。如果没有catch子句匹配该异常，则在finally子句运行后传播异常。

  try{
    breedMoreLlamas();
  } finally {
    // 总是被清理，即使有其他异常
    cleanLlamaStalls();
  }

finally子句在任何匹配的catch子句之后运行：

  try{
    breedMoreLlamas();
  } catch (e) {
    print('Error: $e'); // 首先处理异常
  } finally {
    cleanLlamaStalls(); // 然后清理
  }

了解更多，请阅读库之旅的 异常 部分。

类

Dart是一门面向对象的语言，具有类以及基于mixin的继承。每个对象都是一个类的实例，所有的类都来自于Object。基于Mixin的继承意味着即使每个类（除了Object）只有一个超类（父类），但是类体可以在多个类层次结构中重用。

使用类成员

对象有由函数和数据（分别为方法和实例变量）组成的成员。调用方法时，可以在对象上调用它：该方法可以访问该对象的函数和数据。

使用点（.）来引用实例变量或者方法：

  var p = Point(2, 2);

  // 设置实例变量y的值
  p.y = 3;

  // 获取y的值
  assert(p.y == 3);

  // 在p上调用distanceTo()
  num distance = p.distanceTo(Point(4, 4));

使用 ?. 代替 . 避免最左边的操作数为空的情况

  // 如果p不为空，把它的y的值设为4
  p?.y = 4;

使用构造函数

你可以使用构造函数来创造对象。构造函数的名称可以是 ClassName 或 ClassName.identifier。举例，下面的代码创建了一个Point对象使用了构造函数 Point() 和 Point.fromJson()：

  var p1 = Point(2, 2);
  var p2 = Point.fromJson({'x': 1, 'y': 2});

下面的代码的效果是一样的，但是在构造函数之前使用了可选的关键字 new

  var p1 = new Point(2, 2);
  var p2 = new Point.fromJson({'x': 1, 'y': 2});

版本提示：在Dart2中new才是可选的

一些类提供了常构造函数。使用常构造函数去创建一个编译时的常量，在构造函数的名称前添加关键词 const 。

  var p = const ImmutablePoint(2, 2);

构造两个相同的编译时常量会产生一个规范的实例：

  var a = const ImmutablePoint(1, 1);
  var b = const ImmutablePoint(1, 1);

  assert(identical(a, b));// 它们是相同的实例

在常量的上下文中，你可以省略构造函数或者文字前的 const 关键字，比如，看这段创造一个常地图代码。

  // 这有太多的const关键字

  const pointAndLine = const {
    'point': const [const ImmutablePoint(0, 0)],
    'line': const [const ImmutablePoint(1, 10), const ImmutablePoint(-2, 11)],
  };

你可以省略除了第一个const关键字

  // 只用一个const
  const pointAndLine = {
    'point': [ImmutablePoint(0, 0)],
    'line': [ImmutablePoint(1,10), ImmutablePoint(-2, 11)],
  };

如果一个常构造函数在常上下文外被调用没有const，它创建了一个非 常对象：

  var a = const ImmutablePoint(1, 1);// 创造了一个常对象
  var b = ImmutablePoint(1, 1);// 未创造一个常对象

  assert(!identical(a, b));// 它们不是相同的实例

版本提示：在Dart2中在常上下文中const才是可选的。

获取一个对象的类型

在程序执行的过程中获取对象的类型，你可以使用Object的runtimeType属性，返回 类型Type 对象。

  print('The type of a is ${a.runtimeType}');

到目前为止，你已经了解如何使用类了。本节的其余部分将介绍如何实现类。

实例变量

这里展示了如何去声明一个实例变量：

  class Point{
    num x; // 声明实例变量x，初始值为空
    num y; // 声明变量y，初始值为空
    num z=0; // 声明变量，初始值为0
  }

没有初始化的变量的值为null

所有的实例变量都生成一个隐式的getter方法。非最终实例变量（Non-final）也生成一个setter方法。获取更多的细节，参照 Getters和Setters

  class Point {
    num x;
    num y;
  }

  void main(){
    var point = Point();
    point.x = 4; // 对x使用setter方法
    assert(point.x == 4); // 对x使用getter方法
    assert(point.y == null); // 默认值为null
  }

如果你在实例对象声明的地方初始化对象（而不是在构造函数或者方法中），当实例被创建的时候值就已经被设置了，在构造函数和初始化列表执行之前。

构造函数

通过创建一个跟它的类同名的构造函数来实现构造函数的声明。（plus，可选的，还有一个额外的标识符，如同 命名构造函数 所述）

最常见的构造函数形式，即生成构造函数，创造类的一个新实例：

  class Point {
    num x, y;
    Point (num x, num y) {
      // 有更好的方法去做这个

      this.x = x;
      this.y = y;
    }
  }

this关键字指向现况的实例

使用this时这会有一个命名冲突。否则，Dart代码将会省略this。

将构造函数的值赋给实例变量的模式是很常见的。Dart有语法sugar使实现更简单：

  class Point {
    num x, y;

    // 使用语法sugar设置x，y的值
    // 在构造函数体运行之前
    Point(this.x, this.y);
  }

默认构造函数

如果自己没有声明构造函数，它会自己生成一个。默认生成的构造函数没有参数，并在超类（父类）中调用无参构造函数。

构造函数不是被继承的

子类不从超类（父类）中继承构造函数。声明没有构造函数的子类只有默认构造函数（无参数，无名称）。

命名构造函数

使用命名构造函数为类实现多个构造函数去实现更加的清晰。

  class Point {
    num x, y;

    Point(this.x, this.y);

    // 命名构造函数

    Point.origin() {
      x=0;
      y=0;
    }
  }

记住构造函数是不能被继承的，就意味着超类（父类的）命名构造函数也不能被子类继承。如果希望使用超类中定义的命名构造函数创建子类，则必须在子类中实现该构造函数。

调用非默认的超类构造函数

默认的，在子类调用的超类构造函数是没有命名、没有参数的。超类构造函数在构造函数的开头被调用；如果一个初始化列表也被调用，它将在超类调用之前执行。总之，执行顺序如下：

1. 初始化列表
2. 超类无参构造函数
3. 主类无参构造函数

如果超类没有未命名的无参构造函数，你必须手动在超类中调用一个构造函数。在冒号后面指定超类的构造函数，在构造函数体的前部。

在下面的示例中，Employee类的构造函数调用它的超类Person的命名构造函数

  class Person {
    String firstName;

    Person.fromJson(Map data) {
      print('in Person');
    }
  }

  class Employee extends Person {
    // Person没有默认的构造函数
    // 你必须调用super.fromJson(data)
    Employee.fromJson(Map data) : super.fromJson(data) {
      print('in Employee');
    }
  }

  main() {
    var emp = new Employee.fromJson({});
  }

  // Prints:
  // in Person
  // in Employee

  if (emp is Person){
    // 类型检查
    emp.firstName = 'Bob';
  }
  (emp as Person).firstName = 'Bob';

因为在调用构造函数之前会处理超类构造函数的参数，所以参数可以是一个表达式，比如函数调用：

  class Employee extends Person {
    Employee() : super.fromJson(getDefaultData());
    // ...
  }

注意：超类构造函数的参数没有this的权限，例如，参数可以调用静态方法但是不能调用实例方法。

初始化列表

除了调用超类的构造函数外，你也可以在构造函数体运行之前，初始化实例变量。用逗号分隔初始化：

  // 初始化列表在构造函数体运行之前设置实例的变量

  Point.fromJson(Map json)
    : x = json['x'],
      y = json['y'] {
        print('In Point.fromJson() : ($x, $y)');
      }

注意：初始化程序的右侧无权访问this。

在开发期间，你可以在初始化列表验证输入的值

  Point.withAssert(this.x, this.y) : assert(x >= 0) {
    print('In Point.withAssert() : ($x, $y)');
  }

设置final字段时，设置初始化列表很方便。在下面的示例中在初始化列表中初始化了三个final字段。

  import 'dart:math';

  class Point {
    final num x;
    final num y;
    final num distanceFromOrigin;

    Point(x, y)
      : x = x,
        y = y,
        distanceFromOrigin = sqrt(x * x + y * y);
  }

  main() {
    var p = new Point(2, 3);
    print(p.distanceFromOrigin);
  }

重定向构造函数

有时候构造函数只用于在同一个类中重定向到其他的构造函数。重定向构造函数的函数体是空的，构造函数的调用出现在冒号之后。

  class Point {
    num x, y;

    // 这个类的主构造函数
    Point(this.x, this.y);

    // 代表主构造函数
    Point.alongXAxis(num x) : this(x, 0);
  }

常构造函数

如果你的类生成不打算更改的对象，你可以使这些对象为编译时常量。为了去实现，定义一个const构造函数，并保证所有的实例变量都是final型。

  class ImmutablePoint {
    static final ImmutablePoint origin  = const ImmutablePoint(0, 0);

    final num x, y;
    const ImmutablePoint(this.x, this.y);
  }

常构造函数并不总是创造常量。更多细节，去看 使用构造函数 那一节。

工厂构造函数

使用关键字 factory 当实现构造函数不总在它的类中创建新的实例。比如，工厂构造函数可能从缓存（cache）中返回实例，或者返回子类型实例。

下面的示例演示了一个构造函数从缓存中返回了一个对象：

  class Logger {
    final String name;
    bool mute = false;

    // _cache是库私有，因为标识符前面的_
    static final Map _cache = {};

    factory Logger(String name) {
      if (_cache.containsKey(name)) {
        return _cache[name];
      } else {
        final logger = Logger._internal(name);
        _cache[name] = logger;
        return logger;
      }
    }
  }

  Logger._internal(this.name);

  void log(String msg) {
    if(!mute) print(msg);
  }

工厂构造函数没有this的权限。

调用工厂构造函数跟调用其他的构造函数一样：

  var logger = Logger('UI');
  logger.log('Button clicked');

方法

方法是赋予对象动作的函数。

实例方法

在对象中的实例方法有使用实例对象和this的权限。下面例子中的distanceTo()方法就是一个实例方法的示例：

  import 'dart:math';

  class Point{
    num x, y;

    Point(this.x, this.y);

    num distanceTo(Point other) {
      var dx = x - other.x;
      var dy = y - other.y;
      return sqrt(dx * dx + dy * dy);
    }
  }

Getters和Setters

Getters和Setters是提供了读写对象属性的特殊方法。回想一下，每一个实例变量都有一个隐性的getter，如果合适的话还有一个setter。你可以通过get和set关键字实现创建额外的属性。

  class Rectangle {
    num left, top, width, height;

    Rectangle(this.left, this.top, this.width, this.height);

    // 定义两个计算的属性：right和bottom
    num get right => left + width;
    set right(num value) => left = value - width;
    num get bottom => top + height;
    set bottom(num value) => top = value - height;
  }

  void main() {
    var rect = Rectangle(3, 4, 20, 15);
    assert(rect.left == 3);
    rect.right = 12;
    assert(rect.left == -8);
  }

通过getters和setters，你从实例变量开始，稍后使用方法包装它们，无需更改客户端的代码。

注意：无论是否明确定义了getter，如同++的运算符都会如于其那样工作。去避免任何不可预测的影响，运算发只需要调用一次getter，并将其值保存在临时变量中。

抽象类

使用abstract修饰符定义抽象类——不能被实例化的类，抽象类对于定义接口是非常有用的，通常还有一些实现。如果你想使抽象类初始化，那就定义一个 factory（工厂）构造函数 。

抽象类一般有抽象方法，下面是一个带有抽象方法的抽象类的示例：

  // 这个类被定义为抽象类，不能被实例化
  abstract class AbstractContainer {
    // 定义构造函数，域，方法。。。

    void updateChildren(); // 抽象方法
  }

隐式接口

每个类都隐式定义了一个接口，接口包含所有该类的实例成员及其实现的接口。如果你想在不继承B类的情况下创建支持B类API的A类，A类应该实现B接口。

类通过在implements子句中声明它们，然后提供接口所需的API来实现一个或者多个接口：

  // 一个Person，隐式接口包含greet()
  class Person {
    // 在界面中，仅能在这个库中可见
    final _name;

    // 因为是个构造函数，所以不在界面中
    Person(this._name);

    // 在界面中
    String greet(String who) => 'Hello, $who.I am &_name.'
  }

  // Person接口的实现
  class Impostor implements Person {
    get _name => '';

    String greet(String who) => 'Hi $who . Do you know who I am?'
  }

  String greetBob(Person person) => person.greet('Bob');

  void main(){
    print(greetBob(Person('Kathy')));
    print(greetBob(Impostor()));
  }

这是一个指定类实现多个接口的示例：

  class Point implements Comparable, Location {...}

扩展类（继承与派生）

使用extends创造子类，并且使用super指向超类：

  class Television {
    void turnOn() {
      _illuminateDisplay();
      _activateIrSensor();
    }
    // ...
  }

  class SmartTelevision extends Television {
    void turnOn() {
      super.turnOn();
      _bootNetworkInterface();
      _initializeMemory();
      _upgradeApps();
    }
    // ...
  }

重载成员

子类可以重写实例方法，getters，setters。你可以使用 @override 注释来指示你有意重载的成员：

  class SmartTelevision extends Television {
    @override
    void turnOn() {...}
    // ...
  }

在代码中，去限制方法参数或者实例变量的类型是 类型安全 的，你可以使用 协变关键字covariant keyword 。

重载运算符

你可以重载下表中的运算符。举个例子，如果你定义一个Vector类，你可以定义一个 + 方法相加两个vector（译者注：可以参考C++在这部分的内容）。

可重载运算符表
<	+	丨	[]
>	/	^	[]=
<=	~/	&	~
>=	*	<<	==
-	%	>>

你可能注意到了!=是不可以重载的运算符，表达式e1 != e2只是!(e1 == e2)的句法糖（译者注：看到这里，译者觉得所谓句法糖的意思，貌似是等价写法的意思，嘤嘤嘤）

下面是类重载运算符的一个例子：

  class Vector {
    final int x, y;

    Vector(this.x, this.y);

    Vector operator + (Vector v) => Vector(x + v.x, y + v.y);
    Vector operator - (Vector v) => Vector(x - v.x, y - v.y);

    // 运算符 == 和 哈希码并没有显示。更多的细节在后面的note中。
  }

  void main() {
    final v = Vector(2, 3);
    final w = Vector(2, 2);

    assert(v + w == Vector(4, 5));
    assert(v - w == Vector(0, 1));
  }

如果你重载了 == ，你也应该重载对象的哈希码getter。举个例子重载 == 和哈希码，参见 实现地图键（在库之旅中） 。

更多关于重载的信息，通常参考 扩展类（继承） 。

没有这个方法noSuchMethod()

要在代码中尝试使用不存在的方法或实例变量时，检测或做出反应，你可以重载noSuchMethod()：

  class A {
    // 除非你重载noSuchMethod，否则使用不存在的成员会导致NOSuchMethodError。

    @override
    void noSuchMethod(Invocation invocation) {
      print('You tried to use a non-existent member: ' + '${invocation.memberName}');
    }
  }

你 不可以 调用一个没有实现的方法，除非满足下面的任意一点：

• 接收器具有静态的类型dynamic

• 接收器具有静态的类型定义了没有实现的方法（抽象是可以的），接收器的dynamic类型有noSuchMethod()的实现，跟类对象是不一样的

更多请参照 noSuchMethod转发规范noSuchMethod forwarding specification

枚举类型Enumerated types

枚举类型，通常被称为 enumerations 或者 enums ，是被用来代表常量的固定数字的特殊一类。

使用枚举

使用关键字enum声明枚举类型：

  enum Color { red, green, blue }

每个枚举的值都有一个 索引index getter，返回从零开始的索引。

  assert(Color.red.index == 0);
  assert(Color.green.index == 1);
  assert(Color.blue.index == 2);

去获取枚举中所有值的列表，你可以使用枚举的values常方法

  List colors = Color.values;
  assert(Color[2] == Color.blue);

你可以在switch语句使用枚举，如果你不处理枚举的所有的值你将会收到警告。

  var aColor = Color.blue;

  switch (aColor) {
    case Color.red:
      print('Red as roses!');
      break;
    case Color.green:
      print('Green as grass!');
      break;
    default: // 避免警告
      print(aColor);
  }

枚举类型有下面的限制：

• 你不可以创建子类，混入，或者实现枚举
• 你不可以明确地实例化枚举

了解更多，参见 Dart语言规范 。

向类添加功能：混入mixins

Mixins是一种在多个类层次结构中重用类代码的方法。

使用 mixin，请使用with关键字后跟一个或多个mixin名称。以下示例显示了两个使用mixins的类：

  class Musician extends Performer with Musical {
    // ...
  }

  class Maestro extends Person with Musical, Aggressive, Demented {
    Maestro(String maestroName) {
      name = maestroName;
      canConduct = true;
    }
  }

去实现mixin，创建一个类并扩展对象、不要声明构造函数。除非您希望mixin可用作常规类，否则请使用mixin关键字而不是class。

  mixin Musical {
    bool canPlayPiano = false;
    bool canCompose = false;
    bool canConduct = false;

    void enterainMe() {
      if (canPlayPiano) {
        print('Playing Piano');
      } else if(canConduct) {
        print('Waving hands');
      } else {
        print('Humming to self');
      }
    }
  }

可以使用mixin指定一个明确的类型，举个例子，你的mixin可以调用一个没有定义的方法——使用on指向调用的超类。

  mixin MusicalPerformer on Musician {
    // ...
  }

版本提醒：在Dart2.1中介绍了对于mixin的支持。早期版本的代码通常使用抽象类代替。更多关于2.1中mixin变化的信息，参见 Dart SDK改变日志 Dart SDK changelog 和 2.1 mixin 规范 2.1 mixin specification。

类变量和方法

使用static关键字去实现类范围的变量和方法：

静态变量

静态变量（类变量）对类范围的状态和常量是非常实用的：

  class Queue {
    static const initialCapacity = 16;
    //...
  }

  void main(){
    assert(Queue.initialCapacity == 16);
  }

静态变量直到使用的时候才能被初始化。

此页遵循样式指南建议更偏向为常名称使用lowerCamelCase。

静态方法

静态方法（类方法）不在实例中作用，因此无this权限。

  import 'dart:math';

  class Point {
    num x, y;
    Point(this.x, this.y);

    static num distanceBetween(Point s, Point b) {
      var dx = a.x - b.x;
      var dy = a.y - a.y;
      return sqrt(dx * dx + dy * dy);
    }
  }

  void main() {
    var a = Point(2, 2);
    var b = Point(4, 4);
    var distance = Point.distanceBetween(a, b);
    assert(2.8 < distance && distance < 2.9);
    print(distance);
  }

对于常用或广泛使用的实用程序和功能，请考虑使用顶级函数而不是静态方法。

你可以使用静态方法作为编译时常量。举个例子，可以将静态方法作为参数传递给常量构造函数。

泛型Generics

如果你查看基础API文档数组，列表，你将会看到类型其实是List。<…>将列表标记为泛型（或者参数化）类型——具有正式参数类型的参数。按照惯例，类型变量有单个字母名称，比如E,T,S,K和V。

为什么要使用泛型

译者注：泛型即为模板

泛型常被用于类型安全，然而它们有比仅仅让你的代码运行的更多好处。

• 正确指定泛型类型可以生成更好的代码。
• 您可以使用泛型来减少代码重复。

如果你希望列表只包含字符串，你可以声明它为List（读作“字符串列表”）。这样，你，你的程序和你的工具检测列表中的非字符串参数是个错误。

  var names = List();
  names.addAll(['Seth', 'Kathy', 'Lars']);
  names.add(42); // 错误

使用泛型的另一个原因是减少代码重复。泛型允许您在多种类型之间共享单个接口和实现，同时仍然利用静态分析。比如创建一个缓存对象的接口

  abstract class ObjectCache {
    Object getByKey(String key);
    void setByKey(String Key, Object value);
  }

你发现你想创建一个指定字符串版本的接口，你创建另一个接口：

  abstract class StringCache {
    String getByKey(String key);
    void setByKey(String Key, String value);
  }

然后你又想创建一个指定数字版本的接口。。。

泛型类型可以解决你创建所有的这些接口的问题。取而代之，你可以带有类型参数创建单个接口：

  abstract class Cache {
    T getByKey(String key);
    void setByKey(String key, T value);
  }

在这段代码中，T是替身类型。它是一个占位符，您可以将其视为开发人员稍后定义的类型。

使用集合文字

列表和集合文字可以被参数化。参数化文字除了在括号之前添加类型，其他就像你之前看到的那样。

  var names = ['Seth', 'Kathy', 'Lars'];
  var pages = {
    'index.html': 'Homepage',
    'robot.txt': 'Hints for web robots',
    'humans.txt': 'We are people, not machines'
  };

使用带有构造函数的参数化类型

在使用构造函数的时候，指定一个或者多个类型，将类型放在类名后面的尖角括号之中

  var names = List();
  names.addAll(['Seth', 'Kathy', 'Lars']);
  var nameSet = Set.from(names);

下面的代码创建了一个整型键、View类型的地图

  var views = Map();

泛型集合和它们包含的类型

Dart泛型的类型具体化，意味着它们在运行时携带类型信息。

  var names = List();
  names.addAll(['Seth', 'Kathy', 'Lars']);
  print(names is List); // 输出true

相反，在Java中泛型擦除，就意味着在运行中删除泛型类型参数。在Java之中，你可以测试对象是否List，但是不能测试它是否是List。

限制参数化类型

当你实现泛型类型之时，你需要去限制参数的类型。你可以使用extends。

  class Foo {
    String toString() => "Instance of 'Foo<$T>'";
  }

  class Extender extends SomeBaseClass {...}

可以使用SomeBaseClass或其任何子类作为泛型参数：

  var someBaseClassFoo = Foo();
  var extenderFoo = Foo();

也可以不指定泛型参数：

  var foo = Foo();
  print(foo); // Instance of 'Foo'

指定非SomeBaseClass会导致错误：

  var foo = Foo