• 基于 mixin 的继承
  • 根类是 Object

使用类成员

  • 数据
  • 函数
  1. var p = Point(2, 2);
  3. // Set the value of the instance variable y.
  4. p.y = 3;
  6. // Get the value of y.
  7. assert(p.y == 3);
  9. // Invoke distanceTo() on p.
  10. double distance = p.distanceTo(Point(4, 4));
  • ?. 避免对象为 null
  1. // If p is non-null, set its y value to 4.
  2. p?.y = 4;

使用构造函数

构造函数可以是:

  • ClassName
  • ClassName.identifier
  1. var p1 = Point(2, 2);
  2. var p2 = Point.fromJson({'x': 1, 'y': 2});
  • new 关键字是可选的
  1. var p1 = new Point(2, 2);
  2. var p2 = new Point.fromJson({'x': 1, 'y': 2});
  • 常量构造函数
  1. var p = const ImmutablePoint(2, 2);
  • 创建两次常量对象, 它们是相同的对象
  1. var a = const ImmutablePoint(1, 1);
  2. var b = const ImmutablePoint(1, 1);
  4. assert(identical(a, b)); // They are the same instance!
  • 不用写过多 const 关键字
  1. // 声明出所有 const
  2. // Lots of const keywords here.
  3. const pointAndLine = const {
  4.   'point': const [const ImmutablePoint(0, 0)],
  5.   'line': const [const ImmutablePoint(1, 10), const ImmutablePoint(-2, 11)],
  6. };
  8. // Only one const, which establishes the constant context.
  9. const pointAndLine = {
  10.   'point': [ImmutablePoint(0, 0)],
  11.   'line': [ImmutablePoint(1, 10), ImmutablePoint(-2, 11)],
  12. };

获取对象类型

  • 返回类型对象
  • 运行时类型 runtimeType
  1. print('The type of a is ${a.runtimeType}');

实例变量

  • 每个实例变量隐含实现 getter 方法
  • 每个非 finall 实例变量隐含实现 setter 方法
  1. class Point {
  2.   double x; // Declare instance variable x, initially null.
  3.   double y; // Declare y, initially null.
  4.   double z = 0; // Declare z, initially 0.
  5. }
  7. class Point {
  8.   double x;
  9.   double y;
  10. }
  12. void main() {
  13.   var point = Point();
  14.   point.x = 4; // Use the setter method for x.
  15.   assert(point.x == 4); // Use the getter method for x.
  16.   assert(point.y == null); // Values default to null.
  17. }

构造函数

  • 与类名相同
  • 命名构造函数
  • this
  1. class Point {
  2.   double x, y;
  4.   Point(double x, double y) {
  5.     // There's a better way to do this, stay tuned.
  6.     this.x = x;
  7.     this.y = y;
  8.   }
  9. }
  • 给实例变量赋值的语法糖
  1. class Point {
  2.   double x, y;
  4.   // Syntactic sugar for setting x and y
  5.   // before the constructor body runs.
  6.   Point(this.x, this.y);
  7. }

默认构造函数

如果没声明构造函数, dart 将会创建一个没有参数的构造函数, 并且调用父类的无参构造函数.

构造函数不会继承

没声明构造函数的子类只有默认的无参构造函数.

命名构造函数

  • 实现多个构造函数
  1. class Point {
  2.   double x, y;
  4.   Point(this.x, this.y);
  6.   // Named constructor
  7.   Point.origin() {
  8.     x = 0;
  9.     y = 0;
  10.   }
  11. }

调用非默认超类构造函数

  • 默认情况下, 子类构造函数会调用父类非命名无参构造函数, 调用位置是子类构造函数体的开始.

各构造函数执行顺序:

  1. 初始化列表
  2. 父类无参构造函数
  3. 子类无参构造函数
  • 如果父类没有未命名的无参构造函数, 那么需要使用 : 符号来明确调用父类的一个构造函数
  • : 是初始化列表, 就是在子类没有创建之前, 使用初始化列表来初始化父类, 有了父类才能有子类
  1. class Person {
  2.   String firstName;
  4.   Person.fromJson(Map data) {
  5.     print('in Person');
  6.   }
  7. }
  9. class Employee extends Person {
  10.   // Person does not have a default constructor;
  11.   // you must call super.fromJson(data).
  12.   Employee.fromJson(Map data) : super.fromJson(data) {
  13.     print('in Employee');
  14.   }
  15. }
  17. main() {
  18.   var emp = new Employee.fromJson({});
  20.   // Prints:
  21.   // in Person
  22.   // in Employee
  23.   if (emp is Person) {
  24.     // Type check
  25.     emp.firstName = 'Bob';
  26.   }
  27.   (emp as Person).firstName = 'Bob';
  28. }

初始化列表

  • :
  • 使用 , 分隔
  • 不能使用 this 
  1. // Initializer list sets instance variables before
  2. // the constructor body runs.
  3. Point.fromJson(Map<String, double> json)
  4.     : x = json['x'],
  5.       y = json['y'] {
  6.   print('In Point.fromJson(): ($x, $y)');
  7. }
  • 在开发模型下, 用于验证参数
  1. Point.withAssert(this.x, this.y) : assert(x >= 0) {
  2.   print('In Point.withAssert(): ($x, $y)');
  3. }
  • 初始化 final 字段
  1. import 'dart:math';
  3. class Point {
  4.   final num x;
  5.   final num y;
  6.   final num distanceFromOrigin;
  8.   Point(x, y)
  9.       : x = x,
  10.         y = y,
  11.         distanceFromOrigin = sqrt(x * x + y * y);
  12. }
  14. main() {
  15.   var p = new Point(2, 3);
  16.   print(p.distanceFromOrigin);
  17. }

重定向构造函数

  1. class Point {
  2.   double x, y;
  4.   // The main constructor for this class.
  5.   Point(this.x, this.y);
  7.   // Delegates to the main constructor.
  8.   Point.alongXAxis(double x) : this(x, 0);
  9. }

常量构造函数

  • 只要确保所有字段是 final 的
  1. class ImmutablePoint {
  2.   static final ImmutablePoint origin =
  3.       const ImmutablePoint(0, 0);
  5.   final double x, y;
  7.   const ImmutablePoint(this.x, this.y);
  8. }

工厂构造函数

  • factory 关键字
  • 可能不会创建新实例, 会从缓存中取出实例
  • factory 无法访问 this
  1. class Logger {
  2.   final String name;
  3.   bool mute = false;
  5.   // _cache is library-private, thanks to
  6.   // the _ in front of its name.
  7.   static final Map<String, Logger> _cache =
  8.       <String, Logger>{};
  10.   factory Logger(String name) {
  11.     return _cache.putIfAbsent(
  12.         name, () => Logger._internal(name));
  13.   }
  15.   factory Logger.fromJson(Map<String, Object> json) {
  16.     return Logger(json['name'].toString());
  17.   }
  19.   Logger._internal(this.name);
  21.   void log(String msg) {
  22.     if (!mute) print(msg);
  23.   }
  24. }
  26. // 与普通构造函数使用方法相同
  27. var logger = Logger('UI');
  28. logger.log('Button clicked');
  30. var logMap = {'name': 'UI'};
  31. var loggerJson = Logger.fromJson(logMap);

方法

实例方法

  1. import 'dart:math';
  3. class Point {
  4.   double x, y;
  6.   Point(this.x, this.y);
  8.   double distanceTo(Point other) {
  9.     var dx = x - other.x;
  10.     var dy = y - other.y;
  11.     return sqrt(dx * dx + dy * dy);
  12.   }
  13. }

Getters 和 Setters

  1. class Rectangle {
  2.   double left, top, width, height;
  4.   Rectangle(this.left, this.top, this.width, this.height);
  6.   // Define two calculated properties: right and bottom.
  7.   double get right => left + width;
  8.   set right(double value) => left = value - width;
  9.   double get bottom => top + height;
  10.   set bottom(double value) => top = value - height;
  11. }
  13. void main() {
  14.   var rect = Rectangle(3, 4, 20, 15);
  15.   assert(rect.left == 3);
  16.   rect.right = 12;
  17.   assert(rect.left == -8);
  18. }

抽象方法

  • 抽象方法必须在抽象类中
  1. abstract class Doer {
  2.   // Define instance variables and methods...
  4.   void doSomething(); // Define an abstract method.
  5. }
  7. class EffectiveDoer extends Doer {
  8.   void doSomething() {
  9.     // Provide an implementation, so the method is not abstract here...
  10.   }
  11. }

抽象类

  1. // This class is declared abstract and thus
  2. // can't be instantiated.
  3. abstract class AbstractContainer {
  4.   // Define constructors, fields, methods...
  6.   void updateChildren(); // Abstract method.
  7. }

隐式接口

  • 每个类隐式创建接口
  1. // A person. The implicit interface contains greet().
  2. class Person {
  3.   // In the interface, but visible only in this library.
  4.   final _name;
  6.   // Not in the interface, since this is a constructor.
  7.   Person(this._name);
  9.   // In the interface.
  10.   String greet(String who) => 'Hello, $who. I am $_name.';
  11. }
  13. // An implementation of the Person interface.
  14. class Impostor implements Person {
  15.   get _name => '';
  17.   String greet(String who) => 'Hi $who. Do you know who I am?';
  18. }
  20. String greetBob(Person person) => person.greet('Bob');
  22. void main() {
  23.   print(greetBob(Person('Kathy')));
  24.   print(greetBob(Impostor()));
  25. }
  • 实现多个接口
  1. class Point implements Comparable, Location {...}

扩展类

  • extends: 创建子类
  • super: 引用父类
  1. class Television {
  2.   void turnOn() {
  3.     _illuminateDisplay();
  4.     _activateIrSensor();
  5.   }
  6.   // ···
  7. }
  9. class SmartTelevision extends Television {
  10.   void turnOn() {
  11.     super.turnOn();
  12.     _bootNetworkInterface();
  13.     _initializeMemory();
  14.     _upgradeApps();
  15.   }
  16.   // ···
  17. }

重载成员

  • @override 
  1. class SmartTelevision extends Television {
  2.   @override
  3.   void turnOn() {...}
  4.   // ···
  5. }

可重载的操作符

image.png

  1. class Vector {
  2.   final int x, y;
  4.   Vector(this.x, this.y);
  6.   Vector operator +(Vector v) => Vector(x + v.x, y + v.y);
  7.   Vector operator -(Vector v) => Vector(x - v.x, y - v.y);
  9.   // Operator == and hashCode not shown. For details, see note below.
  10.   // ···
  11. }
  13. void main() {
  14.   final v = Vector(2, 3);
  15.   final w = Vector(2, 2);
  17.   assert(v + w == Vector(4, 5));
  18.   assert(v - w == Vector(0, 1));
  19. }
  • 重写 == 时, 要求同时重写对象的 hashCode

noSuchMethod()

  • 在使用不存在的方法或实例变量时作出反应, 可以实现 noSuchMethod()
  1. class A {
  2.   // Unless you override noSuchMethod, using a
  3.   // non-existent member results in a NoSuchMethodError.
  4.   @override
  5.   void noSuchMethod(Invocation invocation) {
  6.     print('You tried to use a non-existent member: ' +
  7.         '${invocation.memberName}');
  8.   }
  9. }

扩展方法

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

枚举类型

使用枚举

  • 声明
  1. enum Color { red, green, blue }
  • 每个枚举值有一个 index 属性
  1. assert(Color.red.index == 0);
  2. assert(Color.green.index == 1);
  3. assert(Color.blue.index == 2);
  • 获取枚举类型的所有值
  1. List<Color> colors = Color.values;
  2. assert(colors[2] == Color.blue);
  • 在 switch 中使用枚举
  1. var aColor = Color.blue;
  3. switch (aColor) {
  4.   case Color.red:
  5.     print('Red as roses!');
  6.     break;
  7.   case Color.green:
  8.     print('Green as grass!');
  9.     break;
  10.   default: // Without this, you see a WARNING.
  11.     print(aColor); // 'Color.blue'
  12. }

Mixins

多重继承.

  1. class Musician extends Performer with Musical {
  2.   // ···
  3. }
  5. class Maestro extends Person
  6.     with Musical, Aggressive, Demented {
  7.   Maestro(String maestroName) {
  8.     name = maestroName;
  9.     canConduct = true;
  10.   }
  11. }
  • mixins 类
  1. mixin Musical {
  2.   bool canPlayPiano = false;
  3.   bool canCompose = false;
  4.   bool canConduct = false;
  6.   void entertainMe() {
  7.     if (canPlayPiano) {
  8.       print('Playing piano');
  9.     } else if (canConduct) {
  10.       print('Waving hands');
  11.     } else {
  12.       print('Humming to self');
  13.     }
  14.   }
  15. }
  • 指定该 mixins 只能用在某类
  1. mixin MusicalPerformer on Musician {
  2.   // ···
  3. }

类变量和类方法

  • static

静态变量

  1. class Queue {
  2.   static const initialCapacity = 16;
  3.   // ···
  4. }
  6. void main() {
  7.   assert(Queue.initialCapacity == 16);
  8. }

静态方法

  1. import 'dart:math';
  3. class Point {
  4.   double x, y;
  5.   Point(this.x, this.y);
  7.   static double distanceBetween(Point a, Point b) {
  8.     var dx = a.x - b.x;
  9.     var dy = a.y - b.y;
  10.     return sqrt(dx * dx + dy * dy);
  11.   }
  12. }
  14. void main() {
  15.   var a = Point(2, 2);
  16.   var b = Point(4, 4);
  17.   var distance = Point.distanceBetween(a, b);
  18.   assert(2.8 < distance && distance < 2.9);
  19.   print(distance);
  20. }