Dart 开发语言概览

本文将从变量和运算符开始到类和库的使用来向你介绍 Dart 编程语言的主要功能，这里假设你已经有使用其它语言进行编程的经验。

你可以通过查看 Dart 库概览 学习更多关于 Dart 核心库的知识。若还想了解更多有关语言功能的详细内容，请参阅 Dart 编程语言规范。

备忘:

使用 DartPad 可以体验 Dart 的大部分语言功能 (了解更多)， 打开 DartPad

本页面内嵌了一些 DartPads 做例子展示，

如果你只看到了空白的框框（而没有任何内容），请查阅DartPad 常见问题页面。

一个简单的 Dart 程序

下面的应用程序代码用到了很多 Dart 的基本功能：

// Define a function.
printInteger(int aNumber) {
  print('The number is $aNumber.'); // 打印输出到控制台。
}
// Dart 程序从 main() 函数开始执行。
main() {
  var number = 42; // 声明并初始化一个变量。
  printInteger(number); // 调用一个函数。
}

下面是上述应用程序中使用到的代码片段，这些代码片段适用于所有（或几乎所有）的 Dart 应用：

// This is a comment.

• // 注释。

• 以双斜杠开头的一行语句称为单行注释。Dart 同样支持多行注释和文档注释。查阅注释获取更多相关信息。

• int

• A type. Some of the other built-in typesare String, List, and bool.表示一种数据类型。Dart 中一些其他的内置类型包括 String、List 和 bool。

• 42

• A number literal. Number literals are a kind of compile-time constant.表示一个数字字面量。数字字面量是一种编译时常量。

• print()

• A handy way to display output.一种便利的将信息输出显示的方式。

• '…' (或 "…")

• 表示字符串字面量。

• $variableName (或 ${expression})

• 表示字符串插值：字符串字面量中包含的变量或表达式。查阅字符串获取更多相关信息。

• main()

• The special, required, top-level function where app executionstarts. For more information, seeThe main() function.一个特殊且 必须的 顶级函数，Dart 应用程序总是会从该函数开始执行。查阅 main() 函数 获取更多相关信息。

• var

• A way to declare a variable without specifying its type.用于定义变量，通过这种方式定义变量不需要指定变量类型。

备忘:

本站的代码遵循 Dart 风格指南 中的约定。

重要概念

当你在学习 Dart 语言时, 应该牢记以下几点：

• 所有变量引用的都是 对象，每个对象都是一个 类 的实例。数字、函数以及 null 都是对象。所有的类都继承于 Object 类。

• 尽管 Dart 是强类型语言，但是在声明变量时指定类型是可选的，因为 Dart 可以进行类型推断。在上述代码中，变量 number 的类型被推断为 int 类型。如果想显式地声明一个不确定的类型，可以使用特殊类型 dynamic。

• Dart 支持泛型，比如 List<int>（表示一组由 int 对象组成的列表）或 List<dynamic>（表示一组由任何类型对象组成的列表）。

• Dart 支持顶级函数（例如 main 方法），同时还支持定义属于类或对象的函数（即 静态 和 实例方法）。你还可以在函数中定义函数（嵌套 或 局部函数）。

• Dart 支持顶级 变量，以及定义属于类或对象的变量（静态和实例变量）。实例变量有时称之为域或属性。

• Dart 没有类似于 Java 那样的 public、protected 和 private 成员访问限定符。如果一个标识符以下划线 (_) 开头则表示该标识符在库内是私有的。可以查阅 库和可见性 获取更多相关信息。

• 标识符 可以以字母或者下划线 (_) 开头，其后可跟字符和数字的组合。

• Dart 中 表达式 和 语句 是有区别的，表达式有值而语句没有。比如条件表达式 expression condition ? expr1 : expr2 中含有值 expr1 或 expr2。与 if-else 分支语句相比，if-else 分支语句则没有值。一个语句通常包含一个或多个表达式，但是一个表达式不能只包含一个语句。

• Dart 工具可以显示 警告 和 错误 两种类型的问题。警告表明代码可能有问题但不会阻止其运行。错误分为编译时错误和运行时错误；编译时错误代码无法运行；运行时错误会在代码运行时导致异常。

关键字

下面的表格中列出了 Dart 语言所使用的关键字。

应该避免使用这些单词作为标识符。但是，带有上标的单词可以在必要的情况下作为标识符：

• 带有上标 1 的关键字为 上下文关键字，只有在特定的场景才有意义，它们可以在任何地方作为有效的标识符。

• 带有上标 2 的关键字为 内置标识符，其作用只是在JavaScript代码转为Dart代码时更简单，这些关键字在大多数时候都可以作为有效的标识符，但是它们不能用作类名或者类型名或者作为导入前缀使用。

• 带有上标 3 的关键字为 Dart1.0 发布后用于支持异步相关的特性新加的。不能在由关键字 async、async 或 sync 标识的方法体中使用 await 或 yield 作为标识符。

其它没有上标的关键字为 保留字，均不能用作标识符。

变量

下面的示例代码将创建一个变量并将其初始化：

var name = 'Bob';

变量仅存储对象的引用。这里名为 name 的变量存储了一个 String 类型对象的引用，“Bob” 则是该对象的值。

name 变量的类型被推断为 String，但是你可以为其指定类型。如果一个对象的引用不局限于单一的类型，可以根据设计指南将其指定为 Object 或 dynamic 类型。

dynamic name = 'Bob';

除此之外你也可以指定类型：

String name = 'Bob';

备忘:

本文遵循 风格建议指南 中的建议，通过 var 声明局部变量而非使用指定的类型。

默认值

在 Dart 中，未初始化的变量拥有一个默认的初始化值：null。即便数字也是如此，因为在 Dart 中一切皆为对象，数字也不例外。

int lineCount;
assert(lineCount == null);

备忘:

assert() 的调用将会在生产环境的代码中被忽略掉。在开发过程中，assert(condition) 将会在 条件判断 为 false 时抛出一个异常。详情请查阅 Assert。

Final 和 Const

如果你不想更改一个变量，可以使用关键字 final 或者 const 修饰变量，这两个关键字可以替代 var 关键字或者加在一个具体的类型前。一个 final 变量只可以被赋值一次；一个 const 变量是一个编译时常量（const 变量同时也是 final 的）。顶层的 final 变量或者类的 final 变量在其第一次使用的时候被初始化。

备忘:

实例变量可以是 final 的但不可以是 const 的， final 实例变量必须在构造器开始前被初始化，比如在声明实例变量时初始化，或者作为构造器参数，或者将其置于构造器的 初始化列表中。

下面的示例中我们创建并设置两个 final 变量：

final name = 'Bob'; // Without a type annotation
final String nickname = 'Bobby';

你不能修改一个 final 变量的值：

name = 'Alice'; // Error: a final variable can only be set once.

使用关键字 const 修饰变量表示该变量为 编译时常量。如果使用 const 修饰类中的变量，则必须加上 static 关键字，即 static const（注意：顺序不能颠倒（译者注））。在声明 const 变量时可以直接为其赋值，也可以使用其它的 const 变量为其赋值：

const bar = 1000000; // 直接赋值 [Unit of pressure (dynes/cm2)]
const double atm = 1.01325 * bar; // 利用其它 const 变量赋值 (Standard atmosphere)

const 关键字不仅仅可以用来定义常量，还可以用来创建 常量值，该常量值可以赋予给任何变量。你也可以将构造函数声明为 const 的，这种类型的构造函数创建的对象是不可改变的。

var foo = const [];
final bar = const [];
const baz = []; // 相当于 `const []` (Equivalent to `const []`)

如果使用初始化表达式为常量赋值可以省略掉关键字 const，比如上面的常量 baz 的赋值就省略掉了 const。详情请查阅DON’T use const redundantly

没有使用 final 或 const 修饰的变量的值是可以被更改的，即使这些变量之前引用过 const 的值。

foo = [1, 2, 3]; // foo 的值之前为 const [] (Was const [])

常量的值不可以被修改：

baz = [42]; // 报错：常量不可以被赋值。(Error: Constant variables can't be assigned a value.)

As of Dart 2.5, you can define constants that usetype checks and casts (is and as),collection if and collection for,and spread operators (… and …?):

// Valid compile-time constants as of Dart 2.5.
const Object i = 3; // Where i is a const Object with an int value...
const list = [i as int]; // Use a typecast.
const map = {if (i is int) i: "int"}; // Use is and collection if.
const set = {if (list is List<int>) ...list}; // ...and a spread.

可以查阅 Lists、Maps 和 Classes 获取更多关于使用 const 创建常量值的信息。

内置类型

Dart 语言支持下列的类型：

• numbers
• strings
• booleans

• lists (也被称为 arrays)

• sets

• maps

• runes (用于在字符串中表示 Unicode 字符)

• symbols

可以直接使用字面量来初始化上述类型。例如 'This is a string' 是一个字符串字面量，true 是一个布尔字面量。

由于 Dart 中每个变量引用都指向一个对象（一个 类 的实例），你通常也可以使用 构造器 来初始化变量。一些内置的类型有它们自己的构造器。例如你可以使用 Map() 来创建一个 map 对象。

Numbers

Dart 支持两种 Number 类型：

• int

• 整数值；长度不超过 64位，具体取值范围依赖于不同的平台。在 DartVM 上其取值位于 -263 至 263 - 1 之间。编译成 JavaScript 的 Dart 使用 JavaScript 数字，其允许的取值范围在 -253 至 253 - 1 之间。

• double

• 64位的双精度浮点数字，且符合 IEEE 754 标准。

int 和 double 都是 num 的子类。num 中定义了一些基本的运算符比如 +、-、*、/ 等，还定义了 abs()、ceil() 和 floor() 等方法（位运算符，比如 » 定义在 int 中）。如果 num 及其子类不满足你的要求，可以查看 dart:math 库中的 API。

整数是不带小数点的数字，下面是一些定义整数字面量的例子：

var x = 1;
var hex = 0xDEADBEEF;

如果一个数字包含了小数点，那么它就是浮点型的。下面是一些定义浮点数字面量的例子：

var y = 1.1;
var exponents = 1.42e5;

从 Dart 2.1 开始，整型字面量将会在必要的时候自动转换成浮点数字面量：

double z = 1; // Equivalent to double z = 1.0.

版本提示:

在 Dart 2.1 之前，在浮点数上下文中使用整数字面量是错误的。

下面是字符串和数字之间转换的方式：

// 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');

The int type specifies the traditional bitwise shift (<<, >>), AND(&), and OR (|) operators. For example:

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

数字字面量为编译时常量。很多算术表达式只要其操作数是常量，则表达式结果也是编译时常量。

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

Strings

Dart 字符串是 UTF-16 编码的字符序列。可以使用单引号或者双引号来创建字符串：

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.";
// 代码中文解释
var s1 = '使用单引号创建字符串字面量。';
var s2 = "双引号也可以用于创建字符串字面量。";
var s3 = '使用单引号创建字符串时可以使用斜杠来转义那些与单引号冲突的字符串：\'。';
var s4 = "而在双引号中则不需要使用转义与单引号冲突的字符串：'";

可以在字符串中以 ${表达式} 的形式使用表达式，如果表达式是一个标识符，可以省略掉 {}。如果表达式的结果为一个对象，则 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 s = '字符串插值';
assert('Dart 有$s，使用起来非常方便。' == 'Dart 有字符串插值，使用起来非常方便。');
assert('使用${s.substring(3,5)}表达式也非常方便' == '使用插值表达式也非常方便。');

备忘:

== 运算符判断两个对象的内容是否一样，如果两个字符串包含一样的字符编码序列，则表示相等。

可以使用 + 运算符将两个字符串连接为一个，也可以将多个字符串挨着放一起变为一个：

var s1 = 'String '
    'concatenation'
    " works even over line breaks.";
assert(s1 ==
    'String concatenation works even over '
        'line breaks.');
var s2 = 'The + operator ' + 'works, as well.';
assert(s2 == 'The + operator works, as well.');
// 代码中文解释
var s1 = '可以拼接'
    '字符串'
    "即便它们不在同一行。";
assert(s1 == '可以拼接字符串即便它们不在同一行。');
var s2 = '使用加号 + 运算符' + '也可以达到相同的效果。';
assert(s2 == '使用加号 + 运算符也可以达到相同的效果。');

可以使用三个单引号或者三个双引号创建多行字符串：

var s1 = '''
你可以像这样创建多行字符串。
''';
var s2 = """这也是一个多行字符串。""";

在字符串前加上 r 作为前缀创建 “raw” 字符串（即不会被做任何处理（比如转义）的字符串）：

var s = r'In a raw string, not even \n gets special treatment.';
// 代码中文解释
var s = r'在 raw 字符串中，转义字符串 \n 会直接输出 “\n” 而不是转义为换行。';

你可以查阅 Runes and grapheme clusters 获取更多关于如何在字符串中表示 Unicode 字符的信息。

字符串字面量是一个编译时常量，只要是编译时常量都可以作为字符串字面量的插值表达式：

// 可以将下面三个常量作为字符串插值拼接到字符串字面量中。(These work in a const string.)
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';

可以查阅 字符串和正则表达式 获取更多关于如何使用字符串的信息。

Booleans

Dart 使用 bool 关键字表示布尔类型，布尔类型只有两个对象 true 和 false，两者都是编译时常量。

Dart 的类型安全不允许你使用类似 if (nonbooleanValue) 或者 assert (nonbooleanValue) 这样的代码检查布尔值。相反，你应该总是显示地检查布尔值，比如像下面的代码这样：

// 检查是否为空字符串 (Check for an empty string).
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);

Lists

数组 Array 是几乎所有编程语言中最常见的集合类型，在 Dart 中数组由 List 对象表示。通常称之为 List。

Dart 中 List 字面量看起来与 JavaScript 中数组字面量一样。下面是一个 Dart List 的示例：

var list = [1, 2, 3];

备忘:

这里 Dart 推断出 list 的类型为 List<int>，如果往该数组中添加一个非 int 类型的对象则会报错。你可以阅读 类型推断 获取更多相关信息。

List 的下标索引从 0 开始，第一个元素的下标为 0，最后一个元素的下标为 list.length - 1。你可以像 JavaScript 中的用法那样获取 Dart 中 List 的长度以及元素：

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

如果想要创建一个编译时常量的 List，在 List 字面量前添加 const 关键字即可：

var constantList = const [1, 2, 3];
// constantList[1] = 1; // 取消注释将导致出错 (Uncommenting this causes an error.)

Dart 在 2.3 引入了 扩展操作符（…）和 null-aware 扩展操作符（…?），它们提供了一种将多个元素插入集合的简洁方法。

例如，你可以使用扩展操作符（…）将一个 List 中的所有元素插入到另一个 List 中：

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

如果扩展操作符右边可能为 null ，你可以使用 null-aware 扩展操作符（…?）来避免产生异常：

var list;
var list2 = [0, ...?list];
assert(list2.length == 1);

可以查阅扩展操作符建议获取更多关于如何使用扩展操作符的信息。

Dart 在 2.3 还同时引入了 Collection If 和 Collection For，在构建集合时，可以使用条件判断（if）和循环（for）。

下面示例是使用 Collection If 来创建一个 List 的示例，它可能包含 3 个或 4 个元素：

var nav = [
  'Home',
  'Furniture',
  'Plants',
  if (promoActive) 'Outlet'
];

下面示例是使用 Collection For 将列表中的元素修改后添加到另一个列表中的示例：

var listOfInts = [1, 2, 3];
var listOfStrings = [
  '#0',
  for (var i in listOfInts) '#$i'
];
assert(listOfStrings[1] == '#1');

你可以查阅集合中使用控制流建议获取更多关于使用 Collection If 和 Collection For 的细节内容和示例。

List 类中有许多用于操作 List 的便捷方法，你可以查阅泛型和集合获取更多与之相关的信息。

Sets

A set in Dart is an unordered collection of unique items.Dart support for sets is provided by set literals and the Set type.

版本提示:

尽管 Set 类型(type) 一直都是 Dart 的一项核心功能，但是 Set 字面量(literals) 却是在 Dart2.2 中才加入的。

下面是使用 Set 字面量来创建一个 Set 集合的方法：

var halogens = {'fluorine', 'chlorine', 'bromine', 'iodine', 'astatine'};

备忘:

Dart 推断 halogens 变量是一个 Set<String> 类型的集合，如果往该 Set 中添加类型不正确的对象则会报错。你可以查阅 类型推断 获取更多与之相关的内容。

可以使用在 {} 前加上类型参数的方式创建一个空的 Set，或者将 {} 赋值给一个 Set 类型的变量：

var names = <String>{}; // 类型+{}的形式创建Set。
// Set<String> names = {}; // 声明类型变量的形式创建 Set (This works, too).
// var names = {}; // 这样的形式将创建一个 Map 而不是 Set (Creates a map, not a set.)

Set 还是 map? Map 字面量语法同 Set 字面量语法非常相似。因为先有的 Map 字面量语法，所以 {} 默认是 Map 类型。如果忘记在 {} 上注释类型或赋值到一个未声明类型的变量上，那么 Dart 会创建一个类型为 Map<dynamic, dynamic> 的对象。

向一个已存在的 Set 中添加项目可以使用 add() 方法或 addAll() 方法：

var elements = <String>{};
elements.add('fluorine');
elements.addAll(halogens);

使用 .length 可以获取 Set 中元素的数量：

var elements = <String>{};
elements.add('fluorine');
elements.addAll(halogens);
assert(elements.length == 5);

可以在 Set 字面量前添加 const 关键字创建一个 Set 编译时常量：

final constantSet = const {
  'fluorine',
  'chlorine',
  'bromine',
  'iodine',
  'astatine',
};
// constantSet.add('helium'); // 取消注释将导致出错 (Uncommenting this causes an error).

从 Dart 2.3 开始，Set 可以像 List 一样支持使用扩展操作符（… 和 …?）以及 Collection If 和 Collection For 操作。你可以查阅 List 扩展操作符和List 集合操作符获取更多相关信息。

你也可以查阅泛型以及 Set 获取更多相关信息。

Maps

通常来说， Map 是用来关联 keys 和 values 的对象。keys 和 values 可以是任何类型的对象。在一个 Map 对象中一个 key 只能出现一次。但是 value 可以出现多次。 Dart 中 Map 通过 Map 字面量和 Map 类型来实现。通常来说，Map 是一个键值对相关的对象。其中键和值都可以是任何类型的对象。每个 键 只能出现一次但是 值 可以重复出现多次。Dart 中 Map 提供了 Map 字面量以及 Map 类型两种形式的 Map。

下面是一对使用 Map 字面量创建 Map 的例子：

var gifts = {
  // 键:    值
  'first': 'partridge',
  'second': 'turtledoves',
  'fifth': 'golden rings'
};
var nobleGases = {
  2: 'helium',
  10: 'neon',
  18: 'argon',
};

备忘:

Dart 将 gifts 变量的类型推断为 Map<String, String>，而降 nobleGases 的类型推断为 Map<int, String>。如果你向这两个 Map 对象中添加不正确的类型值，将导致运行时异常。你可以阅读 类型推断获取更多相关信息。

你也可以使用 Map 的构造器创建 Map：

var gifts = Map();
gifts['first'] = 'partridge';
gifts['second'] = 'turtledoves';
gifts['fifth'] = 'golden rings';
var nobleGases = Map();
nobleGases[2] = 'helium';
nobleGases[10] = 'neon';
nobleGases[18] = 'argon';

备忘:

这里为什么使用 Map() 而不是使用 new Map() 构造 Map 对象。因为从 Dart2 开始，构造对象的 new 关键字可以被省略掉。你可以查阅 构造函数的使用获取更多相关信息。

向现有的 Map 中添加键值对与 JavaScript 的操作类似：

var gifts = {'first': 'partridge'};
gifts['fourth'] = 'calling birds'; // 添加键值对 (Add a key-value pair)

从一个 Map 中获取一个值的操作也与 JavaScript 类似。

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

如果检索的 Key 不存在于 Map 中则会返回一个 null：

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

使用 .length 可以获取 Map 中键值对的数量：

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

在一个 Map 字面量前添加 const 关键字可以创建一个 Map 编译时常量：

final constantMap = const {
  2: 'helium',
  10: 'neon',
  18: 'argon',
};
// constantMap[2] = 'Helium'; // 取消注释将导致出错 (Uncommenting this causes an error).

从 Dart 2.3 Map 可以像 List 一样支持使用扩展操作符（… 和 …?）以及 Collection If 和 Collection For 操作。你可以查阅 List 扩展操作符和 List 集合操作符获取更多相关信息。

你也可以查阅泛型以及 Maps 获取更多相关信息。

Runes 与 grapheme clusters

在 Dart 中，runes 公开了字符串的 Unicode 代码点。从 Dart 2.6 开始，使用 characters 包来访问或者操作用户感知的字符，也被称为 Unicode (扩展) grapheme clusters.。

Unicode 编码为每一个字母、数字和符号都定义了一个唯一的数值。因为 Dart 中的字符串是一个 UTF-16 的字符序列，所以如果想要表示 32 位的 Unicode 数值则需要一种特殊的语法。

通常使用 \uXXXX 来表示 Unicode 字符，XXXX 是一个四位数的 16 进制数字。例如心形字符（♥）的 Unicode 为 \u2665。对于不是四位数的 16 进制数字，需要使用大括号将其括起来。例如大笑的 emoji 表情（?）的 Unicode 为 \u{1f600}。

如果你需要读写单个 Unicode 字符，可以使用 characters 包中定义的 characters getter。它将返回 Characters 作为一系列 grapheme clusters的字符串。下面是使用 characters API 的样例：

import 'package:characters/characters.dart';
...
var hi = 'Hi ??';
print(hi);
print('The end of the string: ${hi.substring(hi.length - 1)}');
print('The last character: ${hi.characters.last}\n');

输出取决于你的环境，看上去会像这样：

$ dart bin/main.dart
Hi ??
The end of the string: ???
The last character: ??

有关使用 characters 包操作字符串的详细信息，请参阅用于 characters 包的样例和 API 参考。

备忘:

在使用 List 操作 Rune 的时候需要小心，根据所操作的语种、字符集等不同可能会导致字符串出现问题，具体可参考 Stack Overflow 中的提问： 我如何在 Dart 中反转一个字符串？。

Symbols

Symbol 表示 Dart 中声明的操作符或者标识符，该类型的对象几乎不会被使用到，但是如果需要按名称引用它们的 API 时就非常有用。因为代码压缩后会改变这些符号的名称但不会改变具体的符号。

可以使用在标识符前加 # 前缀来获取 Symbol：

#radix
#bar

Symbol 字面量是编译时常量。

Functions

Dart 是一种真正面向对象的语言，所以即便函数也是对象并且类型为 Function，这意味着函数可以被赋值给变量或者作为其它函数的参数。你也可以像调用函数一样调用 Dart 类的实例。详情请查阅 可调用的类。

下面是定义一个函数的例子：

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

虽然高效 Dart 指南建议在公开的 API 上定义返回类型，不过即便不定义，该函数也依然有效：

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

如果函数体内只包含一个表达式，你可以使用简写语法：

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

语法 => 表达式 是 { return 表达式; } 的简写，=> 有时也称之为胖箭头语法。

备忘:

在 => 与 ; 之间的只能是 表达式 而非 语句。比如你不能将一个 if语句 放在其中，但是可以放置 条件表达式。

函数可以有两种形式的参数：必要参数 和 可选参数。必要参数定义在参数列表前面，可选参数则定义在必要参数后面。可选参数可以是 命名的 或 位置的。

备忘:

某些 API，特别是 Flutter 控件的构造器，它只使用命名参数，即便参数是强制性的。可以查阅下一节获取更多信息。

可选参数

可选参数分为命名参数和位置参数，可在参数列表中任选其一使用，但两者不能同时出现在参数列表中。

命名参数

当你调用函数时，可以使用 参数名: 参数值 的形式来指定命名参数。例如：

enableFlags(bold: true, hidden: false);

When defining a function, use{参数1, 参数2, …}to specify named parameters:

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

/// 设置 [bold] 和 [hidden] 标识……
/// Sets the [bold] and [hidden] flags...
void enableFlags({bool bold, bool hidden}) {...}

虽然命名参数是可选参数的一种类型，但是你仍然可以使用 @required 注解来标识一个命名参数是必须的参数，此时调用者则必须为该参数提供一个值。例如：

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

如果调用者想要通过 Scrollbar 的构造函数构造一个 Scrollbar 对象而不提供 child 参数，则会导致编译错误。

@required 注解定义在 meta 包中，可以直接导入 package:meta/meta.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] 标识……
/// Sets the [bold] and [hidden] flags ...
void enableFlags({bool bold = false, bool hidden = false}) {...}
// bold 的值将为 true；而 hidden 将为 false。
enableFlags(bold: true);

在老版本的 Dart 代码中会使用冒号（:）而不是 = 来设置命名参数的默认值。原因在于刚开始的时候命名参数只支持 :。不过现在这个支持已经过时，所以我们建议你现在都 使用 = 来指定默认值。

下一个示例将向你展示如何为位置参数设置默认值：

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');

List 或 Map 同样也可以作为默认值。下面的示例定义了一个名为 doStuff() 的函数，并为其名为 list 和 gifts 的参数指定了一个 List 类型的值和 Map 类型的值。

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

main() 函数

每个 Dart 程序都必须有一个 main() 顶级函数作为程序的入口，main() 函数返回值为 void 并且有一个 List<String> 类型的可选参数。

下面是一个 Web 应用的 main() 函数示例：

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

备忘:

上述代码中的 .. 语法称之为 级联调用。使用级联访问可以在一个对象上执行多个操作。

下面是使用命令行访问带参数的 main() 函数示例：

// 使用命令 dart args.dart 1 test 运行该应用
// Run the app like this: dart args.dart 1 test
void main(List<String> arguments) {
  print(arguments);
  assert(arguments.length == 2);
  assert(int.parse(arguments[0]) == 1);
  assert(arguments[1] == 'test');
}

你可以通过使用 参数库 来定义和解析命令行参数。

函数作为一级对象

可以将函数作为参数传递给另一个函数。例如：

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闭包。你可以将匿名方法赋值给一个变量然后使用它，比如将该变量添加到集合或从中删除。

匿名方法看起来与命名方法类似，在括号之间可以定义参数，参数之间用逗号分割。

后面大括号中的内容则为函数体：

([[类型] 参数[, …]]) { 函数体; };

下面代码定义了只有一个参数 item 且没有参数类型的匿名方法。List 中的每个元素都会调用这个函数，打印元素位置和值的字符串：

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

点击运行按钮执行代码。

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

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);    }  }}

/// 返回一个将 [addBy] 添加到该函数参数的函数。/// Returns a function that adds [addBy] to the/// function's argument.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() {} // 定义顶层函数 (A top-level function)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;  // 这两个闭包引用了相同的实例对象，因此它们相等。  assert(y.baz == x);  // 这两个闭包引用了不同的实例对象，因此它们不相等。  assert(v.baz != w.baz);}

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

a++a + ba = ba == bc ? a : ba is T

// 括号提高了可读性。// Parentheses improve readability.if ((n % i == 0) && (d % i == 0)) …// 难以理解，但是与上面的代码效果一样。if (n % i == 0 && d % i == 0) …

assert(2 + 3 == 5);assert(2 - 3 == -1);assert(2  3 == 6);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');

var a, b;a = 0;b = ++a; // 在 b 赋值前将 a 增加 1。assert(a == b); // 1 == 1a = 0;b = a++; // 在 b 赋值后将 a 增加 1。assert(a != b); // 1 != 0a = 0;b = —a; // 在 b 赋值前将 a 减少 1。assert(a == b); // -1 == -1a = 0;b = a—; // 在 b 赋值后将 a 减少 1。assert(a != b); // -1 != 0

assert(2 == 2);assert(2 != 3);assert(3 > 2);assert(2 < 3);assert(3 >= 3);assert(2 <= 3);

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

(emp as Person).firstName = 'Bob';

// 将 value 赋值给 a (Assign value to a)a = value;// 当且仅当 b 为 null 时才赋值b ??= value;

var a = 2; // 使用 = 赋值 (Assign using =)a = 3; // 赋值并做乘法运算 Assign and multiply: a = a  3assert(a == 6);

if (!done && (col == 0 || col == 3)) {  // …Do something…}

final value = 0x22;final bitmask = 0x0f;assert((value & bitmask) == 0x02); // 按位与 (AND)assert((value & ~bitmask) == 0x20); // 取反后按位与 (AND NOT)assert((value | bitmask) == 0x2f); // 按位或 (OR)assert((value ^ bitmask) == 0x2d); // 按位异或 (XOR)assert((value << 4) == 0x220); // 位左移 (Shift left)assert((value >> 4) == 0x02); // 位右移 (Shift right)

var visibility = isPublic ? 'public' : 'private';

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

// 相对使用 ?: 运算符来说稍微长了点。(Slightly longer version uses ?: operator).String playerName(String name) => name != null ? name : 'Guest';// 如果使用 if-else 则更长。String playerName(String name) {  if (name != null) {    return name;  } else {    return 'Guest';  }}

querySelector('#confirm') // 获取对象 (Get an object).  ..text = 'Confirm' // 使用对象的成员 (Use its members).  ..classes.add('important')  ..onClick.listen((e) => window.alert('Confirmed!'));

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

final addressBook = (AddressBookBuilder()      ..name = 'jenny'      ..email = 'jenny@example.com'      ..phone = (PhoneNumberBuilder()            ..number = '415-555-0100'            ..label = 'home')          .build())    .build();

var sb = StringBuffer();sb.write('foo')  ..write('bar'); // 出错：void 对象中没有方法 write (Error: method 'write' isn't defined for 'void').

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

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

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

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

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

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

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

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

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());

var command = 'OPEN';switch (command) {  case 'CLOSED':    executeClosed();    break;  case 'PENDING':    executePending();    break;  case 'APPROVED':    executeApproved();    break;  case 'DENIED':    executeDenied();    break;  case 'OPEN':    executeOpen();    break;  default:    executeUnknown();}

var command = 'OPEN';switch (command) {  case 'OPEN':    executeOpen();    // 错误: 没有 break  case 'CLOSED':    executeClosed();    break;}

var command = 'CLOSED';switch (command) {  case 'CLOSED': // case 语句为空时的 fall-through 形式。  case 'NOWCLOSED':    // case 条件值为 CLOSED 和 NOW_CLOSED 时均会执行该语句。    executeNowClosed();    break;}

var command = 'CLOSED';switch (command) {  case 'CLOSED':    executeClosed();    continue nowClosed;  // 继续执行标签为 nowClosed 的 case 子句。  nowClosed:  case 'NOW_CLOSED':    // case 条件值为 CLOSED 和 NOW_CLOSED 时均会执行该语句。    executeNowClosed();    break;}

// 确保变量值不为 null (Make sure the variable has a non-null value)assert(text != null);// 确保变量值小于 100。assert(number < 100);// 确保这是一个 https 地址。assert(urlString.startsWith('https'));

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

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

throw 'Out of llamas!';

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

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

try {  breedMoreLlamas();} on OutOfLlamasException {  // 指定异常  buyMoreLlamas();} on Exception catch (e) {  // 其它类型的异常  print('Unknown exception: $e');} catch (e) {  // // 不指定类型，处理其它全部  print('Something really unknown: $e');}

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

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

try {  breedMoreLlamas();} finally {  // 总是清理，即便抛出了异常。  cleanLlamaStalls();}

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

var p = Point(2, 2);// 为实例变量 y 赋值。p.y = 3;// 获取 y 的值。assert(p.y == 3);// 调用变量 p 的 distanceTo() 方法。num distance = p.distanceTo(Point(4, 4));

// If p is non-null, set its y value to 4.// 如果 p 为非空则将其属性 y 的值设为 4p?.y = 4;

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

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

var p = const ImmutablePoint(2, 2);

var a = const ImmutablePoint(1, 1);var b = const ImmutablePoint(1, 1);assert(identical(a, b)); // 它们是同一个实例 (They are the same instance!)

// Lots of const keywords here.// 这里有很多 const 关键字const pointAndLine = const {  'point': const [const ImmutablePoint(0, 0)],  'line': const [const ImmutablePoint(1, 10), const ImmutablePoint(-2, 11)],};

// Only one const, which establishes the constant context.// 只需要一个 const 关键字，其它的则会隐式地根据上下文进行关联。const pointAndLine = {  'point': [ImmutablePoint(0, 0)],  'line': [ImmutablePoint(1, 10), ImmutablePoint(-2, 11)],};

var a = const ImmutablePoint(1, 1); // 创建一个常量 (Creates a constant)var b = ImmutablePoint(1, 1); // 不会创建一个常量 (Does NOT create a constant)assert(!identical(a, b)); // 这两变量并不相同 (NOT the same instance!)

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

class Point {  num x; // 声明实例变量 x 并初始化为 null。  num y; // 声明实例变量 y 并初始化为 null。  num z = 0; // 声明实例变量 z 并初始化为 0。}

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。}

class Point {  num x, y;  Point(num x, num y) {    // 还会有更好的方式来实现此逻辑，敬请期待。    this.x = x;    this.y = y;  }}

class Point {  num x, y;  // 在构造函数体执行前用于设置 x 和 y 的语法糖。  Point(this.x, this.y);}

class Point {  num x, y;  Point(this.x, this.y);  // 命名式构造函数  Point.origin() {    x = 0;    y = 0;  }}

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

// Initializer list sets instance variables before// the constructor body runs.// 使用初始化列表在构造函数体执行前设置实例变量。Point.fromJson(Map<String, num> json)    : x = json['x'],      y = json['y'] {  print('In Point.fromJson(): ($x, $y)');}

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

重定向构造函数

有时候类中的构造函数会调用类中其它的构造函数，该重定向构造函数没有函数体，只需在函数签名后使用（:）指定需要重定向到的其它构造函数即可：

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 关键字标识类的构造函数将会令该构造函数变为工厂构造函数，这将意味着使用该构造函数构造类的实例时并非总是会返回新的实例对象。例如，工厂构造函数可能会从缓存中返回一个实例，或者返回一个子类型的实例。

以下示例演示了从缓存中返回对象的工厂构造函数：

class Logger {
  final String name;
  bool mute = false;
  // _cache 变量是库私有的，因为在其名字前面有下划线。
  static final Map<String, Logger> _cache =
      <String, Logger>{};
  factory Logger(String name) {
    return _cache.putIfAbsent(
        name, () => Logger._internal(name));
  }
  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);
  }
}

Getter 和 Setter

Getter 和 Setter 是一对用来读写对象属性的特殊方法，上面说过实例对象的每一个属性都有一个隐式的 Getter 方法，如果为非 final 属性的话还会有一个 Setter 方法，你可以使用 get 和 set 关键字为额外的属性添加 Getter 和 Setter 方法：

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);
}

使用 Getter 和 Setter 的好处是，你可以先使用你的实例变量，过一段时间过再将它们包裹成方法且不需要改动任何代码，即先定义后更改且不影响原有逻辑。

备忘:

像自增（++）这样的操作符不管是否定义了 Getter 方法都会正确地执行。为了避免一些不必要的异常情况，运算符只会调用 Getter 一次，然后将其值存储在一个临时变量中。

抽象方法

实例方法、Getter 方法以及 Setter 方法都可以是抽象的，定义一个接口方法而不去做具体的实现让实现它的类去实现该方法，抽象方法只能存在于抽象类中。

直接使用分号（;）替代方法体即可声明一个抽象方法：

abstract class Doer {
  // 定义实例变量和方法等等……
  void doSomething(); // 定义一个抽象方法。
}
class EffectiveDoer extends Doer {
  void doSomething() {
    // 提供一个实现，所以在这里该方法不再是抽象的……
  }
}

抽象类

使用关键字 abstract 标识类可以让该类成为 抽象类，抽象类将无法被实例化。抽象类常用于声明接口方法、有时也会有具体的方法实现。如果想让抽象类同时可被实例化，可以为其定义工厂构造函数。

抽象类常常会包含抽象方法。下面是一个声明具有抽象方法的抽象类示例：

// This class is declared abstract and thus
// can't be instantiated.
// 该类被声明为抽象的，因此它不能被实例化。
abstract class AbstractContainer {
  // 定义构造函数、字段、方法等……
  void updateChildren(); // 抽象方法。
}

隐式接口

每一个类都隐式地定义了一个接口并实现了该接口，这个接口包含所有这个类的实例成员以及这个类所实现的其它接口。如果想要创建一个 A 类支持调用 B 类的 API 且不想继承 B 类，则可以实现 B 类的接口。

一个类可以通过关键字 implements 来实现一个或多个接口并实现每个接口定义的 API：

// A person. The implicit interface contains greet().
// Person 类的隐式接口中包含 greet() 方法。
class Person {
  // _name 变量同样包含在接口中，但它只是库内可见的。
  final _name;
  // 构造函数不在接口中。
  Person(this._name);
  // greet() 方法在接口中。
  String greet(String who) => '你好，$who。我是$_name。';
}
// Person 接口的一个实现。
class Impostor implements Person {
  get _name => '';
  String greet(String who) => '你好$who。你知道我是谁吗？';
}
String greetBob(Person person) => person.greet('小芳');
void main() {
  print(greetBob(Person('小芸')));
  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();
  }
  // ···
}

重写类成员

子类可以重写父类的实例方法、Getter 以及 Setter 方法。你可以使用 @override 注解来表示你重写了一个成员：

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

限定方法参数以及实例变量的类型可以让代码更加类型安全，你可以使用协变关键字。

重写运算符

可以在一个类中重写下表所罗列出的所有运算符。比如如果定一个 Vector 表示矢量的类，那么可以考虑重写 + 操作符来处理两个矢量的相加。

备忘:

必须要注意的是 != 操作符并不是一个可被重写的操作符。表达式 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);
  // 运算符 == 和 hashCode 的实现未在这里展示，详情请查看下方说明。
  // ···
}
void main() {
  final v = Vector(2, 3);
  final w = Vector(2, 2);
  assert(v + w == Vector(4, 5));
  assert(v - w == Vector(0, 1));
}

如果重写 == 操作符，必须也同时重写对象 hashCode 的 Getter 方法。你可以查阅实现映射键获取更多关于重写的 == 和 hashCode 的例子。

你也可以查阅扩展一个类获取更多关于重写的信息。

noSuchMethod()

如果调用了对象上不存在的方法或实例变量将会触发 noSuchMethod 方法，你可以重写 noSuchMethod 方法来追踪和记录这一行为：

class A {
  // 除非你重写 noSuchMethod，否则调用一个不存在的成员会导致 NoSuchMethodError。
  @override
  void noSuchMethod(Invocation invocation) {
  print('你尝试使用一个不存在的成员：' +
  '${invocation.memberName}');
  }
}

你不能调用一个未实现的方法除非下面其中的一个条件成立：

• 接收方是静态的 dynamic 类型。

• 接收方具有静态类型，定义了未实现的方法（抽象亦可），并且接收方的动态类型实现了 noSuchMethod 方法且具体的实现与 Object 中的不同。

你可以查阅 noSuchMethod 转发规范获取更多相关信息。

Extension 方法

Dart 2.7 中引入的 Extension 方法是向现有库添加功能的一种方式。你可能甚至都不知道有 Extension 方法。例如，当您在 IDE 中使用代码完成功能时，它建议将 Extension 方法与常规方法一起使用。

这里是一个在 String 中使用 extension 方法的样例，我们取名为 parseInt()，它在 string_apis.dart 中定义：

import string_apis.dart';
...
print('42'.padLeft(5)); // Use a String method.
print('42'.parseInt()); // Use an extension method.

有关使用以及实现 extension 方法的详细信息，请参阅extension methods 页面.

枚举类型

枚举类型是一种特殊的类型，也称为 enumerations 或 enums，用于定义一些固定数量的常量值。

Using enums

使用枚举

使用关键字 enum 来定义枚举类型：

enum Color { red, green, blue }

每一个枚举值都有一个名为 index 成员变量的 Getter 方法，该方法将会返回以 0 为基准索引的位置值。例如，第一个枚举值的索引是 0 ，第二个枚举值的索引是 1。以此类推。

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

可以使用枚举类的 values 方法获取一个包含所有枚举值的列表：

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

你可以在 Switch 语句中使用枚举，但是需要注意的是必须处理枚举值的每一种情况，即每一个枚举值都必须成为一个 case 子句，不然会出现警告：

var aColor = Color.blue;
switch (aColor) {
  case Color.red:
    print('红如玫瑰！');
    break;
  case Color.green:
    print('绿如草原！');
    break;
  default: // 没有该语句会出现警告。
    print(aColor); // 'Color.blue'
}

枚举类型有如下两个限制：

• 枚举不能成为子类，也不可以 mix in，你也不可以实现一个枚举。

• 不能显式地实例化一个枚举类。

你可以查阅 [Dart 编程语言规范][]获取更多相关信息。

使用 Mixin 为类添加功能

Mixin 是一种在多重继承中复用某个类中代码的方法模式。

使用 with 关键字并在其后跟上 Mixin 类的名字来使用 Mixin 模式：

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

定义一个类继承自 Object 并且不为该类定义构造函数，这个类就是 Mixin 类，除非你想让该类与普通的类一样可以被正常地使用，否则可以使用关键字 mixin 替代 class 让其成为一个单纯的 Mixin 类：

mixin Musical {
  bool canPlayPiano = false;
  bool canCompose = false;
  bool canConduct = false;
  void entertainMe() {
    if (canPlayPiano) {
      print('Playing piano');
    } else if (canConduct) {
      print('Waving hands');
    } else {
      print('Humming to self');
    }
  }
}