Dart 语言简易教程(六)

Dart 语言简易教程(一): http://www.jianshu.com/p/8a62b1a2fd75
Dart 语言简易教程(二): http://www.jianshu.com/p/b2153a32dd8b
Dart 语言简易教程(三): http://www.jianshu.com/p/6d2495a0d3d7
Dart 语言简易教程(四): http://www.jianshu.com/p/fdd046a6dc82
Dart 语言简易教程(五) http://www.jianshu.com/p/83adc77839b6

Dart 语言简易教程(六)

对象

Dart 是一种面向对象的语言,并且支持基于mixin的继承方式。
Dart 语言中所有的对象都是某一个类的实例。所有的类有同一个基类--Object。
基于mixin的继承方式具体是指:一个类可以继承自多个父类。

使用new语句来构造一个类。
构造函数的名字可能是ClassName,也可以是ClassName.identifier。例如:

var jsonData = JSON.decode('{"x":1, "y":2}');

// Create a Point using Point().
var p1 = new Point(2, 2);

// Create a Point using Point.fromJson().
var p2 = new Point.fromJson(jsonData);

使用.(dot) 来调用实例的变量或者方法。

var p = new 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(new Point(4, 4));

使用?. 来确认前操作数不为空。常用来替代.

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

使用const替代new来创建编译时的常量构造函数。

var p = const ImmutablePoint(2, 2);

使用runtimeType方法,在运行中获取对象的类型。该方法将返回Type 类型的变量。

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

实例化变量(Instance variables)

在类定义中,所有没有初始化的变量都会被初始化为null

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

类定义中所有的变量Dart 语言都会隐式的定义 setter 方法,针对非空的变量会额外增加 getter 方法。

class Point {
  num x;
  num y;
}

main() {
  var point = new 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;
  num y;

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

this关键字指向了当前类的实例。
上面的代码可以简化为:

class Point {
  num x;
  num y;

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

默认构造函数(Default constructors)

如果类定义时,没有显式的定义构造函数,Dart 语言将提供默认的构造函数。默认的构造函数没有参数。

构造函数不能继承(Constructors aren’t inherited)

Dart 语言中,子类不会继承父类的命名构造函数。如果不显式提供子类的构造函数,系统就提供默认的构造函数。

命名的构造函数(Named constructors)

使用命名构造函数从另一类或现有的数据中快速实现构造函数。

class Point {
  num x;
  num y;

  Point(this.x, this.y);

  // Named constructor
  Point.fromJson(Map json) {
    x = json['x'];
    y = json['y'];
  }
}

构造函数不能被继承,父类中的命名构造函数不能被子类继承。如果想要子类也拥有一个父类一样名字的构造函数,必须在子类是实现这个构造函数。

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

默认情况下,子类只能调用父类的无名,无参数的构造函数。父类的无名构造函数会在子类的构造函数前调用。如果initializer list 也同时定义了,则会先执行initializer list 中的内容,然后在执行父类的无名无参数构造函数,最后调用子类自己的无名无参数构造函数。即下面的顺序:

  1. initializer list
  2. superclass’s no-arg constructor
  3. main class’s no-arg constructor

如果父类不显示提供无名无参数构造函数的构造函数,在子类中必须手打调用父类的一个构造函数。这种情况下,调用父类的构造函数的代码放在子类构造函数名后,子类构造函数体前,中间使用:(colon) 分割。

class Person {
  String firstName;

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

class Employee extends Person {
  // Person does not have a default constructor;
  // you must call 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) {
    // Type check
    emp.firstName = 'Bob';
  }
  (emp as Person).firstName = 'Bob';
}

上面的代码输出如下:

in Person
in Employee
初始化器列表(Initializer list)

除了调用父类的构造函数,也可以通过Initializer list 在子类的构造函数运行前来初始化实例的变量值。如下所示:

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

上面的代码运行结果为:

3.605551275463989

重定向构造函数

有时候构造函数的目的只是重定向到该类的另一个构造函数。
重定向构造函数的函数体是空的。

class Point {
  num x;
  num y;

  // The main constructor for this class.
  Point(this.x, this.y) {
    print("Point($x, $y)");
  }

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

void main() {
  var p1 = new Point(1, 2);
  var p2 = new Point.alongXAxis(4);
}

上面代码对应的输出结果:

Point(1, 2)
Point(4, 0)

静态构造函数(Constant constructors)

如果类的对象不会发生变化,可以构造一个编译时的常量构造函数。
为了实现上述过程,定义格式如下:

  1. 将所有的类的变量定义为final 类型。
  2. 定义const 类型的构造函数。
class ImmutablePoint {
  final num x;
  final num y;
  const ImmutablePoint(this.x, this.y);
  static final ImmutablePoint origin =  const ImmutablePoint(0, 0);
}

工厂构造函数(Factory constructors)

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 = new Logger._internal(name);
      _cache[name] = logger;
      return logger;
    }
  }

  Logger._internal(this.name);

  void log(String msg) {
    if (!mute) {
      print(msg);
    }
  }
}
void main() {
  var p1 = new Logger("1");
  p1.log("2");


  var p2 = new Logger("11");
  p2.log("21");

}

上面代码的输出结果:

2
21

方法(Methods)

方法是对象提供的函数功能。

Getters and Setters

get()set()方法是Dart 语言提供的专门用来读取和写入对象的属性的方法。
每一个类的实例,系统都隐式的包含有get()和set() 方法。
get()set()的例子:

class Rectangle {
  num left;
  num top;
  num width;
  num 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;
}

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

上面例子对应的输出为:

Observatory listening on http://127.0.0.1:33439
Unhandled exception:
'file:///opt/program/Dart/0910.dart': Failed assertion: line 20 pos 10: 'rect.left == -3' is not true.
#0      _AssertionError._throwNew (dart:core-patch/errors_patch.dart:27)
#1      _AssertionError._checkAssertion (dart:core-patch/errors_patch.dart:34)
#2      main (file:///opt/program/Dart/0910.dart:20:10)
#3      _startIsolate.<anonymous closure> (dart:isolate-patch/isolate_patch.dart:261)
#4      _RawReceivePortImpl._handleMessage (dart:isolate-patch/isolate_patch.dart:148)

Process finished with exit code 255

抽象方法(Abstract methods)

抽象方法类似与Java语言中的interface 的概念。在当前不具体的实现方法,只是写好定义接口,具体实现留着调用的人去实现。
可以使用abstract关键字定义抽象方法。

抽象方法的例子:

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

重载操作

1 2 3 4
< + []
> / ^ []=
<= ~/ & ~
>= * << ==
% >>

可以重载的操作符如下表所示:

1 2 3 4
< + []
> / ^ []=
<= ~/ & ~
>= * << ==
% >>

如果定义矢量的话,可以定义+ 方法我操作两个矢量的实例。

下面的例子就是重载了+-操作的例子:

class Vector {
  final int x;
  final int y;
  const Vector(this.x, this.y);

  /// Overrides + (a + b).
  Vector operator +(Vector v) {
    return new Vector(x + v.x, y + v.y);
  }

  /// Overrides - (a - b).
  Vector operator -(Vector v) {
    return new Vector(x - v.x, y - v.y);
  }
}

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

  // v == (2, 3)
  assert(v.x == 2 && v.y == 3);

  // v + w == (4, 5)
  assert((v + w).x == 4 && (v + w).y == 5);

  // v - w == (0, 1)
  assert((v - w).x == 0 && (v - w).y == 1);
}

如果重载了==,同时也需要重载对象的hashCodeget() 方法。

抽象类(Abstract classes)

使用abstract 关键字定义一个抽象类,抽象类是不能实例化的。
抽象类通常用来定义接口。

假如需要将抽象类实例化,需要定义一个factory constructor

抽象类通常会包含一些抽象的方法。
下面是包含抽象方法的例子:

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

  void updateChildren(); // Abstract method.
}

没有使用abstract 关键字的类,即使包含抽象方法,也可以被实例化。

class SpecializedContainer extends AbstractContainer {
  // ...Define more constructors, fields, methods...

  void updateChildren() {
    // ...Implement updateChildren()...
  }

  // Abstract method causes a warning but
  // doesn't prevent instantiation.
  void doSomething();
}

隐式的接口(Implicit interfaces)

每一个类都隐式的定义一个接口,这个接口包含了这个类的所有实例成员和它实现的所以接口。

如果相应创建一个类A, 这个类A 支持类B 提供的API函数,但是不继承B 的实现,则类A 需要继承类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(who) => 'Hello, $who. I am $_name.';
}

// An implementation of the Person interface.
class Imposter implements Person {
  // We have to define this, but we don't use it.
  final _name = "";

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

greetBob(Person person) => person.greet('bob');

main() {
  print(greetBob(new Person('kathy')));
  print(greetBob(new Imposter()));
}

上面代码对应的输出为:

Observatory listening on http://127.0.0.1:33001
Hello, bob. I am kathy.
Hi bob. Do you know who I am?

Process finished with exit code 0

扩展类(Extending a class)

使用extends 关键字来创建一个子类,super关键子来指定父类。

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

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

子类可以重载实例的方法,getters,setter。

可以使用override关键字来注释这个重载的方法。

枚举类型(Enumerated types)

枚举类型是一种特殊的类,通常用来表示相同类型的一组常量值。
每个枚举类型都用于一个index的getter,用来标记元素的元素位置。第一个枚举元素的标是0 。

enum Color {
  red,
  green,
  blue
}

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

获取枚举类中所有的值,使用value常数。

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

因为枚举类里面的每个元素都是相同类型,可以使用switch 语句来针对不同的值做不同的处理。

enum Color {
  red,
  green,
  blue
}
// ...
Color 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'
}

枚举类型不能继承,实例化。

使用’mixins‘ 功能给类添加新的功能

mixins是一种方便重用一个类的代码的方法。
使用with 关键字来实现mixins的功能。

with用法的实例:

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

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

类变量和方法(Class variables and methods)

使用static关键字来使用类范围内的变量及方法

类常量

类常量的作用范围是类的内部。
类常量只有在被使用的时候才会被调用。

class Color {
  static const red =
      const Color('red'); // A constant static variable.
  final String name;      // An instance variable.
  const Color(this.name); // A constant constructor.
}

main() {
  assert(Color.red.name == 'red');
}

类方法

可以将类方法当做编译时的常量使用。

import 'dart:math';

class Point {
  num x;
  num 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);
  }
}

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

推荐阅读更多精彩内容