Dart基础二方法，类，异常_```dartimport 'dart:io';class mariogame { int scor

官方网站：https://www.dartlang.org/guides/language/language-tour

细节中文教程：https://www.jianshu.com/p/9e5f4c81cc7d

# Dart基础

## 类

 

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

 

```dart

//每个实例变量都会自动生成一个 getter 方法（隐含的）。 非final 实例变量还会自动生成一个 setter 方法。

class Point {

  num x;

  num y;

}

```

 

### 构造函数

 

​ 由于把构造函数参数赋值给实例变量的场景太常见了， Dart 提供了一个语法糖来简化这个操作：

 

```dart

class Point {

  num x;

  num y;

 

  Point(this.x, this.y);

}

```

 

### 命名构造函数

 

​ Dart 并不支持构造函数的重载，而采用了命名构造函数为一个类实现多个构造函数：

 

```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);

```

 

 

 

### 初始化列表

 

​ 在构造函数函数体执行之前会首先执行初始化列表，非常适合用来设置 final 变量的值。 

 

```dart

class Point {

  num x;

  num y;

  Point(this.x, this.y);

  //命名构造函数

  Point.y(this.y) {

    x = 0;

  }

 

  Point.fromMap(Map map)

      : x = map['x'], // : 和c++一样，初始化列表

        y = map['y'];

  

  Point.x(int i)

      : x = i, 

        y = 0;

}

```

 

 

 

### 重定向构造函数

 

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

 

```dart

class Point {

  num x;

  num y;

 

  Point(this.x, this.y);

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

}

```

 

 

 

### 常量构造函数

 

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

 

```dart

class ImmutablePoint {

  final num x;

  final num y;

  //常量构造函数

  const ImmutablePoint(this.x, this.y);

}

 

void main(){

    //编译器常量

    var p1 = const ImmutablePoint(0,0);

    var p2 = const ImmutablePoint(0,0);

    print(p1 == p2); // true

}

```

 

 

 

### 工厂构造函数

 

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

 

```dart

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);

}

```

 

​ 借助工厂构造函数能够实现单例:

 

```dart

//使用工厂构造实现单例

class Manager {

  static Manager _instance;

  //和static是一样的, 区别是factory毕竟是构造函数，需要返回一个实例，而static是静态方法。

  factory Manager.getInstance() {

    if (_instance == null) {

      _instance =  new Manager._internal();

    }

    return _instance;

  }

 

//  static Manager getInstance() {

//    if (_instance == null) {

//      _instance = new Manager._internal();

//    }

//    return _instance;

//  }

  Manager._internal();

}

 

```

 

 

 

### Getters 和 Setters

 

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

 

```dart

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

 

### 可覆写的操作符

 

​ 把已经定义的、有一定功能的操作符进行重新定义。可以重新定义的操作符有：

 

| `<`  | `+`  | `|`  | `[]`  |

| ---- | ---- | ---- | ----- |

| `>`  | `/`  | `^`  | `[]=` |

| `<=` | `~/` | `&`  | `~`   |

| `>=` | `*`  | `<<` | `==`  |

| `–`  | `%`  | `>>` |       |

 

​ 比如：List就重写了 `[]`。

 

```dart

class Point {

  int x;

  int y;

  //返回值 参数随你定义

  Point operator +(Point point) {

    return Point(x + point.x, y + point.y);

  }

 

  Point(this.x, this.y);

}

 

var p1 = Point(1, 1);

var p2 = p1 + Point(2, 2);

print(p2.x); ///3

print(p2.y); ///3

```

 

 

 

### 抽象类

 

​ 使用 `abstract` 修饰符定义一个抽象类。抽象类中允许出现无方法体的方法

 

```dart

abstract class Parent {

  String name;

  void printName(); //抽象方法，不需要在方法前声明 abstract

}

```

 

​ 抽象类不能被实例化，除非定义工厂方法并返回子类。

 

```dart

abstract class Parent {

  String name;

  //默认构造方法

  Parent(this.name);

  //工厂方法返回Child实例

  factory Parent.test(String name){

    return new Child(name);

  }

  void printName();

}

// extends 继承抽象类

class Child extends Parent{

  Child(String name) : super(name);

 

  @override

  void printName() {

    print(name);

  }

}

 

void main() {

  var p = Parent.test("Lance");

  print(p.runtimeType); //输出实际类型 Child

  p.printName();

}

 

```

 

### 接口

 

​ 与Java不同，Dart中没有`interface`关键字，**Dart中每个类都隐式的定义了一个包含所有实例成员的接口**， 并且这个类实现了这个接口。如果你想 创建类 A 来支持 类 B 的 方法，而不想继承 B 的实现， 则类 A 应该实现 B 的接口。

 

```dart

class Listener{

  void onComplete(){}

  void onFailure(){}

}

 

class MyListsner implements Listener{

  MyListsner(){

 

  }

  @override

  void onComplete() {

  }

 

  @override

  void onFailure() {

  }

}

```

 

与继承的区别在于：

 

1、单继承，多实现。

 

2、继承可以有选择的重写父类方法并且可以使用`super`，实现强制重新定义接口所有成员。

 

 

 

### 可调用的类

 

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

 

```dart

class Closure {

  call(String a, String b) => '$a $b!';

}

 

main() {

  var c = new Closure();

  var out = c("Hello","Dart");

  print(out);

}

```

 

 

 

### 混合mixins

 

​ Mixins 是一种在多类继承中重用 一个类代码的方法。它的基本形式如下：

 

```dart

//被mixin(混入)的类不能有构造函数

class A  {

  void a(){}

}

class B{

  void b(){}

}

class C with A,B{

  void c(){}

}

```

 

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

 

```dart

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是兼容的

 

```dart

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却可以多混入并且能利用到混入类的具体实现：

 

```dart

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 {}

```

 

 

 

## 异步编程

 

### ioslate机制

 

​ Dart是基于单线程模型的语言。但是在开发当中我们经常会进行耗时操作比如网络请求，这种耗时操作会堵塞我们的代码，所以在Dart也有并发机制，名叫**isolate**。APP的启动入口`main`函数就是一个类似Android主线程的一个主isolate。和Java的Thread不同的是，Dart中的isolate无法共享内存。

 

```dart

import 'dart:isolate';

 

int i;

 

void main() {

  i = 10;

  //创建一个消息接收器

  ReceivePort receivePort = new ReceivePort();

  //创建ioslate

  Isolate.spawn(isolateMain, receivePort.sendPort);

 

  //接收其他isolate发过来的消息

  receivePort.listen((message) {

    //发过来sendPort,则主isolate也可以向创建的isolate发送消息

    if (message is SendPort) {

      message.send("好呀好呀!");

    } else {

      print("接到子isolate消息:" + message);

    }

  });

}

 

/// 新isolate的入口函数

void isolateMain(SendPort sendPort) {

  // isolate是内存隔离的，i的值是在主isolate定义的所以这里获得null

  print(i);

 

  ReceivePort receivePort = new ReceivePort();

  sendPort.send(receivePort.sendPort);

 

 

  // 向主isolate发送消息

  sendPort.send("去大保健吗？");

 

 

  receivePort.listen((message) {

    print("接到主isolate消息:" + message);

  });

}

```

 

 

 

### event-loop

 

​ 可以看到代码中，我们接收消息使用了`listene`函数来监听消息。假设我们现在在main方法最后加入`sleep`休眠，会不会影响`listene`回调的时机？

 

```dart

import 'dart:io';

import 'dart:isolate';

 

int i;

 

void main() {

  i = 10;

  //创建一个消息接收器

  ReceivePort receivePort = new ReceivePort();

  //创建ioslate

  Isolate.spawn(isolateMain, receivePort.sendPort);

 

  //接收其他isolate发过来的消息

  receivePort.listen((message) {

    //发过来sendPort,则主isolate也可以向创建的isolate发送消息

    if (message is SendPort) {

      message.send("好呀好呀!");

    } else {

      print("接到子isolate消息:" + message);

    }

  });

 

  //增加休眠，是否会影响listen的时机？

  sleep(Duration(seconds: 2));

  print("休眠完成");

}

 

/// 新isolate的入口函数

void isolateMain(SendPort sendPort) {

  // isolate是内存隔离的，i的值是在主isolate定义的所以这里获得null

  print(i);

 

  ReceivePort receivePort = new ReceivePort();

  sendPort.send(receivePort.sendPort);

  // 向主isolate发送消息

  sendPort.send("去大保健吗？");

 

 

  receivePort.listen((message) {

    print("接到主isolate消息:" + message);

  });

}

```

 

​ 结果是大概2s后，我们的`listene`才打印出其他isolate发过来的消息。同Android Handler类似，在Dart运行环境中也是靠事件驱动的，通过event loop不停的从队列中获取消息或者事件来驱动整个应用的运行，isolate发过来的消息就是通过loop处理。但是不同的是在Android中每个线程只有一个Looper所对应的MessageQueue，而Dart中有两个队列，一个叫做**event queue(事件队列)**，另一个叫做**microtask queue(微任务队列)**。

 


 

​ Dart在执行完main函数后，就会由Loop开始执行两个任务队列中的Event。首先Loop检查微服务队列，依次执行Event，当微服务队列执行完后，就检查Event queue队列依次执行，在执行Event queue的过程中，没执行完一个Event就再检查一次微服务队列。所以微服务队列优先级高，可以利用微服务进行插队。

 

 

 

我们先来看个例子:

 

```dart

 

import 'dart:io';

 

void main(){

  new File("/Users/enjoy/a.txt").readAsString().then((content){

      print(content);

  });

  while(true){}

}

```

 

文件内容永远也无法打印出来，因为main函数还没执行完。而then方法是由Loop检查Event queue执行的。

 

如果需要往微服务中插入Event进行插队：

 

```dart

 

import 'dart:async';

import 'dart:io';

//结果是限制性了microtask然后执行then方法。

void main(){

  new File("/Users/enjoy/a.txt").readAsString().then((content){

      print(content);

  });

  //future内部就是调用了 scheduleMicrotask

  Future.microtask((){

    print("future: excute microtask");

 

  });

//  scheduleMicrotask((){

//    print("");

//  });

 

}

```

 

 

 

### Future

 

​ 在 Dart 库中随处可见 Future 对象，通常异步函数返回的对象就是一个 Future。 当一个 future *执行完后*，他里面的值 就可以使用了，可以使用 `then()` 来在 future 完成的时候执行其他代码。

 

#### 异常

 

```dart

//当给到一个不存在的文件地址时会发生异常，这时候可以利用catchError捕获此异常。

//then().catchError() 模式就是异步的 try-catch。

new File("/Users/enjoy/a1.txt").readAsString().then((content) {

    print(content);

  }).catchError((e, s) {

    print(s);

  });

```

 

#### 组合

 

`then()`的返回值同样是一个future对象，可以利用队列的原理进行组合异步任务

 

```dart

  new File("/Users/enjoy/a.txt").readAsString().then((content) {

    print(content);

    return 1; //1被转化为 Future<int>类型 返回

  }).then((i){

    print(i);

  }).catchError((e, s) {

    print(s);

  });

```

 

上面的方式是等待执行完成读取文件之后，再执行一个新的future。如果我们需要等待一组任务都执行完成再统一处理一些事情，可以通过`wait()`完成。

 

```dart

 Future readDone = new File("/Users/enjoy/a.txt").readAsString();

  //延迟3s

  Future delayedDone = Future.delayed(Duration(seconds: 3));

 

  Future.wait([readDone, delayedDone]).then((values) {

     print(values[0]);//第一个future的结果

     print(values[1]);//第二个future的结果

  });

```

 

 

 

### Stream

 

​ Stream(流) 在 Dart API 中也经常出现，表示发出的一系列的异步数据。 Stream 是一个异步数据源，它是 Dart 中处理异步事件流的统一 API。

 

​ Future 表示稍后获得的一个数据，所有异步的操作的返回值都用 Future 来表示。但是 Future 只能表示一次异步获得的数据。而 Stream 表示多次异步获得的数据。比如 IO 处理的时候，每次只会读取一部分数据和一次性读取整个文件的内容相比，Stream 的好处是处理过程中内存占用较小。而 File 的 `readAsString()`是一次性读取整个文件的内容进来，虽然获得完整内容处理起来比较方便，但是如果文件很大的话就会导致内存占用过大的问题。

 

```dart

 new File("/Users/enjoy/app-release.apk").openRead().listen((List<int> bytes) {

    print("stream执行"); //执行多次

  });

 

  new File("/Users/enjoy/app-release.apk").readAsBytes().then((_){

    print("future执行"); //执行1次

  });

```

 

`listen()`其实就是订阅这个Stream，它会返回一个`StreamSubscription`订阅者。订阅者肯定就提供了取消订阅的`cancel()`，去掉后我们的listen中就接不到任何信息了。除了`cancel()`取消方法之外，我们还可以使用`onData()`重置listene方法，`onDone`监听完成等等操作。

 

```dart

  StreamSubscription<List<int>> listen = new File("/Users/enjoy/app-release.apk").openRead().listen((List<int> bytes) {

    print("stream执行");

  });

  listen.onData((_){

    print("替代listene");

  });

  listen.onDone((){

    print("结束");

  });

  listen.onError((e,s){

    print("异常");

  });

  //暂停，如果没有继续则会退出程序

  listen.pause();

  //继续

  listen.resume();

```

 

 

 

#### 广播模式

 

​ Stream有两种订阅模式：单订阅和多订阅。单订阅就是只能有一个订阅者，上面的使用我们都是单订阅模式，而广播是可以有多个订阅者。通过 Stream.asBroadcastStream() 可以将一个单订阅模式的 Stream 转换成一个多订阅模式的 Stream，isBroadcast 属性可以判断当前 Stream 所处的模式。

 

```dart

var stream = new File("/Users/enjoy/app-release.apk").openRead();

  stream.listen((List<int> bytes) {

  });

  //错误 单订阅只能有一个订阅者

//  stream.listen((_){

//    print("stream执行");

//  });

 

  var broadcastStream = new File("/Users/enjoy/app-release.apk").openRead().asBroadcastStream();

  broadcastStream.listen((_){

    print("订阅者1");

  });

  broadcastStream.listen((_){

    print("订阅者2");

  });

```

 

需要注意的是，多订阅模式如果没有及时添加订阅者则可能丢数据。

 

```dart

//默认是单订阅

  var stream = Stream.fromIterable([1, 2, 3]);

  //3s后添加订阅者 不会丢失数据

  new Timer(new Duration(seconds: 3), () => stream.listen(print));

 

  //创建一个流管理器 对一个stream进行管理

  var streamController = StreamController.broadcast();

  //添加

  streamController.add(1);

  //先发出事件再订阅 无法接到通知

  streamController.stream.listen((i){

    print("broadcast:$i");

  });

  //记得关闭

  streamController.close();

 

 

  //这里没有丢失，因为stream通过asBroadcastStream转为了多订阅，但是本质是单订阅流，并不改变原始 stream 的实现特性

  var broadcastStream = Stream.fromIterable([1, 2, 3]).asBroadcastStream();

  new Timer(new Duration(seconds: 3), () => broadcastStream.listen(print));

```

 

 

 

### async/await

 

​ 使用`async`和`await`的代码是异步的，但是看起来很像同步代码。当我们需要获得A的结果，再执行B，时，你需要`then()->then()`,但是利用`async`与`await`能够非常好的解决回调地狱的问题：

 

```dart

//async 表示这是一个异步方法,await必须再async方法中使用

//异步方法只能返回 void和Future

Future<String> readFile() async {

  //await 等待future执行完成再执行后续代码

  String content = await new File("/Users/xiang/enjoy/a.txt").readAsString();

  String content2 = await new File("/Users/xiang/enjoy/a.txt").readAsString();

  //自动转换为 future

  return content;

}