官方网站：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;
}