总结：

静态变数也被称为 类变数 静态方法也被称为 类方法 静态变数都是懒载入的，意思就是当你在程序中使用到的时候该静态变数才会被初始化。 静态变数或者静态方法与类的实例无关，它们都属于类本身，所以我么在静态方法中不能使用 this 关键字 在静态方法中，我们只能访问静态方法或者静态变数，不能访问该类中的实例变数或者实例方法

高阶函数和 Lambda 表达式

在 Dart 中，方法也是一个对象 Lambda 是一个没有方法名的方法

下面我们来看看示例：

void main() {
// 普通方法调用
addTwoNumbers(2, 3);

// 没有返回值的 Lambda
Function addTwoNumbersByFunction = (int a, int b) {
var sum = a + b;
print($sum);
};

addTwoNumbersByFunction(2, 3);

// 带有返回值的 Lambda
var sum = (int a, int b) {
return a + b;
};

print(${sum(3, 4)});
}

void addTwoNumbers(int a, int b) {
var sum = a + b;
print($sum);
}

Output：

5
5
7

我们还可以使用另外一种简短的语法来表示 Lambda，使用 => 来表示

void main(){
// 使用简短语法声明没有返回值的 Lambda
Function addTwoNumbersWithArrows = (int a, int b) => print(${a + b});

// 调用
addTwoNumbersWithArrows(3, 8);

// 使用简单语法声明带有返回值的 Lambda
var sumWithArrows = (int a, int b) => a + b;
// 调用
print(${sumWithArrows(3, 7)});
}

Output:

11
10

高阶函数

高阶函数的定义

• 可以接受一个 Function 作为参数的函数
• 可以返回一个 Function 的函数
• 以上两者都允许

下面我们来写一个用于四则运算的高阶函数：

void main() {
var plusResult = arithmetic(12, 3, (a, b) => a + b);
var reduceResult = arithmetic(12, 3, (a, b) => a - b);
var multiplyResult = arithmetic(12, 3, (a, b) => a * b);
var divideResult = arithmetic(12, 3, (a, b) => a / b);

print(plus result is $plusResult);
print(reduce result is $reduceResult);
print(myltiply result is $multiplyResult);
print(divide result is $divideResult);
}

// 接受一个 Function 参数，并且返回了一个 Function
double arithmetic(double a, double b, Function function) {
return function(a, b);
}

上述代码中 arithmetic 方法接受了一个 Function，并且将其作为返回值返回； 而参数 Function 是接受两个 double 类型的参数。

我们在上一小节中讲到 高阶函数 可以使用没有名称的方法来表示也可以使用 Lambda 来表示。

上述代码中使用的是 Lambda 作为高阶函数进行传递的，那么如果我们使用没有名称的方法来表示，如下：

var modelResult = arithmetic(12, 3, (a, b) {
return a % b;
});
print(model result is $modelResult);

Output:

plus result is 15.0
reduce result is 9.0
myltiply result is 36.0
divide result is 4.0
model result is 0.0

Collections

固定长度的 List

我们来声明一个长度为 5 的整型 List

定长的集合在被定义之后，长度就不能被改变

void main() {
// 声明一个固定长度的集合
List<int> numList = List(5);
// 添加元素
numList.add(9);
// 删除元素
numList.remove(9);
// 删除指定位置上的元素
numList.removeAt(0);
// 清空集合
numList.clear();
}

那么如果我们只想上述代码之后会怎样呢？答案是会报错，因为上述代码中的4中操作在固定长度的集合中都不支持。

Output：

Unhandled exception:
Unsupported operation: Cannot add to a fixed-length list
...

这里顺带提一下，上述代码中我们知道了会抛出 Unsupported 异常，那么根据前面的知识，我们可以使用 try..on.. 来捕获，就当复习一下：

void main() {
try {
// 声明一个固定长度的集合
List<int> numList = List(5);
// 添加元素
numList.add(9);
// 删除元素
numList.remove(9);
// 删除指定位置上的元素
numList.removeAt(0);
// 清空集合
numList.clear();
} on UnsupportedError {
print(操作不支持...);
}
}

Output：

操作不支持...

那么回到我们的问题，固定长度的集合要怎么添加删除元素呢？如下：

void main() {
// 声明一个固定长度的集合
List<int> numList = List(5);

numList[0] = 1;
numList[1] = 2;
numList[2] = 3;
numList[3] = 4;
numList[4] = 5;

print(遍历元素：);
for (int value in numList) {
print(value);
}

print(----更新第一个元素为 10------);

numList[0] = 10;

print(遍历元素：);
numList.forEach((value) => print(value));

print(----将第一个元素置为NULL---);

numList[0] = null;

print(遍历元素：);
for (int i = 0; i < numList.length; i++) {
print(${numList[i]});
}
}

上述代码中，我们使用了索引的方式来给固定长度的 List 赋值，并使用三种方式来遍历，第一种为 for..in ；第二种为 Lambda 表达式；第三种为常规的 for 循环

Output：

遍历元素：
1
2
3
4
5
----更新第一个元素为 10------
遍历元素：
10
2
3
4
5
----将第一个元素置为NULL---
遍历元素：
null
2
3
4
5

动态长度的 List

我们直接看示例：

void main() {
// 动态长度的 集合
List<int> list = List();

list.add(1);
list.add(2);

list.forEach((value) => print($value));
print();

list.removeAt(0);
list.forEach((value) => print($value));
print();

list.add(3);
list[0] = null;
list.forEach((value) => print($value));
}

Output：

1
2

2

null
3

还有一种声明方法：

// 这样也是一个动态的集合
List<String> letterList = ["A", "B", "C"];

letterList.add("D");
letterList.add("E");

letterList.forEach((letter) => print($letter));

Output：

A
B
C
D
E

Set

Set 是无序的；Set 是不允许添加重复元素；Set 不能使用下标来获取里面里面的元素，因为它是无序 的。

void main() {
// 方式一：
Set<String> letterSet = Set.from(["A", "B", "C"]);
letterSet.add("D");
letterSet.add("E");
// 重复的元素将被忽视
letterSet.add("A");

// 使用 for..in.. 遍历 Set
for (String letter in letterSet) {
print($letter);
}

print();

// 方式二：
Set<int> numSet = Set();
numSet.add(0);
numSet.add(1);
numSet.add(2);

// 使用 Lambda 遍历 Set
numSet.forEach((value) => print($value));
}

Output:

A
B
C
D
E

0
1
2

Map

Dart 中 Map 的特性和 Java 中的类似，都是以键值对的形式存放，Map 中的键是唯一的，但是值可以重复，Map 也是无序的。

下面看看 Dart 中 Map 的基本操作：

void main() {
Map<String, String> letterMap = Map();
letterMap["a"] = "A";
letterMap["b"] = "B";
letterMap["c"] = "C";

// 检查是否存在某个 key
letterMap.containsKey("a");
// 更新某个 key 对应的 value，注意 value 为一个 Lambda 表达式
letterMap.update("a", (value) => "${value}AA");

// 获取 Map 的长度
letterMap.length;
// 删除 Map 中的某个元素
letterMap.remove("c");
// 清空 Map
letterMap.clear();

// 遍历所有的 key
for (String key in letterMap.keys) {
print($key);
}

print();

// 遍历所有的 value
for (String value in letterMap.values) {
print($value);
}

print();

// 遍历所有的 key-value
letterMap.forEach((key, value) => print($key == $value));
}

上述代码中使用的是构造方法的方式来创建 Map，我们还可以使用一下方式来创建：

Map<String, int> studentScoreMap = {
"Jack": 90,
"Rost": 100,
"Mary": 30,
"LiLei": 56
};

studentScoreMap.forEach((name, source) => print($name == $source));

Output:

Jack == 90
Rost == 100
Mary == 30
LiLei == 56

Callable

Callable 能让我们像调用方法一样调用某个类，不过我们在类中需要实现 call 方法：

void main() {
var personOne = Person();
var info = personOne("Jack", 18);
print($info);
}

class Person {
// 实现 call 方法
String call(String name, int age) {
return "$name is $age years old";
}
}

Output：

Jack is 18 years old

推荐阅读：