目录

• 接口
• Mixins
• 枚举
• 泛型

1. 接口

• 类和接口是同一的，类就是接口
• 每个类都隐式的定义了一个包含所有实例成员的接口
• 如果是复用已有类的实现，使用继承（extends）
• 如果只是使用已有类的外在行为，使用接口（implements）

代码如下：

abstract class User {
  void run();
}  

class Student implements User {
  @override
  void run() {
    print("Student run...");
  }
}

void main () {
  var student = new Student();
  student.run();
}

2. Mixins

• Mixins 类似于多继承，是在多类继承中重用一个类代码的方式
• 作为Mixin 的类不能有显示申明的构造方法
• 使用关键字 with 连接一个或多个mixin

class A {
  void a() {
    print('A.a()....');
  }
}

class B {
  void a() {
    print('B.a()....');
  }

  void b() {
    print('B.b()....');
  }
}

class C {
  // 显示申明构造方法 (报错)
  // C () { }
  
  void a() {
    print('C.a()....');
  }
  
  void b() {
    print('C.b()....');
  }

  void c() {
    print('C.c()....');
  }
}

class D extends A with C, B {
  
}

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

// 打印得出：B.a()....

3. 枚举

• 枚举是一种有穷序列集
• 使用关键字 enum 定义一个枚举
• 常用于代替常量，控制语句等
• index 从0开始，依次累加
• 不能指定原始值
• 不能添加方法

// const spring = 0;
// const summer = 1;
// const autumn = 2;
// const winter = 3;

enum Season {
  spring,
  summer,
  autumn,
  winter

  // error
  // spring = 1,
  // void test() {

  // }
}

void main () {
  var type = Season.spring;

  print(type.index);

  switch (type) {
    case Season.spring:
      print('1~3月');
      break;
    case Season.summer:
      print('4~6月');
      break;
    case Season.autumn:
      print('7~9月');
      break;
    case Season.winter:
      print('10~12月');
      break;
  }
}

4. 泛型

• dart中类型是可选的，可使用泛型限定类型

void main() {
  // var list = new Lis();
  var list = new List<String>();
  list.add(1);  // 报错
  list.add("1");
}

• 使用泛型能够有效的减少代码重复
  通常情况下，我们会定义多个类型的方法来存放不同类型的值

class Utils {
  int element;
  String elementStr;

  void putInt(int element) {
    this.element = element;
  }

  void putStr(String elementStr) {
    this.elementStr = elementStr;
  }
}

如果使用泛型，类泛型的使用，代码如下：

void main() {
  var list = new List<int>();
  list.add(1);

  // var utils = new Utils<String>();
  // utils.put("string");

  var utils = new Utils<int>();
  utils.put(1);

}

class Utils<T> {
  T element;

  void put(T element) {
    this.element = element;
  }

}

方法泛型使用，代码如下

void main() {
  var utils = new Utils();
  utils.put<int>(1);
  utils.put<String>('string');
}

class Utils {
  void put<T>(T element) {
    print(element);
  }
}