Dart 2官方文档中文版（Dart 编程语言导览）Part 2

构造函数

通过和类相同的名称创建函数来声明构造函数（以及命名构造函数中所描述的可选额外标识符）。最常见形式的构造函数，生成构造函数，创建一个类的新实例：

class  Point  {

  num  x,  y;

  Point(num  x,  num  y)  {

    // 有更好的实现方式，请保持关注

    this.x  =  x;

    this.y  =  y;

  }

}

this 关键字引用的是当前实例。

Note: 仅在有名称冲突时使用 this 。否则Dart 的样式省略 this。

为实例变量赋值构造函数的参数非常普通 ，Dart提供了语法糖来进行简化：

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;

  }

}

记住构造函数并不会继承，也就表示超类的构造函数不会由子类继承。如果希望通过超类中定义的命名构造函数创建子类 ，必须在子类中实现这个构造函数。

调用非默认超类构造函数

默认，子类中的构造函数调用超类中的未命名、无参数的构造函数。超类的构造函数在构造函数体的开头调用。如果还使用了 初始化程序列表，它在超类调用前执行。总之，执行的顺序如下：

1. 初始化程序列表initializer list
2. 超类的无参构造函数
3. 主类的无参构造函数

如果超类中没有未命名的无参构造函数，那么就必须手动调用超类的一个构造函数。在冒号(:)后、刚好在构造函数体前（如有）指定超类构造函数。

在下例中，Employee类的构造函数调用其超类Person的命名构造函数。点击 Run 来执行代码。

点击查看

因为超类构造函数的参数在调用构造函数前运行，参数可以是像函数调用这样的表达式：

class  Employee  extends  Person  {

  Employee()  :  super.fromJson(getDefaultData());

  // ···

}

Warning: 超类构造函数的参数无法访问 this。例如，参数可调用静态方法但无法调用实例方法。

初始化程序列表

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

// 初如化程序列表在构造函数体运行前

// 设置实例变量

Point.fromJson(Map  json)

    :  x  =  json['x'],

      y  =  json['y']  {

  print('In Point.fromJson(): ($x, $y)');

}

Warning: 初始化程序的右侧无法访问 this。

在开发过程中，可以在初始化程序列表中使用assert来验证输入。

Point.withAssert(this.x,  this.y)  :  assert(x  >=  0)  {

  print('In Point.withAssert(): ($x, $y)');

}

初始化程序列表在设置final字段时非常方便。以下示例在初始化程序列表中初始化了3个final字段。点击 Run 来执行代码。

点击查看

重定向构造函数

有时构造函数的目的仅是重定向到相同类中的其它构造函数。重定向构造函数体为空，构造函数调用出现在冒号(:)之后。

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  _cache  =

      {};

  factory Logger(String  name)  {

    return  _cache.putIfAbsent(

        name,  ()  =>  Logger._internal(name));

  }

  Logger._internal(this.name);

  void  log(String  msg)  {

    if  (!mute)  print(msg);

  }

}

Note: 工厂构造函数无法访问 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，以及如若合适时的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，可以以实例变量开始，然后通过方法封装它们，都无需修改客户端模式。

Note: 不论是否显式的定义getter递增 (++)等运算符都以预期的方式运行。 为避免任意预期的副作用，运算符仅调用getter一次，在临时变量中w 保存它的值。

抽象方法

实例、getter和setter方法可以是抽象的，定义接口并将其实现留给其它类。抽象方法仅能存在于 抽象类中。

要让方法为抽象的，使用分号 (;) 而非方法体：

abstract  class  Doer  {

  // 定义实例变量和方法...

  void  doSomething();  // 定义一个抽象方法

}

class  EffectiveDoer  extends  Doer  {

  void  doSomething()  {

    // 提供一个实现，因此这里该方法不是抽象的...

  }

}

抽象类

使用 abstract 修饰符来定义一个抽象类 – 一个无法实例化的类。抽象类对于定义接口非常有用，通常伴有一些实现。如果希望抽象类为可实例化的，定义一个 工厂构造函数。

抽象类通常有 抽象方法。这下是一个声明拥有抽象方法的抽象类的示例：

// 这个类声明为抽象类，

// 因此无法实例化。

abstract  class  AbstractContainer  {

  // 定义构造函数、字段、方法...

  void  updateChildren();  // 抽象方法

}

隐式接口

每个类隐式定义包含类的所有实例成员的接口及它实现的任意接口。如果希望创建支持类B而不继承B的应用的类A，类 A 应实现 B 的 接口。

类A通过在implements从句中通过声明它们来实现一个或多个接口，然后中提供这些接口所要求的 API。例如：

// A 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。

可重载运算符

可以重载下表中所显示的运算符。例如，如果你定义了一类Vector类，可以定义一个+ 方法来对两个向量进行想加。

| < | + | | | [] |
| > | / | ^ | []= |
| <= | ~/ | & | ~ |
| >= | * | << | == |
| – | % | >> | |

Note: 你可能流到到 != 并不是一个可重载运算符。表达式 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));

}

如果重载==，还应当重载 Object的 hashCode getter。有关重载 == 和 hashCode的示例，参见 实现映射的键。

更多有关重载总的信息，参见 继承类。

noSuchMethod()

要在代码尝试使用不存在的方法或实例变量时进行监测或回应，可以重载noSuchMethod()：

class  A  {

  // 除非你重载noSuchMethod，使用一个不存在的

  // 成员会导致NoSuchMethodError报错

  @override

  void  noSuchMethod(Invocation invocation)  {

    print('You tried to use a non-existent member: '  +

        '${invocation.memberName}');

  }

}

你无法调用一个未实现的方法，以下情况除外：

• 接收者有一个静态类型dynamic。
• 接收者有一个定义未实现方法的静态类型（抽象方法没有问题），并且接收者的动态类型有一个不同于Object类中的对 noSuchMethod() 的实现。

更多信息，参数非正式的 noSuchMethod 推送规范。

枚举类型

枚举类型，常称为枚举或enum， 是一种用于展示固定数量的常量值的特殊的类。

使用enum

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

assert(Color.red.index  ==  0);

assert(Color.green.index  ==  1);

assert(Color.blue.index  ==  2);

获取枚举中所有值的列表，可使用enum的 values 常量。

List  colors  =  Color.values;

assert(colors[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:  // 没有这条，会看到一条WARNING

    print(aColor);  // 'Color.blue'

}

枚举类型有如下的限制：

• 不能有子类、mixin实现一个enum。
• 不能显式地实例化一个 enum。

更多信息，参见Dart语言规范。

为类添加功能： mixin

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;

  }

}

要实现一个mixin，创建继承Object和未声明构造函数的类。除非你希望让mixin和普通类一样可用，否则请使用 mixin 关键字来替代 class。例如：

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

    }

  }

}

要指定只有某些类型可以使用该mixin – 例如，这样你的mixin可以调用它未定义的方法 – 使用 on 来指定所要求的超类：

mixin  MusicalPerformer  on  Musician  {

  // ···

}

Version note: 对 mixin 关键字的支持在Dart 2.1中引入。更早发行版本中的代码通常使用abstract class来进行代替。更多有关2.1对mixinw 修改的信息，参见 Dart SDK修改记录 和 2.1 mixin规范。

类变量和方法

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

静态变量

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

class  Queue  {

  static  const  initialCapacity  =  16;

  // ···

}

void  main()  {

  assert(Queue.initialCapacity  ==  16);

}

静态变量直到使用时才进行初始化。

Note: 本文遵循 样式指南推荐 的推荐，使用 lowerCamelCase （首字母小写的驼峰命名法）来作为常量名。

静态方法

静态方法（类方法）不对实例进行操作，因此无法访问 this。例如：

import  'dart:math';

class  Point  {

  num  x,  y;

  Point(this.x,  this.y);

  static  num distanceBetween(Point  a,  Point  b)  {

    var  dx  =  a.x  -  b.x;

    var  dy  =  a.y  -  b.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);

}

Note: 考虑对常用或广泛使用的工具和功能使用顶级函数来代替静态方法。

可以使用静态方法来作为编译时常量。例如，你可以传递一个静态方法作为对常量构造函数的参数。

泛型

如果你在查看基本数组类型List的 API 文档，实际上看到的类型是 List。<…>标记表示 List是一种泛型（或参数化）类型 – 使用拥有正式类型参数的类型。按照惯例，大部分类型变量都有单字母名称，如 E, T, S, K和 V。

为什么使用泛型？

泛型通常是类型安全所需要的，但它们有比允许你的代码运行更多的好处：

• 合理地指定泛型会产生更好的生成代码。
• 可以使用泛型来减少代码重复。

如果你想要列表仅包含字符串，可以声明它为List (将其读作“字符串列表”)。这样你、你的程序员小伙伴和你的工具都会监测到为该列表赋非字符串值可能是错误的。以下是一个示例：

var  names  =  List();

names.addAll(['Seth',  'Kathy',  'Lars']);

names.add(42);  // Error

另一个使用泛型的原因是减少代码重复量。泛型让我们可以在多个类型中共享单个接口和实现，而又仍拥有静态分析的好处。例如，假设你创建接口来捕获一个对象：

abstract  class  ObjectCache  {

  Object  getByKey(String  key);

  void  setByKey(String  key,  Object  value);

}

发现你想要该接口的字符串版本，所以创建了另一个接口：

abstract  class  Cache  {

  T  getByKey(String  key);

  void  setByKey(String  key,  T  value);

}

在以上代码中，T是占位类型。它是一个可以看作类型的占位符，开发者可以在稍后定义这个类型。

使用集合字面量

列表、集和映射字面量可以是参数化的。参数字面量和我们所看到的其它字面量一样，只是可以在方括号（或花括号）之前添加 <*type*> (针对列表和集) 或 <*keyType*, *valueType*> (针对映射)。下面是一个使用带类型字面量的示例：

var  names  =  ['Seth',  'Kathy',  'Lars'];

var  uniqueNames  =  {'Seth',  'Kathy',  'Lars'};

var  pages  =  {

  'index.html':  'Homepage',

  'robots.txt':  'Hints for web robots',

  'humans.txt':  'We are people, not machines'

};

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

在使用构造函数时要指定一个或多个类型，将类型放在类名后的尖括号 (<...>) 中。例如：

var  nameSet  =  Set.from(names);

以下代码创建一个键为整型值为View类型的映射：

var  views  =  Map();

泛型集合及它们所包含的类型

Dart的泛型是实化（reified）类型，表示它们可以在运行时携带类型信息。例如，可以测试一个集合的类型：

var  names  =  List();

names.addAll(['Seth',  'Kathy',  'Lars']);

print(names is  List);  // true

Note: 不同的是，Java中的泛型使用的是擦除（erasure）类型，表示泛型参数在运时会被删除。在 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);  // 'Foo'的实例

指定任意非SomeBaseClass 类型会导致报错：

var  foo  =  Foo