10天学会flutter DAY3 玩转dart 方法

class Vector{

  final int x, y;



  Vector(this.x, this.y);



  Vector operator +(Vector vector) => Vector(x + vector.x, y + vector.y);

  Vector operator -(Vector vector) => Vector(x - vector.x, y - vector.y);



}



main{

  final v = Vector(2, 3);

  final w = Vector(2, 2);



  assert(v + w == Vector(2, 3));

  assert(v - w == Vector(0, 1));



}

3、Getter 和 Setter

---

• Getter 和 Setter 是一对用来读写属性的特殊方法，上面说过实例对象的每一个属性都有一个隐式的Getter 方法，如果为非final 属性的话，还会有一个Setter 方法，你可以使用get 和 set 关键字为额外的属性添加 Getter 和 Setter 方法：

class Rectangle {

  double left, top, width, height;



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



  // Define two calculated properties: right and bottom.

  double get right => left + width;

  set right(double value) => left = value - width;

  double get bottom => top + height;

  set bottom(double 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 的好处是，你可以先使用你的实例变量，过一段时间再将它们包裹成方法且不需要改动任何代码，即先定义后更改且不影响原有逻辑。

像自增（++）这样的操作符不管是否定义了 Getter 方法都会正确地执行。为了避免一些不必要的异常情况，运算符只会调用 Getter 一次，然后将其值存储在一个临时变量中。

4、抽象方法

---

• 实例方法、Getter 方法以及 Setter 方法都可以是抽象的，定义一个接口方法而不去做具体的实现让实现它的类去实现该方法，抽象方法只能存在于 抽象类中。

abstract class Doer {

//   定义一个抽象方法

  void doSomething();

}



class EffectiveDoer extends Doer{

  @override

  void doSomething() {

    // TODO: implement doSomething

  //  这里是抽象方法的实现

  }



}

5、 抽象类

---

使用关键字 abstract 标识类可以让该类成为 抽象类，抽象类将无法被实例化。抽象类常用于声明接口方法、有时也会有具体的方法实现。如果想让抽象类同时可被实例化，可以为其定义 工厂构造函数。

• 抽象类常常会包含 抽象方法。下面是一个声明具有抽象方法的抽象类示例：

abstract class Doer {

//   定义一个抽象方法

  void doSomething();

}

6、隐式接口

---

每一个类都隐式地定义了一个接口并实现了该接口，这个接口包含所有这个类的实例成员以及这个类所实现的其它接口。如果想要创建一个 A 类支持调用 B 类的 API 且不想继承 B 类，则可以实现 B 类的接口。

• 一个类可以通过关键字 implements 来实现一个或多个接口并实现每个接口定义的 API：

// A person. The implicit interface contains greet().

class Person {

  // In the interface, but visible only in this library.

  final String _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 {

  String get _name => '';



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

}



String greetBob(Person person) => person.greet('Bob');

• 如果需要实现多个类接口，可以使用逗号分割每个接口类：

class Point implements Comparable, Location {...}

7、扩展一个类

---

• 使用 extends 关键字来创建一个子类，并可使用 super 关键字引用一个父类：

class Television{

  void turnOn(){

    _illuminateDisplay();

    _activateIrSensor();

  }

}



class SmartTelevision extends Television{

  void turnOn(){

    _bootNetworkInterface();

    _initializeMemory();

    _upgradeApps();

  }

}

8、重写类成员

---

• 子类可以重写父类的实例方法（包括 操作符）、 Getter 以及 Setter 方法。你可以使用 @override 注解来表示你重写了一个成员：

class Television {

  // ···

  set contrast(int value) {...}

}



class SmartTelevision extends Television {

  @override

  set contrast(num value) {...}

  // ···

}

9、扩展方法

---

扩展方法是向现有库添加功能的一种方式。你可能已经在不知道它是扩展方法的情况下使用了它。例如，当您在 IDE 中使用代码完成功能时，它建议将扩展方法与常规方法一起使用。

• 这里是一个在 String 中使用扩展方法的样例，我们取名为 parseInt()，它在 string_apis.dart 中定义：

import 'string_apis.dart';

...

print('42'.padLeft(5)); // Use a String method.

print('42'.parseInt()); // Use an extension method.

10、枚举类型

---

枚举类型是一种特殊的类型，也称为 enumerations 或 enums，用于定义一些固定数量的常量值。

• 使用关键字 enum 来定义枚举类型：

enum Color { red, green, blue }

• 每一个枚举值都有一个名为 index 成员变量的 Getter 方法，该方法将会返回以 0 为基准索引的位置值。例如，第一个枚举值的索引是 0 ，第二个枚举值的索引是 1。以此类推。

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

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

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

• 你可以在 Switch 语句中使用枚举，但是需要注意的是必须处理枚举值的每一种情况，即每一个枚举值都必须成为一个 case 子句，不然会出现警告：

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'

}

枚举类型有如下两个限制：

1、 枚举不能成为子类，也不可以 mixin，你也不可以实现一个枚举。

2、 不能显式地实例化一个枚举类。

11、使用 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 替代 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');

    }

  }

}

• 可以使用关键字 on 来指定哪些类可以使用该 Mixin 类，比如有 Mixin 类 A，但是 A 只能被 B 类使用，则可以这样定义 A：

class Musician {

  // ...

}

mixin MusicalPerformer on Musician {

  // ...

}

class SingerDancer extends Musician with MusicalPerformer {

  // ...

}

12、类变量和方法

---

使用关键字 static 可以声明类变量或类方法。

静态变量

• 静态变量（即类变量）常用于声明类范围内所属的状态变量和常量：

class Queue {

  static const initialCapacity = 16;

  // ···

}



void main() {

  assert(Queue.initialCapacity == 16);

}

静态变量在其首次被使用的时候才被初始化。

静态方法

• 静态方法（即类方法）不能对实例进行操作，因此不能使用 this。但是他们可以访问静态变量。如下面的例子所示，你可以在一个类上直接调用静态方法：

class Point {

  double x, y;

  Point(this.x, this.y);