Dart是一个面向对象的语言，同时增加了混入(mixin)继承的特性。对象都是由类初始化生成的，所有的类都由Object对象继承。混入继承意味着尽管所有类（除了Object类）只有一个父类，但是类的代码体可以在多个类中重复使用。（个人理解：mixin,extends,implements，extends是类似java单继承，implements类似java的多接口实现，但这些都是运行时使用，mixin应该是在编译时使用，类似于jsp的include,比如 A with B,其实是在编译时，将两个类的代码合并，编译成classes） 。

Using class members 类成员

对象由成员变量和方法构成。你可以用点(.)调用方法或者成员变量

var p = Point(2, 2);

// Set the value of the instance variable y.
p.y = 3;

// Get the value of y.
assert(p.y == 3);

// Invoke distanceTo() on p.
num distance = p.distanceTo(Point(4, 4));
Use ?. instead of . to avoid an exception when the leftmost operand is null:

// If p is non-null, set its y value to 4.
p?.y = 4;

Using constructors 构造方法

你可以用构造方法创建对象，构造方法是ClassName或者ClassName.identifier.下面是构造方法的两种写法：

Point() and Point.fromJson() constructors:

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

版本注意：new 关键字在Dart2中是可选的。

一些类提供了静态构造方法。当你需要这些创建编译常量对象，可以在构造对象代码前加上const关键字。

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!

在编译常量上下中，可以忽略后续的const关键字，也可以达到同样效果

// Lots of const keywords here.
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 pointAndLine = {
  'point': [ImmutablePoint(0, 0)],
  'line': [ImmutablePoint(1, 10), ImmutablePoint(-2, 11)],
};

如果用常量构造器初始化对象，但是没有加入const关键字，它将是非常量对象

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!

版本注意： const关键字的忽略写法在Dart2中才有效

Getting an object’s type 获取对象类型

在运行时获取对象的类型，你可以用Object的对象的 runtimeType属性。

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

Instance variables 成员变量

下面是如何定义成员变量：

class Point {
  num x; // Declare instance variable x, initially null.
  num y; // Declare y, initially null.
  num z = 0; // Declare z, initially 0.
}

所有为初始化变量的值是null.

所有成员变量都内置get方法。非final的成员变量内置了set方法。

class Point {
  num x;
  num y;
}

void main() {
  var point = Point();
  point.x = 4; // Use the setter method for x.
  assert(point.x == 4); // Use the getter method for x.
  assert(point.y == null); // Values default to null.
}

如果你在成员变量的定义时就进行初始化，在对象创建时，它将先于构造器和初始化列表执行。

Constructors 构造器

类构造器是和类名同名的函数,(其中还有一种命名构造函数的写法，后续介绍)。

class Point {
  num x, y;

  Point(num x, num y) {
    // There's a better way to do this, stay tuned.
    this.x = x;
    this.y = y;
  }
}

上面的例子中，thisg关键字可以读取成员变量。
注意：使用this只有在方法参数和成员变量有冲突时才用，其它场景可以不写

如果构造器的入参和成员变量对应，可以直接赋值，可以用如下的简化写法：

class Point {
  num x, y;

  // Syntactic sugar for setting x and y
  // before the constructor body runs.
  Point(this.x, this.y);
}

Default constructors 默认构造器

如果没有定义构造器，类将提供一个无参构造器，如果类有一个父类，也会调用父类的无参构造器

Constructors aren’t inherited 构造器不可继承

子类不会继承父类的构造器，如果子类没有定义构造器，它只有默认的无参构造器，不会去继承父类的构造器。

Named constructors 命名构造器

Dart可以使用命名构造器去实现多个构造逻辑。

class Point {
  num x, y;

  Point(this.x, this.y);

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

构造器是不可继承的，这个规则在命名构造器同样有效。如果你想要一个和父类一样的命名构造器，需要在子类的自己定义同样的构造器。

Invoking a non-default superclass constructor 调用父类的非默认构造器

默认情况下,子类的构造器将调用父类的默认构造器。父类构造器先于子类构造器执行，如果子类构造器有初始化执行器列表，它将先于父类构造器执行，如下是执行顺序：

initializer list
superclass’s no-arg constructor
main class’s no-arg constructor

如果父类没有默认构造器，你必须手动调用父类的其它构造器。写法是在子类构造器名后面加上冒号(????，写上父类构造器调用。
Because the arguments to the superclass constructor are evaluated before invoking the constructor, an argument can be an expression such as a function call:

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

注意：父类构造器的参数不接收this, 只能接受静态方法。

Initializer list 初始化执行器

在构造器后面除了可以追加父类构造器外，还可以追加初始化执行器。

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

注意：右边的初始化执行器不接受this写法。

在开发模式下，你可以通过assert在初始化执行器中判断参数是否为空。

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

Redirecting constructors 重定向构造器

有些时候，定义的构造器只为了传递给另一个构造器，那么构造器的代码体是空的，同时后面直接追加：目标构在器

class Point {
  num x, y;

  // The main constructor for this class.
  Point(this.x, this.y);

  // Delegates to the main constructor.
  Point.alongXAxis(num x) : this(x, 0);
}

Constant constructors 常量构造器

如果对象在创建后，不再改变，你可以将它写成编译常量。这些样类，首先构造器要有const关键字，同时成员变量得是final.

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

  final num x, y;

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

Factory constructors 工厂构造器

当构造器使用factory关键字时，对象创建不一定每次都是一个新对象。factory可能从缓存中提取对象返回或者创建新对象。

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

  // _cache is library-private, thanks to
  // the _ in front of its name.
  static final Map<String, Logger> _cache =
      <String, Logger>{};

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

Methods 方法

Instance methods 成员方法

成员方法可以使用成员变量和this关键字，

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 and setters get和set

get和set是读写对象成语变量的特殊方法。通过.调用成员变量，就是调用内置的get方法，set方法也是一样的。

你也可以通过get或者set关键字重载get和set方法

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

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

  // Define two calculated properties: right and 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);
}

Note: Operators such as increment (++) work in the expected way, whether or not a getter is explicitly defined. To avoid any unexpected side effects, the operator calls the getter exactly once, saving its value in a temporary variable.

Abstract methods 抽象方法

成员方法，get方法，set方法都是定义为在抽象类中定义成抽象方法，注意是在抽象类中，非抽象类不可定义。

抽象方法直接在方法后加上；号，不用实现代码。

abstract class Doer {
  // Define instance variables and methods...

  void doSomething(); // Define an abstract method.
}

class EffectiveDoer extends Doer {
  void doSomething() {
    // Provide an implementation, so the method is not abstract here...
  }
}

Abstract classes 抽象类

你可以用abstract关键字来定义抽象类，注意，抽象类不可初始化。抽象类适合做接口定义，具体实现通过继承抽象类。抽象类的实现初始化方法，一般用工厂构造器。

// This class is declared abstract and thus
// can't be instantiated.
abstract class AbstractContainer {
  // Define constructors, fields, methods...

  void updateChildren(); // Abstract method.
}

Implicit interfaces 接口实现

如果A继承B，则A将具备B的所有成员变量和方法，也同时具备B继承的所有接口方法。但是，你如果不像继承B类，但有希望拥有B类的方法，可以继承B的相应接口。

// A person. The implicit interface contains greet().
class Person {
  // In the interface, but visible only in this library.
  final _name;

  // Not in the interface, since this is a constructor.
  Person(this._name);

  // In the interface.
  String greet(String who) => 'Hello, $who. I am $_name.';
}

// An implementation of the Person interface.
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 {...}

Extending a class 扩展类

通过extends继承父类，可以用super去访问父类。

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

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

Overriding members 重载

子类可以重载成员方法,get方法，set 方法，你可以用@override是标记该方法被重载

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

To narrow the type of a method parameter or instance variable in code that is type safe, you can use the covariant keyword.

Overridable operators 操作符重载

你可以重载如下操作符：

< + | []

/ ^ []=
<= ~/ & ~
= * << ==
– % >>
‘注意：你会注意到!=是不用于重载的，因为它和是等效的，比如(e1!=e2)和!(e1e2)这两个是相同效果'

下面是+,-的重载示例：

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

  // Operator == and hashCode not shown. For details, see note below.
  // ···
}

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方法。

noSuchMethod()

如果对象尝试调用不存在的变量或者方法，会抛出noSuchMethod异常，这个异常可以通过重载该方法，增加自定义逻辑。

class A {
  // Unless you override noSuchMethod, using a
  // non-existent member results in a NoSuchMethodError.
  @override
  void noSuchMethod(Invocation invocation) {
    print('You tried to use a non-existent member: ' +
        '${invocation.memberName}');
  }
}

你一般不能调用未继承的方法除非出现如下情况：

它是一个dynamic对象，因为是动态类型，所以编译器不会检查。

它继承了一个抽象类，同时它没有做抽象方法做具体实现，但是定义了 noSuchMethod()函数，这样，编译器也不会检查。

更多的内容请查看noSuchMethod

Enumerated types 枚举类型

枚举类型一般用于表示一些限定范围内的常量。

Using enums

可以用enum关键字定义枚举。

enum Color { red, green, blue }

每个枚举对象的属性都会赋予一个整数值，它是从0开始，基于属性位置递增。例如，Color的枚举对象，第一个是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语句，编译器会在你没有处理所有枚举属性时，作出提示。

var aColor = Color.blue;

switch (aColor) {
  case Color.red:
    print('Red as roses!');
    break;
  case Color.green:
    print('Green as grass!');
    break;
  default: // Without this, you see a WARNING.
    print(aColor); // 'Color.blue'
}

枚举类型有下面的限制：
枚举不可继承，混入，也不可以被继承
枚举类不可初始化

Adding features to a class: mixins 混入

Mixins是一种在多个类中重用代码的方式。

混入的写法是：with关键字加上多个混入的类

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

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

用于mixin的对象是一个继承Object的无构造函数的类，如果你想将用于混入的类和普通类区分开来，可以用 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可以通过on关键字来限定哪些类的子类才可以用它做用户（不太理解：To specify that only certain types can use the mixin — for example, so your mixin can invoke a method that it doesn’t define — use on to specify the required superclass:）

mixin MusicalPerformer on Musician {
  // ···
}

注意：mixin关键字在dart2.1采用到，早期版本用abstract class.

Class variables and methods 类成员变量和方法

使用static 关键字修饰类的成员变量和方法就形成了静态变量和静态方法。

Static variables 静态变量

Static variables (class variables) are useful for class-wide state and constants:

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

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

静态变量在它使用时才初始化。

Static methods 静态方法

静态方法可以通过类直接调用：

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

第八篇翻译 ，Generics 泛型