Flutter学习之Dart语法特性

1
2
3
4
5
6
7
8
9
10
11
12
//定义打印数字方法
printNumber(num Number){
print('The number is $Number');
}
//执行程序入口
void main(){
//定义初始化一个变量
var number = 6.76;
//调用打印数字方法
printNumber(number);
}

1
2
3
4
5
6
7
8
9
10
11
12
//定义打印数字方法
printNumber(num Number){
print("The number is $Number");
}
//执行程序入口
void main(){
//定义初始化一个变量
var number;
//调用打印数字方法
printNumber(number);
}

1
2
3
4

//定义初始化一个变量
double number = 6.666;

1
2
3
4
5
6
//定义初始化一个变量
final double number = 6.666;
number = 6.667;
//调用打印数字方法
printNumber(number);

1
2
3
4
5
6
7

//定义初始化一个变量
const double number = 6.666;
number = 6.667;
//调用打印数字方法
printNumber(number);

1
2
3
4
5

//定义初始化一个变量
const double number = 6.66;
const double number1 = 2 * number;

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
//执行程序入口
void main(){
//整形，其取值通常位于-2的53次方到2的53之间。
num x = 777;
//浮点数 64位
x = 777.7;
int y = 777;
y = 777.7;
//这一行编译器会报错，因为将int型的数据转为double型
double n = 77,7;
d = 77;
//这个地方会报错，因为将double
int x1 = 7;
int x2 = 77;
int x3 = 777;
int x4 = 7777;
print('${x1.bitLength}'); //占了3个bit 相当于00000000 00000111
print('${x2.bitLength}'); //占了7个bit 相当于00000000 01001101
print('${x3.bitLength}'); //占了10个bit 相当于00000011 00001001
print('${x4.bitLength}'); //占了13个bit 相当于00011110 01100001
}

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
//执行程序入口
void main(){
int i =7;
double d = 10.1;
print(i / d);
//0.6930693069306931
print(i ~/ d);
//0
这个操作是取整 就是得出商
print(i.isOdd);
// 判断是奇数
print(i.isEven);
// 判断是偶数
//String -> int
var x1 = int.parse("7");
print(x1 == 7);
//输出true
//Sting -> double
var x2 = double.parse("7.7");
print(x2 == 7.7);
//输出true
//int -> String
var x3 = 7.toString();
print(x3 == '7');
//输出true
//double -> String
var x4 = 7.1234.toStringAsFixed(2);
print(x4 == '7.12');
//输出true
//求绝对值
var x5 = (-7).abs();
print(x5 == 7);
//四舍五入1
var x6 = (7.7).round();
print(x6);
//输出8
//四舍五入2
var x7 = (7.3).round();
print(x7);
//输出7
//求大小于它的最大整数
var x8 = (7.7).floor();
print(x8);
//输出7
//求大于它的最小整数
var x9 = (7.7).ceil();
print(x9);
//输出8
double num1 = 7.77;
print(num1);
//结果是7.77
double num2 = 7;
print(num2);
//结果是7.0
int num3 = 7;
print(num3.toDouble());
//int 转 double 结果是7.0
double num4 = 7.77;
print(num4.toInt());
//double 转 int 结果是7
}

1
2
3
4
5
6
7
8
9
10
//执行程序入口
void main(){
String m_str1 = '单引号字符串';
String m_str2 = "双引号字符串";
print(m_str1);
//输出：单引号字符串
print(m_str2);
//输出：双引号字符串
}

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
//执行程序入口
void main(){
String m_str1 = '单引号中的"双引号"字符串';
String m_str2 = "双引号中的'单引号'字符串";
print(m_str1);
//输出：单引号中的"双引号"字符串
print(m_str2);
//输出：双引号中的'单引号'字符串
//单引号里面有单引号，必须在前面加反斜杠
String m_str3 = '单引号中的'单引号'';
String m_str4 = "双引号里面有双引号,"双引号"";
print(m_str3);
//输出：单引号中的'单引号'
print(m_str4);
//输出：双引号里面有双引号,"双引号"
}

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
 //String m_str5 = '单引号''''单引号'; //报错
String m_str6 = '单引号'' ''单引号';
print(m_str6);
//输出： 单引号 单引号
String m_str7 = '单引号''*''单引号';
print(m_str7);
//输出： 单引号*单引号
//String m_str8 = "双引号""""双引号"；
//报错
String m_str9 = "双引号"" ""双引号";
print(m_str9);
//输出： 双引号 双引号
String m_str10 = "双引号""*""双引号";
print(m_str10);
//输出： 双引号*双引号

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
 String m_str11 = '单引号""""单引号';
print(m_str11);
//输出： 单引号""""单引号
String m_str12 = '单引号"" ""单引号';
print(m_str12);
//输出： 单引号"" ""单引号
String m_str13 = '单引号""*"""单引号';
print(m_str13);
//输出： 单引号""*"""单引号
String m_str14 = "双引号''''双引号";
print(m_str14);
//输出:
双引号''''双引号
String m_str15 = "双引号'' ''双引号";
print(m_str15);
//输出：
双引号'' ''双引号
String m_str16 = "双引号''*''双引号";
print(m_str16);
//输出：
双引号''*''双引号

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
//使用空格拼接，多个空格也是可以地
String m_str1 = '单引号字符串' '拼接'
'---';
print(m_str1);
//输出：单引号字符串拼接---
//使用换行符和空格
String m_str2 = '单引号字符串'
'换行''加空格' '';
print(m_str2);
//输出： 单引号字符串换行加空格
//单双引号 空格拼接
String m_str3 = "单双引号字符串加空格" '拼接'
"----";
print(m_str3);
//输出： 双引号字符串加空格拼接----
//单双引号 换行 空格
String m_str4 = "单双引号字符串"
'换行' '加空格' '***';
print(m_str4);
//输出： 单双引号字符串换行加空格***
//使用三个单引号创建多行字符串
String m_str5 = '''
三个单引号+
拼接
''';
print(m_str5);
/*输出
三个单引号+
拼接
*/
//使用三个双引号创建多行字符串
String m_str6 = """
三个双引号+
拼接
""";
print(m_str6);
/*输出
三个双引号+
拼接
*/
String m_str7 = "正常拼接"+",用加号了来拼接";
print(m_str7);
//输出： 正常拼接,用加号了来拼接

1
2
3
4
5
6
7
8
9

String m_str1 = r"sdsdsds";
print(m_str1);
//输出
sdsdsds
print("换行：n"); //输出：换行
print(r"换行：n"); //输出：换行：n
print("换行：\n"); //输出：换行：n

1
2
3
4
5
6
7
8
9
10
11
12
bool flag = true;
String m_str1 = "字符串";
print("看看这个值：${m_str1} ""看看这个值flag：${flag}"); //输出：字符串：字符串 看看这个值flag：true
//使用$+字符串
String name = "knight";
print("$name" + "CTO");
//输出：knightCTO；
//使用字符串拼接，运用了String类中的toUpperCase函数，把字母变成大写 
String m_str = "Android";
assert('${m_str.toUpperCase()} is very good' ==
'ANDROID is very good');

1
2
3
4
5
6
7

String name ="knight";
//报错 因为name不是bool类型
if(name){
print(name);
}

1
2
3
4
5
6
7
8
9
10
11
12
13
14

// 检查是否为空字符串
var fullName = '';
assert(fullName.isEmpty);
// 检查是否小于等于0
var hitPoints = 0;
assert(hitPoints <= 0);
// 检查是否为 null.
var unicorn;
assert(unicorn == null);
// 检查是否为 NaN.
var iMeantToDoThis = 0 / 0;
assert(iMeantToDoThis.isNaN);

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
//创建一个int类型的list 并赋值为0，1，2，3，4
List list =
[0,1,2,3,4];
//使用构建的方式创建list
List list1 = new List();
//创建一个常量的List，不可以改变的List
List list2 = const[0,1,2,3];
//增加泛型
List list3 = new List<String>();
//创建固定的长度的数组列表，不能移除或者增加
List list4 = new List(5);
//创建包含所有以下元素的可改变的长度列表
List list5 = new List.from([0,1,2,3]);
//创建在固定范围内改变长度的列表
List list6 = new List()..length = 10;
//创建包含所有元素的固定长度列表
List list7 = new List.unmodifiable([0,1,2]);
//用生成器给所有元素赋初始值
List list8 = new List<int>.generate(5, (int i){
return i + i;
});

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
 //在列表中存放不同类型的对象
List list = [1,2,3,false,"Kinght"];
print(list);
//输出：[1, 2, 3, false, Kinght]
//在列表中添加元素
list.add(7);
print(list);
//输出：[1, 2, 3, false, Kinght, 7]
//修改列表下标为1的值
list[1] = "paul";
print(list);
//输出：[1, paul, 3, false, Kinght, 7]
//移除列表的指定值得的元素
list.remove("paul");
print(list);
//输出：[1, 3, false, Kinght, 7]
//移除列表指定下标下的元素
list.removeAt(0);
print(list);
//输出：[3, false, Kinght, 7]
//获取列表的长度
print(list.length);
//输出：4
//向列表中的指定位置添加元素 在第0的位置上插入Android
list.insert(0, "Android");
print(list);
//输出：[Android, 3, false, Kinght, 7]
//判断数组中是否有某元素
print(list.indexOf("Android")); //这里存在，输出对应的下标，如果没有则输出-1
//排序
List list1 = [3,1,2,6,7];
// 根据语法提示： List.sort([(int, int) → int compare]) → void
list1.sort((a,b) => a.compareTo(b));
print(list1);
//输出：[1, 2, 3, 6, 7]

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59

//1.通过构建器来创建Map
Map map1 = new Map();
//添加值 赋值
map1["one"] = 'Android';
map1["two"] = 'IOS';
map1["three"] = 'Flutter';
print(map1);
//输出：{one: Android, two: IOS, three: Flutter}
//2.通过复制的形式
Map map2 = Map.of(map1);
print(map2);
//输出：{one: Android, two: IOS, three: Flutter}
//3.跟上面形式一样
Object.fromEntries() 函数传入一个键值对的列表，并返回一个带有这些键值对的新对象。
// 这个迭代参数应该是一个能够实现@iterator方法的的对象，返回一个迭代器对象。它
// 生成一个具有两个元素的类似数组的对象，第一个元素是将用作属性键的值，第二个元素是与该属性键关联的值。
Map map3 = Map.fromEntries(map1.entries);
print(map3);
//4.直接声明，直接赋值key为String类型的map
Map map4 = {'one':'Android',
'two':'IOS',
'three':'Flutter'};
print(map4);
//输出：{one: Android, two: IOS, three: Flutter}
//5.创建一个空的Map
Map map5 = Map.identity();
print(map5);
//输出：{}
//6.创建不可变的Map
Map map6 = const {'one':'Android','two':'IOS','three':'flutter'};
print(map6);
//输出：{one: Android, two: IOS, three: flutter}
//7.在目标的map6创建(复制)新的不可修改map7
Map map7 = Map.unmodifiable(map6);
print(map7);
//输出：{one: Android, two: IOS, three: flutter}
//8.创建key为int值得map
Map map8 = {1:'Android',
2:'IOS',
3:'Flutter'};
print(map8);
//输出：{1: Android, 2: IOS, 3: Flutter}
//9.根据list所提供的key value来创建map
List<String> keys = ['one','two'];
List<String> values = ['Android','IOS'];
Map map9 = Map.fromIterables(keys, values);
print(map9);
//输出：{one: Android, two: IOS}
//通过构建器来创建Map
Map map10 = new Map();
//添加值 赋值 赋值不同类型的Map
map10["one"] = 'Android';
map10["two"] = 'IOS';
map10["three"] = 'Flutter';
map10[4] = 'RN';
print(map10);
//输出：{one: Android, two: IOS, three: Flutter, 4: RN}

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
 //创建Map key是int类型，value是String类型
var
map1 = new Map<int,String>();
//对Map第一个位置赋值，中括号是key
map1[0] = 'Android';
//对Map第二个位置赋值
map1[1] = 'IOS';
//对Map第三个值赋值
map1[2] = 'flutter';
//对Map赋空值
map1[3] = null;
//因为Map中的键值是唯一的，当第二次输入的key如果存在，Value会覆盖之前
map1[2] = 'RN';
print(map1);
//{0: Android, 1: IOS, 2: RN, 3: null}
//获取Map的长度
print(map1.length);
//输出：4
//判断Map是否为空
print(map1.isNotEmpty);
//输出结果：true
//判断Map是否不为空
print(map1.isEmpty);
//输出结果：false
//检索Map是否含有某个Key
print(map1.containsKey(1)); //输出：true
//检索Map是否包含某个Value
print(map1.containsValue('Android'));
//输出：true
//删除某个键值对
map1.remove(0);
print(map1);
//输出：{1: IOS, 2: RN, 3: null}
//获取所有的key
print(map1.keys);
//输出：(1, 2, 3)
//获取所有的values
print(map1.values);
//输出：(IOS, RN, null)
//循环打印
/*
key:1, value:IOS
key:2, value:RN
key:3, value:null
*/
map1.forEach((key,value) {
print("key:${key}, value:${value}");
});

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
//执行程序入口
void main(){
var clapp = 'u{1f44f}';
print(clapp);
//输出：?
print(clapp.codeUnits);
//输出： [55357, 56399]
print(clapp.runes.toList());
//输出：
[128079]
//使用String. fromCharCodes方法显示字符图形
Runes input = new Runes(
'u2665
u{1f605}
u{1f60e}
u{1f47b}
u{1f596}
u{1f44d}');
print(new String.fromCharCodes(input));
//输出：♥
?
?
?
?
?
}

1
2
3
4
5
6
7
8
9
10
11
12
13

//使用 Symbol 字面量来获取标识符的 symbol 对象，也就是在标识符 前面添加一个 # 符号：
//#radix
//#bar
print(#n == new Symbol('n'));
//输出：true
var name = 'knight';
Symbol symbol = #name;
print(symbol);
//输出：Symbol("name")
print(#name);
//输出：Symbol("name")

1
2
3
4
5
//定义一个方法 判断列表对应下标是否为null
bool isNoble(int atomicNumber) {
return list[atomicNumber] != null;
}

1
2
3
4
5
//定义一个方法 判断列表对应下标是否为null 忽略类型定义
isNoble(int atomicNumber) {
return list[atomicNumber] != null;
}

1
2
3
//定义一个方法 判断列表对应下标是否为null 缩写写法
bool isNoble(int atomicNumber) => list[atomicNumber] != null;

1
2
enableFlags(bold: true, hidden: false);

1
2
3
4
enableFlags({bool bold, bool hidden}) {
// ...
}

1
2
3
4
5
6
7
8
9
10
11
12
13
14
//定义一个方法 [String device]是可选位置参数 也就是调用这个方法可以不传这个参数
String say(String from, String msg, [String device]) {
var result = '$from says $msg';
if (device != null) {
result = '$result with a $device';
}
return result;
}
//不使用可选参数调用方法
assert(say('Bob', 'Howdy') == 'Bob says Howdy');
//使用可选参数调用方法
assert(say('Bob', 'Howdy', 'smoke signal') ==
'Bob says Howdy with a smoke signal');

1
2
3
4
5
6
//定义一个返回类型为空的方法 方法中hidden默认值为false
void enableFlags({bool bold = false,bool hidden = false}){
}
//调用方法 没有传hidden的值，那默认值就是false
enableFlags(bold:true);

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
//定义一个方法 这个方法位置可选位置参数device的默认参数是carrier pigon
//也就是当调用这个方法，没有传这个参数时，这个参数会取默认值
String say(String from, String msg,
[String device = 'carrier pigeon', String mood]) {
var result = '$from says $msg';
if (device != null) {
result = '$result with a $device';
}
if (mood != null) {
result = '$result (in a $mood mood)';
}
return result;
}
//调用上面的方法
assert(say('Bob', 'Howdy') ==
'Bob says Howdy with a carrier pigeon');

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
//执行程序入口
void main(){
//调用判断对应小标的值是否为空
// print(isNoble(1));
//输出：true
doStuff();
//输出：list:
[1, 2, 3]
//输出：gifts: {first: paper, second: cotton, third: leather}
}
//List和Map都取了默认值
void doStuff(
{List<int> list = const [1, 2, 3],
Map<String, String> gifts = const {
'first': 'paper',
'second': 'cotton',
'third': 'leather'
}}) {
print('list:
$list');
print('gifts: $gifts');
}

1
2
3
4
5
6
void main() {
querySelector("#sample_text_id")
..text = "Click me!"
..onClick.listen(reverseText);
}

1
2
3
4
5
6
7
8
// Run the app like this: dart args.dart 1 test
void main(List<String> arguments) {
print(arguments);
assert(arguments.length == 2);
assert(int.parse(arguments[0]) == 1);
assert(arguments[1] == 'test');
}

1
2
3
4
5
6
7
printElement(element) {
print(element);
}
var list = [1, 2, 3];
// 遍历集合
list.forEach(printElement);

1
2
3
var loudify = (msg) => '!!! ${msg.toUpperCase()} !!!';
assert(loudify('hello') == '!!! HELLO !!!');

1
2
3
4
([[Type] param1[, …]]) {
codeBlock;
};

1
2
3
4
5
6
7
8
9
10
11
var list = ['apples', 'oranges', 'grapes', 'bananas', 'plums'];
list.forEach((i) {
print(list.indexOf(i).toString() + ': ' + i);
});
//输出：
0: apples
1: oranges
2: grapes
3: bananas
4: plums

1
2
list.forEach((i) => print(list.indexOf(i).toString() + ': ' + i));

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
var topLevel = true;
main() {
var insideMain = true;
myFunction() {
var insideFunction = true;
nestedFunction() {
var insideNestedFunction = true;
assert(topLevel);
assert(insideMain);
assert(insideFunction);
assert(insideNestedFunction);
}
}
}

1
2
3
4
5
6
7
8
9
10
11
12
Function makeAdder(num addBy) {
return (num i) => addBy + i;
}
main() {
// Create a function that adds 2.
var add2 = makeAdder(2);
// Create a function that adds 4.
var add4 = makeAdder(4);
assert(add2(3) == 5);
assert(add4(3) == 7);
}

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
foo() {}
// 顶级方法
class A {
static void bar() {} // 静态方法
void baz() {}
// 实例方法
}
void main() {
var x;
// 比较顶级函数
x = foo;
print(foo == x);
//输出：true
// 比较静态方法
x = A.bar;
print(A.bar == x);
//输出：true
// 比较实例方法
var v = new A(); // 实例1
var w = new A(); // 实例2
var y = w;
x = w.baz;
//这些闭包引用相同的实例
//所有相等
print(y.baz == x);
//输出：true
// 闭包引用不同的实例，所以不相等`
print(v.baz != w.baz);
//输出：true
}

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
void main() {
var n = 2;
var i = 2;
var d = 7;
if((n % i == 0) && (d % i == 0)){
print('符合条件');
}else{
print('不符合条件');
//进入这里
}
if(n % i == 0 && d % i == 0){
print('符合条件');
}else{
print('不符合条件');
//进入这里
}
}

1
2
3
4
if (emp is Person) { // Type check
emp.firstName = 'Bob';
}

1
2
(emp as Person).firstName = 'Bob';

1
2
3
4
5
a = value;
// 给 a 变量赋值
b ??= value; // 如果 b 是 null，则赋值给 b；
// 如果不是 null，则 b 的值保持不变

1
2
3
4
5
6
var a = 2;
// Assign using =
a *= 3;
// Assign and multiply: a = a * 3
assert(a == 6);

1
2
var finalStatus = m.isFinal ? 'final' : 'not final';

1
2
3
4
5
6
7
8
9
10
11
String toString() => msg ?? super.toString();
//上面代码可以用下面代码来表示，意思效果是一样的，代码易懂但是不简洁
String toString() => msg == null ? super.toString() : msg;
String toString() {
if (msg == null) {
return super.toString();
} else {
return msg;
}
}

1
2
3
4
5
6
querySelector('#button') // Get an object.
..text = 'Confirm'
// Use its members.
..classes.add('important')
..onClick.listen((e) => window.alert('Confirmed!'));

1
2
3
4
5
var button = querySelector('#button');
button.text = 'Confirm';
button.classes.add('important');
button.onClick.listen((e) => window.alert('Confirmed!'));

1
2
3
4
5
6
7
8
9
final addressBook = (new AddressBookBuilder()
..name = 'jenny'
..email = 'jenny@example.com'
..phone = (new PhoneNumberBuilder()
..number = '415-555-0100'
..label = 'home')
.build())
.build();

1
2
3
var sb = new StringBuffer();
sb.write('foo')..write('bar');

1
2
3
4
5
6
7
8
if (isRaining()) {//条件语句
you.bringRainCoat();//内容体
} else if (isSnowing()) {//条件语句
you.wearJacket();//内容体
} else {
car.putTopDown();//内容体
}

1
2
3
4
5
6
7
8
9
10
11
12
13
var message = new StringBuffer("Dart is fun");
for (var i = 0; i < 5; i++) {
message.write('!');
}
//使用foreach循环 list 和 Set都可以用这种方式
List numbers = [1,2,3,4,5,6,7,8,9，10];
numbers.foreach((number)=> print(number));
//使用for in循环，一般List和Set都是用这种方式
List numbers = [1,2,3,4,5,6,7,8,9，10];
for(var number in numbers){
print(number);
}

1
2
3
4
5
6
7
8
9
10
11
//判断条件
while (!isDone()) {
//内容
doSomething();
}
//例子
var i = 0;
while(i > 5){
i++;
}

1
2
3
4
5
6
7
8
9
do {
printLine();//内容体
} while (!atEndOfPage());//条件判断
//例子
var i = 0;
do{
i++;
}while(i > 7);

1
2
3
4
5
while (true) {
if (shutDownRequested()) break;
processIncomingRequests();
}

1
2
3
4
5
6
7
8
for (int i = 0; i < candidates.length; i++) {
var candidate = candidates[i];
if (candidate.yearsExperience < 5) {
continue;
}
candidate.interview();
}

1
2
3
candidates.where((c) => c.yearsExperience >= 5)
.forEach((c) => c.interview());

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
var command = 'OPEN';
switch (command) {
case 'CLOSED':
executeClosed();
break;
case 'PENDING':
executePending();
break;
case 'APPROVED':
executeApproved();
break;
case 'DENIED':
executeDenied();
break;
case 'OPEN':
executeOpen();
break;
default:
executeUnknown();
}

1
2
3
4
5
6
7
8
9
10
11
12
void main() {
var number = 1;
var i = 0;
switch(number){
case 1;
i++;
case 2:
i--;
break;
}
}

1
2
3
4
5
6
7
8
9
10
11
12
void main() {
var number = 1;
var i = 0;
switch(number){
case 1;
i++;
case 2:
i--;
break;
}
}

1
2
3
4
5
6
7
8
9
10
11
12
void main() {
var number = 1;
var i = 0;
switch(number){
case 1;
i++;
case 2:
i--;
break;
}
}

1
2
3
4
5
6
7
// 确保变量是非空值 
assert(text != null);
// 确保值是小于100
assert(number < 100);
// 确保这是一个 https 地址
assert(urlString.startsWith('https'));

1
2
thow new FormatException('Expected at least 1 section');

1
2
throw 'Out of llamas!';

1
2
3
distanceTo(Point other) =>
throw new UnimplementedError();

1
2
3
4
5
6
try {
breedMoreLlamas();
} on OutOfLlamasException {
buyMoreLlamas();
}

1
2
3
4
5
6
7
8
9
10
11
12
13
try {
breedMoreLlamas();
} on OutOfLlamasException {
// A specific exception
buyMoreLlamas();
} on Exception catch (e) {
// Anything else that is an exception
print('Unknown exception: $e');
} catch (e) {
// No specified type, handles all
print('Something really unknown: $e');
}

1
2
3
4
5
6
7
8
9

...
} on Exception catch (e) {
print('Exception details:n $e');
} catch (e, s) {
print('Exception details:n $e');
print('Stack trace:n $s');
}

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
final foo = '';
void misbehave() {
try {
foo = "You can't change a final variable's value.";
} catch (e) {
print('misbehave() partially handled ${e.runtimeType}.');
rethrow; // Allow callers to see the exception.
}
}
void main() {
try {
misbehave();
} catch (e) {
print('main() finished handling ${e.runtimeType}.');
}
}

1
2
3
4
5
6
7
try {
breedMoreLlamas();
} finally {
// 即使抛出异常也会执行
cleanLlamaStalls();
}

1
2
3
4
5
6
7
8
9
10
try {
breedMoreLlamas();
} catch(e) {
print('Error: $e');
// 优先处理异常
} finally {
cleanLlamaStalls();
// 然后再执行
}

1
2
3
4
5
6
var jsonData = JSON.decode('{"x":1, "y":2}');
// 创建Point类型的对象
var p1 = new Point(2, 2);
// 根据json来创建Point对象
var p2 = new Point.fromJson(jsonData);

1
2
3
4
5
6
7
8
var p = new Point(2, 2);
// 对实例对象的变量y赋值
p.y = 3;
// 从成员变量得到值
assert(p.y == 3);
// 从p复制实例对象
num distance = p.distanceTo(new Point(4, 4));

1
2
3
//如果P不是空对象，那么对其变量y赋值
p?.y = 4;

1
2
var p = const ImmutablePoint(2, 2);

1
2
3
4
var a = const ImmutablePoint(1, 1);
var b = const ImmutablePoint(1, 1);
print(identical(a, b)); // 它们是相同的实例，输出true

1
2
print('The type of a is ${a.runtimeType}');

1
2
3
4
5
6
7

class Point{
num x;//声明实例变量x，初始化为空
num y;//声明实例变量y，舒适化为空
num z = 0;//声明实例变量z，初始化为0
}

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
class Point{
num x;//声明实例变量x，初始化为空
num y;//声明实例变量y，舒适化为空
num z = 0;//声明实例变量z，初始化为0
}
void main() {
var point = new Point();
point.x = 4;
//使用setter方法对x变量赋值
print(point.x == 4);
//输出true 使用getter获取x变量的值
print(point.y == null);
//输出true
}

1
2
3
4
5
6
7
8
9
class Point {
num x;
num y;
Point(num x, num y) {
this.x = x;
this.y = y;
}
}

1
2
3
4
5
6
7
8
class Point {
num x;
num y;
// 设置x和y的语法糖
// 在构造函数主体运行之前
Point(this.x, this.y);
}

1
2
3
4
5
6
7
8
9
10
11
class Point {
num x;
num y;
Point(this.x, this.y);
// 命名构造函数
Point.fromJson(Map json) {
x = json['x'];
y = json['y'];
}
}

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
//定义Person类
class Person {
String firstName;
Person.fromJson(Map data) {
print('in Person');
}
}
class Employee extends Person {
// Person 没有默认构造函数
// you must call super.fromJson(data).
Employee.fromJson(Map data) : super.fromJson(data) {
print('in Employee');
}
}
main() {
var emp = new Employee.fromJson({});
// 打印输出
// in Person
// in Employee
}

1
2
3
4
5
class Employee extends Person {
// ...
Employee() : super.fromJson(findDefaultData());
}

1
2
3
4
5
6
7
8
9
10
11
12
class Point {
num x;
num y;
Point(this.x, this.y);
// 初始化列表在构造函数体运行之前设置实例变量。
Point.fromJson(Map jsonMap)
: x = jsonMap['x'],
y = jsonMap['y'] {
print('In Point.fromJson(): ($x, $y)');
}
}

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
import 'dart:math';
export 'src/DartProject_base.dart';
// TODO: Export any libraries intended for clients of this package.
class Point {
final num x;
final num y;
final num distanceFromOrigin;
Point(x, y)
: x = x,
y = y,
distanceFromOrigin = sqrt(x * x + y * y);
}
main() {
var p = new Point(2, 3);
print(p.distanceFromOrigin);//输出：3.605551275463989
}

1
2
3
4
5
6
7
8
9
class Point {
num x;
num y;
// 主构造函数
Point(this.x, this.y);
// 调用主构造函数
Point.alongXAxis(num x) : this(x, 0);
}

1
2
3
4
5
6
7
8
class ImmutablePoint {
final num x;
final num y;
const ImmutablePoint(this.x, this.y);
static final ImmutablePoint origin =
const ImmutablePoint(0, 0);
}

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
class Logger {
final String name;
bool mute = false;
static final Map<String, Logger> _cache =
<String, Logger>{};
factory Logger(String name) {
if (_cache.containsKey(name)) {
return _cache[name];
} else {
final logger = new Logger._internal(name);
_cache[name] = logger;
return logger;
}
}
Logger._internal(this.name);
void log(String msg) {
if (!mute) {
print(msg);
}
}
}

1
2
3
var logger = new Logger('UI');
logger.log('Button clicked');

1
2
3
4
5
6
7
8
9
10
11
12
import 'dart:math';
class Point {
num x;
num y;
Point(this.x, this.y);
num distanceTo(Point other) {
var dx = x - other.x;
var dy = y - other.y;
return sqrt(dx * dx + dy * dy);
}
}

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
class Rectangle {
num left;
num top;
num width;
num height;
Rectangle(this.left, this.top, this.width, this.height);
// 定义两个计算属性：右和下。
num get right
=> left + width;
set right(num value)
=> left = value - width;
num get bottom
=> top + height;
set bottom(num value) => top = value - height;
}
main() {
var rect = new Rectangle(3, 4, 20, 15);
assert(rect.left == 3);
rect.right = 12;
assert(rect.left == -8);
}

1
2
3
4
5
6
7
8
9
10
abstract class Doer {
// ...定义实例变量和方法...
void doSomething(); // 定义一个抽象方法.
}
class EffectiveDoer extends Doer {
void doSomething() {
// ...提供实现，因此此处的方法不是抽象的...
}
}

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
class Vector {
final int x;
final int y;
const Vector(this.x, this.y);
/// 覆写 + (a + b).
Vector operator +(Vector v) {
return new Vector(x + v.x, y + v.y);
}
/// 覆写 - (a - b).
Vector operator -(Vector v) {
return new Vector(x - v.x, y - v.y);
}
}
main() {
final v = new Vector(2, 3);
final w = new Vector(2, 2);
// v == (2, 3)
assert(v.x == 2 && v.y == 3);
// v + w == (4, 5)
assert((v + w).x == 4 && (v + w).y == 5);
// v - w == (0, 1)
assert((v - w).x == 0 && (v - w).y == 1);
}

1
2
3
4
5
6
// 这个类是抽象类，不能实例化
abstract class AbstractContainer {
// ...定义构造函数, 变量, 方法...
void updateChildren(); // 抽象方法.
}

1
2
3
4
5
6
7
8
9
10
class SpecializedContainer extends AbstractContainer {
// ...定义更多的构造方法, 方法...
void updateChildren() {
// ...实现 updateChildren()...
}
//Abstract method causes a warning but doesn't prevent instantiation.
抽象方法导致警告，但不阻止实例化。
void doSomething();
}

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
// A person. 隐式接口包含greet().
class Person {
// 在接口中，但仅在此库中可见
final _name;
// 不在接口中，因为这是构造函数
Person(this._name);
// 在接口中
String greet(who) => 'Hello, $who. I am $_name.';
}
// 实现Person 接口
class Imposter implements Person {
// 我们必须定义这个，但我们不使用它。
final _name = "";
String greet(who) => 'Hi $who. Do you know who I am?';
}
greetBob(Person person) => person.greet('bob');
main() {
print(greetBob(new Person('kathy')));
print(greetBob(new Imposter()));
}

1
2
3
4
class Point implements Comparable, Location {
// ...
}

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
class Television {
void turnOn() {
_illuminateDisplay();
_activateIrSensor();
}
// ...
}
class SmartTelevision extends Television {
void turnOn() {
super.turnOn();
_bootNetworkInterface();
_initializeMemory();
_upgradeApps();
}
// ...
}

1
2
3
4
5
6
7
8
class A {
//除非重写NoSuchMethod，否则使用不存在的函数将导致NoSuchMethodError。
void noSuchMethod(Invocation mirror) {
print('You tried to use a non-existent member:' +
'${mirror.memberName}');
}
}

1
2
3
4
5
6
7
class A {
@override
void noSuchMethod(Invocation mirror) {
// ...
}
}

1
2
3
4
5
6
7
@proxy
class A {
void noSuchMethod(Invocation mirror) {
// ...
}
}

1
2
3
4
5
6
class A implements SomeClass, SomeOtherClass {
void noSuchMethod(Invocation mirror) {
// ...
}
}

1
2
3
4
5
6
enum Color {
red,
green,
blue
}

1
2
3
4
print(Color.red.index == 0); //输出：true
print(Color.green.index == 1);//输出：true
print(Color.blue.index == 2);//输出：true

1
2
3
List<Color> colors = Color.values;
print(colors[2] == Color.blue);//输出：true

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
enum Color {
red,
green,
blue
}
// ...
Color aColor = Color.blue;
switch (aColor) {
case Color.red:
print('Red as roses!');
break;
case Color.green:
print('Green as grass!');
break;
default: // 如果没有这个，你会看到一个警告
print(aColor);
// 'Color.blue'
}

1
2
3
4
5
6
7
8
9
10
11
class Musician extends Performer with Musical {
// ...
}
class Maestro extends Person
with Musical, Aggressive, Demented {
Maestro(String maestroName) {
name = maestroName;
canConduct = true;
}
}

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
abstract class Musical {
bool canPlayPiano = false;
bool canCompose = false;
bool canConduct = false;
void entertainMe() {
if (canPlayPiano) {
print('Playing piano');
} else if (canConduct) {
print('Waving hands');
} else {
print('Humming to self');
}
}
}

1
2
3
4
5
6
7
8
9
10
11
class Color {
static const red =
const Color('red'); // 静态构造变量.
final String name;
// 静态实例变量.
const Color(this.name); // 构造方法.
}
main() {
print(Color.red.name == 'red'); //输出：true
}

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
import 'dart:math';
class Point {
num x;
num y;
Point(this.x, this.y);
static num distanceBetween(Point a, Point b) {
var dx = a.x - b.x;
var dy = a.y - b.y;
return sqrt(dx * dx + dy * dy);
}
}
main() {
var a = new Point(2, 2);
var b = new Point(4, 4);
var distance = Point.distanceBetween(a, b);
assert(distance < 2.9 && distance > 2.8);
}

1
2
3
4
5
6
main() {
List Tech = new List<String>();
Tech.addAll(['Android','IOS','Flutter']);
Tech.add(42);//运行时报错
}

1
2
3
4
5
abstract class ObjectCache {
Object getByKey(String key);
setByKey(String key, Object value);
}

1
2
3
4
5
abstract class StringCache {
String getByKey(String key);
setByKey(String key, String value);
}

1
2
3
4
5
abstract class Cache<T> {
T getByKey(String key);
setByKey(String key, T value);
}

1
2
3
4
5
6
7
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'
};

1
2
3
4
var names = new List<String>();
names.addAll(['Seth', 'Kathy', 'Lars']);
var nameSet = new Set<String>.from(names);

1
2
var views = new Map<int, View>();

1
2
3
4
var names = new List<String>();
names.addAll(['Seth', 'Kathy', 'Lars']);
print(names is List<String>); // 输出：true

1
2
3
4
5
6
7
8
9
10
11
12
13
// T必须是SomebaseClass或其后代之一。
class Foo<T extends SomeBaseClass> {...}
class Extender extends SomeBaseClass {...}
void main() {
// 可以在<>中使用somebaseclass或它的任何子类。
var someBaseClassFoo = new Foo<SomeBaseClass>();
var extenderFoo = new Foo<Extender>();
//也可以使用no<>
var foo = new Foo();
//指定任何非SomeBaseClass类型将导致警告，在Debug检查模式，运行时错误。
// var objectFoo = new Foo<Object>();
}

1
2
3
4
5
6
7
T first<T>(List<T> ts) {
// ...做一些初始化工作或者错误检查...
T tmp ?= ts[0];
// ...做一些额外的检查或者处理...
return tmp;
}

1
2
import 'dart:html';

1
2
3
4
import 'dart:io';
import 'package:mylib/mylib.dart';
import 'package:utils/utils.dart';

1
2
3
4
5
6
7
import 'package:lib1/lib1.dart';
import 'package:lib2/lib2.dart' as lib2;
// ...
Element element1 = new Element();
// 使用 lib1 中的 Element .
lib2.Element element2 = new lib2.Element(); // 使用 lib2 中的 Element.

1
2
3
4
5
// 仅导入foo
import 'package:lib1/lib1.dart' show foo;
// 导入除foo以外的所有名称。
import 'package:lib2/lib2.dart' hide foo;

1
2
import 'package:deferred/hello.dart' deferred as hello;

1
2
3
4
5
greet() async {
await hello.loadLibrary();
hello.printGreeting();
}

1
2
await lookUpVersion()

1
2
3
4
5
6
7
8
9
checkVersion() async {
var version = await lookUpVersion();
if (version == expectedVersion) {
// 主体内容.
} else {
// 主体内容.
}
}

1
2
3
4
5
6
try {
server = await HttpServer.bind(InternetAddress.LOOPBACK_IP_V4, 4044);
} catch (e) {
// 对无法绑定到端口作出反应...
}

1
2
3
4
5
checkVersion() async {
// ...
}
lookUpVersion() async => /* ... */;

1
2
String lookUpVersionSync() => '1.0.0';

1
2
Future<String> lookUpVersion() async => '1.0.0';

1
2
await expression

1
2
3
4
var entrypoint = await findEntrypoint();
var exitCode = await runExecutable(entrypoint, args);
await flushThenExit(exitCode);