dart快速入门教程 （7.4）

7.12.多态

多态字面上理解就是多种状态，通俗的说，多态表现为父类定义一个方法不去实现，子类继承这个方法后实现父类的方法，这个方法有多种表现

// import 'person.dart';

void main() {
  var d = Dog();
  d.run();
}

abstract class Animal {
  run();
}

class Dog extends Animal {
  @override
  run() {
    // 表现1
    print("小狗在跑");
  }
}

class Cat extends Animal {
  @override
  run() {
    // 表现2
    print("小猫在跑");
  }
}

7.13.接口

接口用于定义规范，和抽象类是类似的,接口里面定义的方法必须被实现，接口中的方法只能为抽象方法 新建lib文件夹，里面建DB.dart、Mysql.dart、MongoDB.dart文件

DB.dart 定义接口

abstract class DB {
  find();
  save();
  update();
  delete();
}

Mysql.dart实现接口

import 'DB.dart';

class Mysql implements DB {
  Mysql(_uri) {
    print("根据${_uri}链接数据库");
  }
  @override
  save() {
    print("增加数据");
  }

  @override
  find() {
    print("查询数据");
  }

  @override
  update() {
    print('更新数据');
  }

  @override
  delete() {
    print("删除数据");
  }

  @override
  String get uri => null;
}

MongoDB.dart 实现接口

import 'DB.dart';

class MongoDB implements DB {
  MongoDB(_uri) {
    print("根据${_uri}链接数据库");
  }
  @override
  save() {
    print("增加数据");
  }

  @override
  find() {
    print("查询数据");
  }

  @override
  update() {
    print('更新数据');
  }

  @override
  delete() {
    print("删除数据");
  }
}

调用

import 'lib/Mysql.dart';

void main() {
  var connection = new Mysql("http://127.0.0.1");
  connection.save();
}

7.14.接口和抽象类的相同点和区别

它们的相同点是：1 都是上层的抽象 2 都不能被实例化 3 都包含抽象方法，但是不必具体实现

它们的不同点：从设计的角度讲，接口设计的目的是规范到底有哪些行为，是一种约束机制，规范不同的类必须具有某些相同的行为即可，即法律规定的就是必须遵守的，法律没有规定的没有人管你，而抽象类设计的目的是代码复用，当不同的类具有某些相同的行为，比如猫和狗都有吃东西、睡觉的行为，把这些相同行为都放到一个抽象类中，其中吃东西的行为两个类是一致的，睡觉的行为有差异，因此，吃东西的行为可以在抽象类中就可以先实现了，避免子类重复去实现这个行为，而睡觉这种行为两个类有差异，就让它们各自去实现

举例：

import 'dart:io';

void main() {
  var c = new Cat();
  c.eat("小猫");
  c.sleep();
  var d = new Dog();
  d.eat("小狗");
  d.sleep();
}

abstract class Animal {
  eat(name) {
    print("${name}正在吃东西");
  }

  sleep();
}

class Dog extends Animal {
  sleep() {
    print("小狗晚上睡觉");
  }
}

class Cat extends Animal {
  sleep() {
    print("小猫晚上睡觉");
  }
}

7.14.Mixins

在dart中继承是单继承方式，那如果要用到多继承呢？那就需要用到Mixins，Mixins类似于多继承,一个类可以继承多个类的属性和方法

void main() {
  var d = new D();
  d.printA();
  d.printB();
  d.printC();
}

class A {
  printA() {
    print("这是A");
  }
}

class B {
  printB() {
    print("这是B");
  }
}

class C {
  printC() {
    print("这是C");
  }
}

class D extends A with B, C {}

注意：使用mixins的时候要注意继承顺序

void main() {
  var d = new D();
  d.printBC();
}

class A {
  printA() {
    print("这是A");
  }
}

class B {
  printB() {
    print("这是B");
  }

  printBC() {
    print("这是B里面的BC");
  }
}

class C {
  printC() {
    print("这是C");
  }

  printBC() {
    print("这是C里面的BC");
  }
}
// 把B，C位置换一下试试看结果
class D extends A with B, C {}

注意2: with关键字后面的类中不能显示的声明构造函数

class B {
  // 这里有声明构造方法，后面就会报错
  B() {}
  printB() {
    print("这是B");
  }

  printBC() {
    print("这是B里面的BC");
  }
}

注意3: with后面的类(B、C)只能继承Object，不能继承别的类

// 继承别的类会报错
class B extends test{
  B() {}
  printB() {
    print("这是B");
  }

  printBC() {
    print("这是B里面的BC");
  }
}

简写

void main() {
  var e = new E();
  e.printA();
  e.printB();
  e.printC();
  e.printBC();
}

class A {
  printA() {
    print("这是A");
  }
}

class B {
  printB() {
    print("这是B");
  }

  printBC() {
    print("这是B里面的BC");
  }
}

class C {
  printC() {
    print("这是C");
  }

  printBC() {
    print("这是C里面的BC");
  }
}

// 混合组装A和B得到一个新的类D
class D = A with B;
// 混合组装D和C得到一个新的类E，E实际上就是A、B、C的混合
class E = D with C;

螺钉课堂视频课程地址：http://edu.nodeing.com