7.Classes-类(Dart中文文档)

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

如果父类没有默认构造器，你必须手动调用父类的其它构造器。写法是在子类构造器名后面加上冒号(