闭包

1. 闭包是一个方法（对象）

2. 闭包定义在其他方法内部

3. 闭包能够方位外部方法内的局部变量，并持有其状态

Map常用操作

List常用操作

泛型

1、Dart类型是可选的，可使用泛型限定类型

2、使用泛型能够有效的减少代码重复

3、类的泛型、方法的泛型

class Utils<T> {
  T element;
  void putInt(T element) {
    this.element = element;
  }
}

void main(List args) {
  var u= new Utils();
  u.put<String>("ssdas");
  u.put<int>(11);
}

class Utils {

 void put<T> (T e) {
   print(e);
 }
}

枚举

1、是一种有穷序列集的数据类型

2、使用关键字enum定义一个枚举

3、常用于代替常量，控制语句等

dart枚举特性

1、index从0开始，依次累加

2、不能指定原始值

3、不能添加方法

class Person {
   int age;

   Person(this.age);

   bool operator > (Person person) {
     return this.age > person.age;
   }

   int operator [] (String str) {
     if (str == "age") {
       return this.age;
     }
     return 0;
   }

   @override
   bool operator ==(Object other) =>
       identical(this, other) ||
           other is Person &&
               runtimeType == other.runtimeType &&
               age == other.age;

   @override
   int get hashCode => age.hashCode;



}

对象操作符覆写

1、覆写操作符需要在类中定义

返回类型 operator 操作符 (参数1，参数2...){

实现体...

return 返回值；

}

2、如果覆写==，还需要覆写对象的hashCode getter方法，可以工具直接生成

abstract class A {
  void run();
}

class B implements A{
  @override
  void run() {
    // TODO: implement run
    print("b...A");
  }
}

class C implements A{
  @override
  void run() {
    // TODO: implement run
    print("c...A");
  }
}

class E {
  String name;
  void run(){}
}

class D extends E with B{

}

class DE extends E with C{

}

Mixins

1、Mixins类似于多继承，是在多类继承中重用一个类代码的方式

（注意：若多个类有重名的默认调用继承最后一个类中的方法）

class D extends A with B,C {

}

2、作为Mixin的类不能有显示声明构造方法

3、作为Mixin的类只能继承于Object，implements继承的不影响

4、使用关键字with连接一个或多个mixin

class D  extends A with C,B {
  d() {}
}

dart接口

1、类和接口是统一的，类就是接口

2、每个类都隐式的定义了一个包含所有实例成员的接口，抽象类也不另外

3、如果是复用已有类的实现，使用继承extends

4、如果只是使用已有类的外在行为，使用接口implements，

Dart 抽象类

1、抽象类使用abstract表示，不能直接被实例化

2、抽象方法不用abstract修饰，无实现

abstract class Person {
void run();
void study() {}
}

3、抽象类可以没有抽象方法

4、有抽象方法的类一定得声明为抽象类

继承中的构造方法

1、子类的构造方法默认会调用父类的无名无参构造方法

2、如果父类没有无名无参构造方法，则需要显示调用父类构造方法

3、在构造方法参数后使用：显示调用父类构造方法

构造方法执行顺序

1、父类的构造方法在子类构造方法体开始执行的位置调用

2、如果有初始化列表，初始化列表会在父类构造方法之前执行

class Student extends Person {
  int age;
  final String gender;

  Student(String name,String g) : gender = g , super.withName(name);
}

Dart继承

使用关键字extends继承一个类

子类会继承父类可见的属性和方法，不会继承构造方法

子类能够复写父类的方法，getter和setter

单继承，多态性

import 'Person.dart';

void main(List args) {
//  var student = new Student();
//  student.study();
//  student.name = "Tome";
//  student.age = 15;
//  print(student.isAudit);
//  student.run();

Person person = new Student();
//(person as Student).study();
if (person is Student) {
  person.study();
}
print(person);
}

class Student extends Person{

  void study() {
    print("student study...");
  }

  @override
  // TODO: implement isAudit
  bool get isAudit => age > 15;

  @override
  void run() {
    print("student run ...");
  }
}

对象call方法

dart中方法可以作为对象操作，对象也可以作为方法使用

1、如果类实现了call()方法，则该类的对象可以作为方法使用

class Person {
  String name;
  int age;
//只需要方法名为call就行
    call(String name, int age) {
    return "work ...$name. age is $age";
  }


}

对象操作符

条件成员访问： ?.

var person = new Person();
person?.work();

对成员是否为空进行判断

类型转换as

var person;
person = "";
person = new Person();
(person as Person).work();

是否指定类型：is, is!

  var person;
  person = "";
  person = new Person();
//  (person as Person).work();
if (person is Person) {
  person.work();
}

级联操作：..

var person = new Person();
person..name = "Tome"
..age = 20..work();