通过dart语言(一)的学习，相信大家已经可以很熟练的写出完整的应用程序了，但是想要写出更优秀、更完美的dart语言框架，还需要更深入的理解dart语言的一些特点。
接下来，我将带领大家一起更深入的学习dart语言。
目录
泛型
使用<...> 的方式来定义泛型。
为什么使用泛型？
- 虽然Dart 语言中类型是可选的，但是明确的指明使用的是泛型，会让代码更好理解。
var names = new List<String>();
names.addAll(['xiaojian', 'lili', 'jim']);
- 使用泛型让代码更简洁
abstract class IntCache {
int getByKey(String key);
setByKey(String key, int value);
}
abstract class StringCache {
String getByKey(String key);
setByKey(String key, String value);
}
上面两个类可以优化为：
abstract class Cache<T> {
T getByKey(String key);
setByKey(String key, T value);
}
集合类型
泛型用于List 、Set、 Map 类型参数化
var names = <String>['Seth', 'Kathy', 'Lars'];
var pages = <String, String>{
'index.html': 'Homepage',
'robots.txt': 'Hints for web robots',
'humans.txt': 'We are people, not machines'
};
构造函数中参数化类型
var names = new List<String>();
names.addAll(['Seth', 'Kathy', 'Lars']);
var nameSet = new Set<String>.from(names);
var views = new Map<int, View>();
泛型集合及它们所包含的类型
var names = new List<String>();
names.addAll(['Seth', 'Kathy', 'Lars']);
print(names is List<String>); // true
库和可见性
使用import 和 library 指令可以方便的创建一个模块或分享代码。一个Dart 库不仅能够提供相应的API，还可以包含一些以_开头的私有变量仅在库内部可见。
每一个Dart 应用都是一个库，即使它没有使用library指令。库可以方便是使用各种类型的包。
使用库
使用import指定怎样的命名空间，从一个库引用另一个库。
import唯一要求的参数是指定库的URI。
- dart内置库，URI组合dart:
- 其他库，使用文件路径或package:组合，package:组合式通过包管理工具提供的。
import 'package:flutter/material.dart';
import 'Home.dart';
库的前缀
如果导入的库拥有相互冲突的名字，使用as为其中一个或几个指定不一样的前缀。
import 'package:lib1/lib1.dart';
import 'package:lib2/lib2.dart' as lib2;
Element element1 = new Element(); // Uses Element from lib1.
lib2.Element element2 = new lib2.Element(); // Uses Element from lib2.
导入库的一部分
如果只需要使用库的一部分内容，使用show或hide有选择的导入。
// 仅导入foo.
import 'package:lib1/lib1.dart' show foo;
// 除了foo都导入
import 'package:lib2/lib2.dart' hide foo;
延迟加载
延迟加载，也叫懒加载，允许应用程序按需加载库。使用延迟加载的场景：
- 减少程序初始化启动时间。
- 执行A/B测试——尝试替换一个算法的实现。
- 加载很少用的功能，比如可选的屏幕和对话框。
要延迟加载一个库，首先必须使用deferred as导入它，当需要使用库的时候，使用库名调用loadLibrary()。
import 'package:deferred/hello.dart' deferred as hello;
greet() async {
// 使用await关键字暂停执行，直到库加载
await hello.loadLibrary();
hello.printGreeting();
}
异步(async和await)
使用async函数和await表达式实现异步操作。
当需要使用一个从Future返回的值时，有两个选择：
- 使用async和await。
- 使用Future API。
当需要从一个Stream获取值时，有两个选择：
- 使用async和异步的循环(await for)。
- 使用Stream API。
代码使用了async和await就是异步的，虽然看起来像同步代码。
static postData(String path, Map<String, String> params,Function successCallBack) async {
var httpClient = HttpClient();
var uri = new Uri.https(
HOST, path, _createPostData(params));
var request = await httpClient.postUrl(uri);
var response = await request.close();
if (response.statusCode == HttpStatus.OK) {
var json = await response.transform(UTF8.decoder).join();
var data = JSON.decode(json);
print("data=====" + data.toString() );
if(successCallBack!=null){
successCallBack(data['data']);
}
} else {
print("data=====error");
}
}
声明异步函数
异步函数是一个被async标记的函数。
虽然异步的函数中可能执行耗时的操作，但是函数本身在调用后将会立即返回，即使函数体一条语句也没执行。
给函数添加async关键字将使函数返回一个Future类型
checkVersion() async {
// ...
}
lookUpVersion() async => /* ... */;
案例
getData(String path, Map<String, String> params) async {
var httpClient = HttpClient();
var uri = new Uri.https(
HOST, path, _createPostData(params));
var request = await httpClient.postUrl(uri);
var response = await request.close();
return await response.transform(UTF8.decoder).join();
}
调用函数想获得其结果：
void main(){
String a = getData("/bbs/list",map);
print(a);
}
运行后程序报错：
Failed to load "/Users/wangxiaojian/Documents/androidCode/flutter_rong_app/test/widget_test.dart": type 'Future<dynamic>' is not a subtype of type 'String'
test/widget_test.dart 55:14 main
===== asynchronous gap ===========================
package:test serializeSuite
/var/folders/j7/0w0w7vgd6s5f_gv67_jfzgjr0000gn/T/dart_test_listenerqkAJjf/listener.dart 19:27 main
因为data是String类型，而函数getData()是一个异步操作函数，其返回值是一个await延迟执行的结果。在Dart中，有await标记的运算，其结果值都是一个Future对象，Future不是String类型，所以就报错了。
那如果这样的话，我们就没法获取到延迟执行的结果了？当然可以，Dart规定有async标记的函数，只能由await来调用，比如这样：
void main() async{
// await 必须在有async标记的函数中运行
String a = await getData("/bbs/list",map);
print(a);
}
上面这种方法一般用于调用封装好的异步接口，比如getData()被封装到了其他dart文件，通过使用async函数对其调取使用
- await关键字必须在async函数内部使用
- 调用async函数必须使用await关键字
PS：await关键字真的很形象，等一等的意思，就是说，既然你运行的时候都要等一等，那我调用的时候也等一等吧
为什么要用Future？
在定义Flutter函数时，还可以指定其运行结果返回值的类型，以提高代码的可读性：
Future<String> getData(String path, Map<String, String> params) async {
var httpClient = HttpClient();
var uri = new Uri.https(
HOST, path, _createPostData(params));
var request = await httpClient.postUrl(uri);
var response = await request.close();
return await response.transform(UTF8.decoder).join();
}
Future最主要的功能就是提供了链式调用，熟悉ES6语法的小伙伴都应该很熟悉，链式调用解决两大问题：明确代码执行的依赖关系和实现异常捕获。
看下面案例：
String _name = "";
void _setName(String name) async{
_name = name;
}
void _getName() async{
await _setName("wangxiaojian");
print(_name);
}
void main() async{
await _getName();
}
如果要想先执行_getName再执行_setName，必须在_getName中await _setName();_setName的代码与_getName耦合，将来如果_getName废掉或者改动，_setName中还需要经过修改以适配变更。
为了解决此问题，Future提供了一套非常简洁的解决方案,而async和await无法企及的，因此掌握Future还是很有必要滴：
String _name = "";
_setName() {
_name = "wangxiaojian";
}
_getName() {
print(_name);
}
void main() {
new Future(_setName()).then(_getName());
}
可调用类
Dart 语言中为了能够让类像函数一样能够被调用，可以实现call()方法。
class ClassFunction {
call(String a, String b, String c) => '$a $b $c!';
}
main() {
var cf = new ClassFunction();
var out = cf("wangxiaojian","is","talent");
print('$out');
print(cf.runtimeType);
print(out.runtimeType);
print(cf is Function);
}
运行结果：
wangxiaojian is talent!
ClassFunction
String
false
类型定义
typedef关键字，用来声明一种类型，当一个函数类型分配给一个变量时，保留类型信息。
// 声明一种 Compare类型
typedef int Compare(int a, int b);
int sort(int a, int b) => a - b;
main() {
print(sort is Compare);
}
运行结果：
true
元数据
元数据是以@开始的修饰符。在@ 后面接着编译时的常量或调用一个常量构造函数。
所有dart代码中可用的三个注解：
- @deprecated 被弃用的
- @override 重载
- @proxy 代理
定义自己的元数据
通过library来定义一个库，在库中定义一个相同名字的class，然后在类中定义const 构造方法。
// 定义
library todo;
class todo {
final String who;
final String what;
const todo(this.who, this.what);
}
// 使用
import 'todo.dart';
@todo('seth', 'make this do something')
void doSomething() {
print('do something');
}
元数据可以修饰library(库), class(类), typedef(类型定义), type parameter(类型参数), constructor(构造函数), factory(工厂函数), function(函数), field(作用域), parameter(参数), 或者 variable declaration(变量声明)。
可以使用reflection反射，在运行时检查元数据。
