Dart 面向对象

Dart 面向对象，Dart作为高级语言，支持面向对象的很多特性，并且支持基于mixin的继承方式。基于mixin的继承方式是指一个类可以继承自多个父类，相当于其他语言里的多继承。所有的类都有同一个基类Object，这个特性类似于Java语言，Java所有的类也都是继承自Object，也就是说一切皆为对象。
使用语句实例化一个类，如下所示：

// 实例化了一个User类的对象user
var user = new User('张三', 20);

实例化成员变量

定义一个User类，在类中添加两个成员变量name与age，代码如下所示：

class User{
  String name; //name成员变量
  int age;      //age成员变量
}

类定义中所有的变量都会隐式地定义setter方法，针对非空的变量会额外增加getter方法。实例化成员变量请参考如下代码：

class User{
  String name; //name成员变量
  int age; //age成员变量
}


main() {
  var user = new User();
  user.name = '张三'; //相当于使用了name的setter方法
  user.age = 20;


}

构造函数

1.常规构造函数
构造函数是用来构造当前类的函数，是一种特殊的函数，函数名称必须和类名相同。如下代码为User类添加了一个构造函数，函数里给User类的两个成员变量初始化了值：

class User{


  String name;
  int age;


  User(String name,int age){
    this.name = name;
    this.age = age;
  }


}

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

class User{


  String name;
  int age;


  User(this.name,this.age);

}

2.命名的构造函数
使用命名构造函数从另一类或现有的数据中快速实现构造函数，代码如下所示：

class User {
  String name;
  int age;


  User(this.name, this.age);


  // 命名的构造函数
  User.fromJson(Map json) {
    name = json['name'];
    age = json['age'];
  }
}

3.构造函数初始化列表
除了调用父类的构造函数，也可以通过初始化列表在子类的构造函数运行前初始化实例的成员变量值，代码如下所示：

class User {
  final String name;
  final int age;


  User(name, age)
      : name = name,
        age = age;
}


main() {
  var p = User('张三', 20);
}

读取和写入对象

get和set方法是专门用于读取和写入对象的方法，每一个类的实例，系统都隐式地包含有get和set方法，这和很多语言里的VO类相似。

例如，定义一个矩形的类，有上、下、左、右四个成员变量—top、bottom、left、right，使用get及set关键字分别对right及bottom进行设置。代码如下所示：

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


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


  // 获取right值
  num get right            => left + width;


  // 设置right值，同时left也发生变化
  set right(num value)   => left = value - width;


  // 获取bottom值
  num get bottom           => top + height;


  // 设置bottom值，同时top也发生变化
  set bottom(num value) => top = value - height;
}


main() {
  var rect = Rectangle(3, 4, 20, 15);


  print('left:'+rect.left.toString());
  print('right:'+rect.right.toString());
  rect.right = 30;
  print('更改right值为30');
    print('left:'+rect.left.toString());
    print('right:'+rect.right.toString());


    print('top:'+rect.top.toString());
    print('bottom:'+rect.bottom.toString());
    rect.bottom = 50;
    print('更改bottom值为50');
    print('top:'+rect.top.toString());
    print('bottom:'+rect.bottom.toString());
  }

上面例子对应的输出为：

flutter: left:3
flutter: right:23
flutter: 更改right值为30
flutter: left:10
flutter: right:30
flutter: top:4
flutter: bottom:19
flutter: 更改bottom值为50
flutter: top:35
flutter: bottom:50

重载操作

运算符重载是多态的一种，运算符重载通常只是一种语法，这种语法对语言的功能没有影响，但是更方便程序员使用，让程序更加简洁，有更高的可读性。

operator是Dart的一个关键字，它和运算符（如=）一起使用，表示一个运算符重载函数，在理解时可将operator和运算符（如operator=）视为一个函数名。

接下来编写一个例子来实现向量的相加、相减操作。定义一个Vector向量类，编写两个方法分别用于重载加号、重载减号，那么当两个向量相加，就表示它们的x值及y值相加，当两个向量相减，就表示它们的x值及y值相减。完整的示例代码如下：

// 定义一个向量类
class Vector {
  final int x;
  final int y;
  const Vector(this.x, this.y);



  //重载加号 + (a + b)
  Vector operator +(Vector v) {
    return Vector(x + v.x, y + v.y);
  }


  //重载减号 - (a - b)
  Vector operator -(Vector v) {
    return Vector(x - v.x, y - v.y);
  }
}


main() {
  // 实例化两个向量
  final v = Vector(2, 3);
  final w = Vector(2, 2);


  final r1 = v + w;
  print('r1.x='+r1.x.toString() + ' r1.y=' + r1.y.toString());


  final r2 = v - w;
  print('r2.x='+r2.x.toString() + ' r2.y=' + r2.y.toString());
}

上面代码的输出结果为：

flutter: r1.x=4 r1.y=5
flutter: r2.x=0 r2.y=1

继承类

继承是面向对象编程技术的一块基石，因为它允许创建分等级层次的类。继承就是子类继承父类的特征和行为，使得子类对象（实例）具有父类的实例域和方法。Dart中使用extends关键字来创建一个子类，用super关键字来指定父类。

接下来定义一个动物类，动物具有吃和跑两种能力。再定义一个人类，人类是属于动物类的，人类不仅会吃和会跑，还会说、会学习，所以人类相当于动物类的子类。完整的示例如下所示：

// 动物类
class Animal {


  // 动物会吃
  void eat(){
    print('动物会吃');
  }


  // 动物会跑
  void run(){
    print('动物会跑');
  }
}
// 人类
class Human extends Animal {


  // 人类会说
  void say(){
    print('人类会说');
  }


  // 人类会学习
  void study(){
    print('人类会学习');
  }
}
main() {


  print('实例化一个动物类');
  var animal = Animal();
  animal.eat();
  animal.run();


  print('实例化一个人类');
  var human = Human();
  human.eat();
  human.run();
  human.say();
  human.study();
}

上面的例子输出结果如下：

flutter: 实例化一个动物类
flutter: 动物会吃
flutter: 动物会跑
flutter: 实例化一个人类
flutter: 动物会吃
flutter: 动物会跑
flutter: 人类会说
flutter: 人类会学习

抽象类

抽象类类似于Java语言中的接口。抽象类里不具体实现方法，只是写好定义接口，具体实现由调用者完成。抽象类中可以使用abstract关键字定义类。

接下来写一个数据库操作的抽象类的例子。定义一个抽象类DataBaseOperate，其中定义了4个数据库常用的操作方法—“增删改查”。再定义一个类，命名为DataBase-OperateImpl，继承自DataBaseOperate，用来实现抽象类中的方法。完整的代码如下所示：

// 数据库操作抽象类
abstract class DataBaseOperate {
  void insert(); //定义插入的方法
  void delete(); //定义删除的方法
  void update(); //定义更新的方法
  void query();   //定义一个查询的方法
}


// 数据库操作实现类
class DataBaseOperateImpl extends DateBaseOperate {


  // 实现了插入的方法
  void insert(){
    print('实现了插入的方法');
  }


  // 实现了删除的方法
  void delete(){
    print('实现了删除的方法');
    }


    // 实现了更新的方法
    void update(){
      print('实现了更新的方法');
    }


    // 实现了一个查询的方法
    void query(){
      print('实现了一个查询的方法');
    }


  }


  main() {


    var db = DataBaseOperateImpl();
    db.insert();
    db.delete();
    db.update();
    db.query();


  }

上述代码的输出结果为：

flutter: 实现了插入的方法
flutter: 实现了删除的方法
flutter: 实现了更新的方法
flutter: 实现了一个查询的方法

枚举类型

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

enum Color {
  red,
  green,
  blue
}

获取枚举类中所有的值，使用value常数：

List<Color> colors = Color.values;

因为枚举类里面的每个元素都是相同的类型，可以使用switch语句针对不同的值做不同的处理，示例代码如下：

enum Color {
  red,
  green,
  blue
}
// 定义一个颜色变量，默认值为蓝色
Color aColor = Color.blue;
switch (aColor) {
  case Color.red:
    print('红色');
    break;
  case Color.green:
    print('绿色');
    break;
  default: //默认颜色
    print(aColor);   //'Color.blue'
}

Mixins

Mixins（混入功能）相当于多继承，也就是说可以继承多个类。使用with关键字来实现Mixins的功能，示例代码如下所示：

class S {
  a() {print("S.a");}
}


class A {
  a(){print("A.a");}
  b(){print("A.b");}
}


class T = A with S;


main(List<String> args) {
  T t = T();
  t.a();
  t.b();
}

以上代码的输出内容如下所示，从结果上来看T具有了S及A两个类的方法：

S.a
A.b