Dart 学习笔记二（类与构造函数）

类

Dart 是一个面向对象编程语言。 每个对象都是一个类的实例，所有的类都继承于 Object。

类的声明使用class关键字
类在没有定义构造函数，会默认提供一个空的构造函数
可以使用new关键字和构造函数来创建对象

类的声明

//每个实例变量都会自动生成一个getter方法（隐含的）。非final 实例变量还会自动生成一个setter方法。
class Point {
  num _x; //变量前加下划线表示私有属性，相当于Java的private
  num y;
}

构造函数

Dart语法中，把构造函数参数赋值给实例变量的场景太常见了， 它提供了一个语法糖来简化这个操作，在构造函数的参数前加this关键字定义：

class Point {
  num x;
  num y;
  num z;
  Point(this.x, this.y); //使用this来该变量赋值
  
  //  也可以不用this，在函数体赋值
  Point(this.x, this.y, z){
  		this.z = z;
  }
}

命名构造函数

在Java中可以通过重载来定义构造函数，Dart 并不支持这种方式，而采用了命名构造函数为一个类实现多个构造函数：

class Point {
  num x;
  num y;
  Point(this.x, this.y);
  Point(this.y);///错误，不允许重载
  //命名构造函数
  Point.y(this.y) {
    x = 0;
  }
}

//使用
var p = Point.y(0);

常量构造函数

如果创建一个不可变的对象, 可以把这些对象定义为编译时常量，要实现这个功能，需要定义一个 const 构造函数， 并且声明所有类的变量为 final。

class ImmutablePoint {
  final num x;
  final num y;
  
  // 常量构造函数
  const ImmutablePoint (this.x, this.y); 

  //创建一个常量对象不能用new，要用const
  static final ImmutablePoint origin = const ImmutablePoint (1, 2); 
}

重定向构造函数

有时候一个构造函数会调动类中的其他构造函数(在Java中就是 this(...))。 一个重定向构造函数是没有代码的，在构造函数声明后，使用 冒号调用其他构造函数。

class Point {
  num x;
  num y;

  Point(this.x, this.y);
  Point.xy(int x,int y):this(x,y); ///调用上面的构造函数
}

工厂构造函数

当实现一个使用factory 关键词修饰的构造函数时，这个构造函数不必创建类的新实例。例如，一个工厂构造函数 可能从缓存中获取一个实例并返回，或者 返回一个子类型的实例。（工厂构造函数无法访问 this）

class Logger {
  final String name;
  //从缓存获取对象
  static final Map _cache = {};
  //工厂构造函数，无法使用this变量
  factory Logger(String name) {
    if (_cache.containsKey(name)) {
      //工厂构造函数需要返回 Logger 实例对象
      return _cache[name];
    } else {
      final logger = Logger._internal(name);
      _cache[name] = logger;
      return logger;
    }
  }
  //以 _ 开头的函数、变量无法在库外使用
  Logger._internal(this.name);
}

利用工厂构造函数能够实现单例：

class Manager{
  int i;
  static Manager _instance;
  // 工厂构造方法 必须返回一个 实例对象
  factory Manager.getInstance(){
    if(_instance == null){
      _instance = new Manager._newInstance();
    }
    return _instance;
  }

  //私有的 private的
  Manager._newInstance();
}

Getters 和 Setters

Dart中每个实例变量都隐含的具有一个 getter， 如果变量不是 final 的则还有一个 setter。可以通过实现 getter 和 setter 来创建新的属性， 使用 get 和 set 关键字定义 getter 和 setter：

class Rect {
  num left;
  num top;
  num width;
  num height;

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

  //使用 get定义了一个 right 属性
  num get right => left + width;
  set right(num value) => left = value - width;
}

void main() {
  var rect = Rect(0, 0, 10, 10);
  print(rect.right); //打印 10
  rect.right = 15;
  print(rect.left);  //打印 5
}

需要注意的是，在get与set中使用自身会导致Stack Overflow

可覆写的操作符

在Dart语言中，可以把已经定义的、有一定功能的操作符进行重新定义。比如：List就重写了 []。可以重新定义的操作符有：

<	+	|	[]
>	/	^	[]=
<=	~/	&	~
>=	*	<<	==
–	%	>>

class Point {
  int x;
  int y;
  //返回值 参数都可以随便定义
  Point operator *(Point point) {
    return Point(x + point.x, y + point.y);
  }

  Point(this.x, this.y);
}
void main() {
	var p1 = Point(1, 1);
	var p2 = p1 + Point(2, 2);
	print(p2.x); //打印 3
	print(p2.y); ///打印 3
}

抽象类

与Java不同，Dart中没有interface关键字，Dart中每个类都隐式的定义了一个包含所有实例成员的接口， 并且这个类实现了这个接口。

class Listener{
  void onSuccess(){}
  void onFailure(){}
}

class MyListsner implements Listener{
  MyListsner(){
  }
  
  @override
  void onSuccess() {
  }

  @override
  void onFailure() {
  }
}

这里是引用与继承的区别在于：
单继承，多实现。
继承可以有选择的重写父类方法并且可以使用super，实现强制重新定义接口所有成员。

Dart中的类和接口是统一的，类就是接口，如果你想重写部分功能，那么你可以继承一个类；如果你想实现某些功能，那么你也可以实现一个类。
使用abstract关键字来定义抽象类，并且抽象类不能被实例化，抽象方法不需要关键字，直接以分号 ; 结束即可。

//抽象类定义
abstract class Animal{ // 定义了一个 Animal类/接口
    String run(); // 这是一个抽象方法，不需要abstract关键字，是隐式接口的一部分。
}
class Lion implements Animal{ // Lion 实现了 Animal接口

 // 实现了 Animal接口要求的 run方法
    String run() {
    	return "四条腿跑";
    }   
}

可调用的类

​如果 Dart 类实现了 call() 函数则 可以当做方法来调用。

class Closure {
  call(String a, String b) => '$a $b!';
}

main() {
  var c = new Closure();
  var out = c("Hello","Dart");
  print(out);
}

混合mixins

多重继承有很多不足，例如，结构复杂化，优先顺序模糊，功能冲突等问题，而Mixin则是为了解决多继承的问题而出现。它类似于多继承，但通常混入 Mixin 的类和 Mixin 类本身并不是is-a的关系。实质上，Mixin是通过语言特性，来更简洁地实现组合模式。因此，Mixin可以灵活地添加某些功能。传统的接口概念中，并不包含实现部分，而 Mixin 包含实现。

//被mixin(混入)的类不能有构造函数
class A  {
 void a(){}
}
class B{
 void b(){}
}
class C with A,B{
 void c(){}
}

with后面跟着需要混入的类，被mixin(混入)的类不能有构造函数。现在的 C拥有了三个方法（a、b与c）。假设A与B 存在相同的方法，以最右侧的混入类为主，比如：

class A {
  String getMessage() => 'A';
}

class B {
  String getMessage() => 'B';
}
//
class AB with A, B {}

class BA  with B, A {}

void printMessage(obj) => print(obj.getMessage());

void main() {
  printMessage(AB()); //输出 B
  printMessage(BA()); //输出 A
}

继承与mixins是兼容的

class A {
  String getMessage() => 'A';
}

class B {
  String getMessage() => 'B';
}
class P{
  String getMessage() => 'P';
}
class AB extends P with A, B {}

class BA extends P with B, A {}
//可以简写成：
//class AB = P with A, B;
//class BA = P with B, A;
void printMessage(obj) => print(obj.getMessage());

void main() {
  printMessage(AB()); //输出 B
  printMessage(BA()); //输出 A
}

​ mixins弥补了接口和继承的不足，继承只能单继承，而接口无法复用实现，mixins却可以多混入并且能利用到混入类的具体实现：

abstract class Swimming{
    void swimming(){
        print("游泳");
    }
}

abstract class Jump{
    void jump(){
        print("跳跃");
    }
}

//只能单继承，如果需要Jump，只能以implements的形式
class Lance extends Swimming implements Jump{
 	//实现接口
    void jump(){
        print("跳跃");
    }
}

//但是实际上，我们经常不需要重新实现Jump方法，复用Jump所实现的jump方法就可以了
//这时使用混合能够更加方便
class Lance1 with Swimming, Jump {}