配置环境和"hello world" demo
前面已经配置过flutter的环境了，能够在控制台直接使用flutter来创建和编译运行一个flutter项目。其实flutter sdk已经包含了dart sdk，其在fluuter的bin/cache目前下，名叫dart-sdk，在dart-sdk目录下也有一个bin目录，这个bin目录中就有一个dart命令命令，将dart-sdk/bin配置到环境变量的path就能在任意位置使用dart命令。
最佳配置应该是跟flutter的配置方法一样，先在环境变量配置文件中配置一个DART_HOME，然后再将dart-sdk的bin给连接到path上去。
export DART_HOME=$FLUTTER_HOME/bin/cache/dart-sdk
export path=$path:$DART_HOME/bin 这样的好处再明显不过了，如果flutter的位置变了，只需要将FLUTTER_HOME修改就行，DART_HOME和path所引用的都只是相对路径，不需要修改。将dart-sdk的bin配置到path后重启一下控制台程序，就可以发现dart命令了，执行一下dart --version，可以如果没有报找不到命令，并且正确输出了dart的版本号，就说明配置好了。
还是用世界性的编程题目——"hello world"来测一下，创建一个目录，在这个目录下创建一个test.dart文件，在其中写入hello world的dart程序。
// demo dart
void main() {
print('hello world!');
} 回到控制台，执行命令`dart test.dart`，可见控制台输出了"hello world!"
Dart的变量数据类型
  看了dart的代码，发现它其实也是一门类C的语言，所有的代码都是由变量与方法组成，程序控制结构也包括了顺序结构，判断分支结构与循环结构。
Dart用var来声明一个变量，这跟JS很像，并且还可以自动类型推断，比如var number = 20;就是声明了一个int的变量，并且赋值了20，当然也可以给变量指定类型，比如String name = "Benson"。Dart跟Java和C/C++一样，每行的最后以一个分号结尾，不加分号会编译失败，同样，注释也是使用双左斜杠"//"。
Dart还支持动态类型，一般来说当一个变量声明时就确定了它的类型了，除了像Java这种面向对象语言可以将变量声明为Object类型的，那这个类型就可以用来赋值为任何对象了，包括基本数据类型，因为Java对所有基本数据类型都给也了其包装类型，如double的包装类型是Double。而Dart直接支持动态类型，只需要使用dynamic来声明一个变量即可。如下demo
// dynamic type demo
main() {
dynamic t = "Benson";
print(t);
t = 20;
print(t);
} 这段代码是可以编译并正常运行的，执行dart命令来编译并运行，会输出
Benson
20 Dart跟python一样，是门完全面向对象语言，任何变量或常量都是对象，因为所有的变量的默认值都是null
几乎所有的语言都支持了常量，那Dart有什么理由不支持呢？Dart同时支持final和const，其中final表示只可赋值一次，而const表示引用的是个字面量，在编译期就决定了它的真实值。
Dart支持的内置类型也非常丰富，主要包括以下各类
数值型：int和double
字符串：String，字符串可以用单引号''，也可以用双引号""，和其它语言一样，双引号可以内嵌表达式，表达式以$开头，而单引号的字符串不支持。
逻辑值：bool，只有true和false两个取值。
数组类型：List，Dart用范型List来表示数组，同时也可以当成列表来使用。
集合类型：Set，跟其他语言一样，其中的元素值只能有一个，不可重复。
Map：key-value映射，使用方式跟JS中的JSON类型类型
字符类型：Runes
函数
Dart语言的函数跟Java的特别相似，只是Dart的函数可以不需要声明函数的类型和参数的类型，当然也是可以声明的。Dart也跟Kotlin一样，当函数的实现只有一行代码时，可直接用表达式来写，例如
bool isNoble(int atomicNumber) => _nobleGases[atomicNumber] != null; Dart语言的函数还支持命名可选参数，定义时如下
void enableFlags({bool bold, bool hidden}) {...} 而使用时，则是
enableFlags(bold: true, hidden: false); 当某些命名参数必填时，可用@required注解来修饰参数定义
Dart函数的位置可选参数使用[]来定义，如
String say(String from, String msg, [String device]) {...} 对于默认参数，在定义可选参数时，可直接在定义函数时，使用=来给出默认值，例如
void enableFlags({bool bold = false, bool hidden = true}) {...} 或者位置可选参数的默认值
String say(String from, String msg, [String device = "none"]) {...} Dart语言作为比Java更面向对象的语言，和JS一样，将函数作为了一等对象，也就是所有的函数都是对象类型，且可以赋值给变量，并且Dart还支持匿名函数或者说是Lambda
main() {
var list = ["test1", "test2", "test3"];
list.forEach((item) {
print("item is $item");
});
} 这几行代码就演示了list.forEarch函数的参数就是一个函数，而这个参数在赋值时传入了一个lambda表达式。
Dart的逻辑控制跟Java几乎一模一样，都有if-else，for循环，while,do-while循环。Dart的异常处理跟Java也非常类似，只是写法不太一样，抛异常使用throw指令，可以抛一个任意对象，而catch指令则需要用on来指定异常的类型，如下
try {
doSomeThing();
} on Exception catch(e) {
print("...$e");
} 同样的，Dart可以使用finally来处理try的任意情况，这跟Java是一样的，不论是否有抛出异常，都会执行finally块中的内容。
类与接口
  Dart中的类的概念跟Java也几乎一样，每个类都继承自Object类，且每个类都有且只有一个父类，每个类可以有n个子类。Dart对象的创建跟方法一样，可以省略new关键词，并且传构造参数时，不仅可以像Java那样按位置传，还可以使用命名参数来传，如下两种构造方法是等价的。
class Point {
num x, y;
Point(this.x, this.y);
}
var p1 = Point(1, 2);
var p2 = Point({'x':1, 'y': 2}); Dart可以使用对象的runtimeType属性来返回这个对象的Type对象，也就是它的对象类型。
关于Dart中如何来创建一个类，这跟Java也是非常相似的，
class Point {
num x;
num y;
num z = 0;
Point(num x, num y) {
this.x = x;
this.y = y;
}
} 由于Dart的所有变量默认值都是null，因此类中的属性默认值也都是null，当构造器传入参数对应其属性的话，则构造器可省略赋值语句，变成
class Point {
num x, y;
Point(this.x, this.y);
} Dart还有一个叫作命名构造函数，其作用类似于Java的create生成方法，如下
class Point {
num x;
num y;
Point(this.x, this.y);
Point.fromJson(Map<String, num> map) {
this.x = map["x"];
this.y = map["y"];
} Dart的继承也使用extends关键词，子类也默认不继承父类的构造函数，如要调用父类的构造函数，则需要在子类的构造函数中显式地调用父类的构造函数
class Point {
num x;
num y;
Point(this.x, this.y);
Point.fromJson(Map<String, num> map) {
this.x = map["x"];
this.y = map["y"];
}
}
class PointV3 extends Point {
num z;
PointV3(num x, num y, num z): super(x, y) {
this.z = z;
}
}
main() {
var p1 = Point(1, 2);
print("x=${p1.x},y=${p1.y}");
var p2 = Point.fromJson({"x":3, "y":4});
print("x=${p2.x},y=${p2.y}");
var p3 = PointV3(1, 2, 3);
print("x=${p3.x},y=${p3.y},z=${p3.z}");
} Dart也支持抽象类和抽象方法，只不过抽象类中的抽象方法不再需要在方法前面声明abstract关键词了，只需要在类名前加abstract关键词，
abstract class Person {
say(String str);
}
class DXB extends Person {
say(String str) {
print("xiaobing say:$str");
}
}
main() {
var dxb = DXB();
dxb.say("Hello");
} Dart同样支持接口，但支持方式比较奇葩，Dart让每个类都隐匿定义了一个接口，这个接口中包含了这个类所有的成员及其实现的接口。简单点理解就是如果类A要实现B的接口，而不是继承B的实现，就可以把B当成接口来implements，这样所有类都可以成为接口了，但前提是如果使用了implements，就不是使用的继承，也就是说需要在实现类中实现接口类中定义的所有方法
// person 类。 隐式接口里面包含了 greet() 方法声明。
class Person {
// 包含在接口里，但只在当前库中可见。
final _name;
// 不包含在接口里，因为这是一个构造函数。
Person(this._name);
// 包含在接口里。
String greet(String who) => 'Hello, $who. I am $_name.';
}
// person 接口的实现。
class Impostor implements Person {
get _name => '';
String greet(String who) => 'Hi $who. Do you know who I am?';
}
String greetBob(Person person) => person.greet('Bob');
void main() {
print(greetBob(Person('Kathy')));
print(greetBob(Impostor()));
} 和其他语言一样，Dart也使用enum关键词来支持枚举类型，其实我一直都觉得所有的面向对象语言的枚举设计都很鸡肋，要说枚举支持switch，那int也是支持的，所有地方的枚举都可以用int来代替，只能说编译期检查值范围是枚举唯一的用处了，但其实Java在Android中也是支持用注解来定义值范围的，比如用注解来标注传入的值必须是资源id类型或者特定字符串范围。
Dart同样也支持静态成员，静态成员属于类的，也用static来修饰。
Dart的范型
前面有提到Dart的集合类型，如Set、List和Map，这些集合类型都是带有范型参数的，与Java的范型有区别的是，Dart的范型是"固化的"，简单点理解就是Dart的范型参数能够在支持期检查到，而Java的范型参数在编译期就会被擦除，最典型的现象就是Dart可以使用names is List<String>来判断集合的具体类型，而Java这样写直接就会报语法错误，只能判断name instanceOf List
说到范型就不得不说说协变和逆变了，所谓协变就是使用泛型集合get到的泛型值需要使用协变的父类型来引用，这样才能类型安全，而逆变则相反，是指add集合的值必须是逆变的子类
```
static class A {
}
static class B extends A {
}
static class C extends A {
}
static class D extends B {
}
static void test() {
List<? extends A> list1 = new ArrayList<>();
List<? super B> list2 = new ArrayList<>();
A a = new A();
B b = new B();
C c = new C();
D d = new D();
list1.add(a); // 语法错误
list1.add(b); // 语法错误
list1.add(c); // 语法错误
list1.add(d); // 语法错误
A a1 = list1.get(0);
B b1 = (B) list1.get(0);
C c1 = (C) list1.get(0);
D d1 = (D) list1.get(0);
list2.add(a); // 语法错误
list2.add(b);
list2.add(c); // 语法错误
list2.add(d);
A a2 = (A) list2.get(0);
B b2 = (B) list2.get(0);
C c2 = (C) list2.get(0);
D d2 = (D) list2.get(0);
} ```
在这段代码中，有一处是非常出乎人意料的，就是list1在add时，居然四种类型的值都会语法错误，这就是因为list1的泛型参数是协变的，协变是用来适配get的值使用父类引用的，因此A a1 = list1.get(0)就不需要强转。而list2.add(b)和list2.add(d)没有语法错误就是逆变在起作用，由于逆变可以add任意子类，因为在get时全部都要强转，而这些都是有可能会强转异常的。
Dart的导库
Dart跟Java一样，使用import关键词来导库，但库的定位不再是package指定的包名，而是一个URI，同时，导的库也可以使用as关键词来重命令，以此来避免库名重复导致的歧义。
Dart的导库还支持部分导入，用show关键词来选择性导入，用hide关键词来屏蔽导入。
Dart异步编程
Dart使用await、async和Future类型来提供异步支持。其中的Future比较类似于JS中的Promise，创建一个Promise时需要传入一个闭包，这个闭包中要执行耗时任务。同样Future创建时也传入一个匿名函数，这个匿名函数中可以执行耗时操作，同时Future还提供了then和catchError函数，也是要传入匿名函数，分别处理正常执行结果和异常结果，但执行then和catchError函数后，并不会马上执行耗时任务的匿名函数，这就是Dart提供的异步编译框架。
```
import 'dart:async';
Future<String> sayHello(String name) async {
return Future(() {
Future.delayed(const Duration(seconds: 1));
print("int call...");
return "hello $name";
});
}
main() async {
print("before call...");
sayHello("xiaobing")
.then((res) {
print(res);
})
.catchError((error) {
print(error);
});
print("after call...");
} 在上面这个例子中，打印结果是
before call...
after call...
int call...
hello xiaobing 分析可知先执行了main函数中的before call和after call，然后才执行耗时匿名函数，成功返回后将结果打印出来。
对于await和async的使用，可以想象这样一种场景，用网络请求登录，再获取用户信息，最后将用户信息保存到本地。这个场景中三个任务都是异步的，但三个任务是有先后关系的，如果只用Future，我们会写出如下嵌套层的代码
Future<String> login() {
return Future(() => "token");
}
Future<String> getUserInfo(String token) {
return Future(() => "xiaobing-$token");
}
Future<String> saveUserInfo(String name) {
return Future(() {
print("save $name");
return name;
});
}
main() {
login().then((token) => getUserInfo(token)
.then((name) => saveUserInfo(name).then((name) => print("saveUserInfo $name success..."))
));
} 但若使用async + await就可以避免这种嵌套写法
Future<String> login() {
return Future(() => "token");
}
Future<String> getUserInfo(String token) {
return Future(() => "xiaobing-$token");
}
Future<String> saveUserInfo(String name) {
return Future(() {
print("save $name");
return name;
});
}
main() async {
var token = await login();
var name = await getUserInfo(token);
var saveResult = await saveUserInfo(name);
print("saveUserInfo $saveResult success");
} await指令是等待Future的耗时任务执行完，并将结果解包成普通类型，而aysnc是在使用await的函数上必须加的，因为await表示要等待，等待则必须异步，async则表示这个函数是个异步函数。
494
被折叠的 条评论
为什么被折叠?
到【灌水乐园】发言
