Flutter快速入门一：Dart语言

变量

  var a = 1;
  int b = 10;
  double c = 0.5;
  String s = "hello";
  dynamic d = 0.5;

  final Num = count;  // final 只能赋值一次
  const Num1 = 10; // const赋值必须是编译时常量
  //区别一：final 要求变量只能初始化一次，并不要求赋的值一定是编译时常量，可以是常量也可以不是。而 const 要求在声明时初始化，并且  赋值必需为编译时常量。
  //区别二：final 是惰性初始化，即在运行时第一次使用前才初始化。而 const 是在编译时就确定值了。


  // numbers
  var a = 0;
  int b = 1;
  double c = 0.1;

  // strings
  var s1 = 'hello';
  String s2 = "world";

  // booleans
  var real = true;
  bool isReal = false;

  // lists
  var arr = [1, 2, 3, 4, 5];
  List<String> arr2 = ['hello', 'world', "123", "456"];
  List<dynamic> arr3 = [1, true, 'haha', 1.0];

  // maps
  var map = new Map();
  map['name'] = 'zhangsan';
  map['age'] = 10;
  Map m = new Map();
  m['a'] = 'a';

  //runes，Dart 中 使用runes 来获取UTF-32字符集的字符。String的 codeUnitAt and codeUnit属性可以获取UTF-16字符集的字符
  var clapping = '\u{1f44f}';
  print(clapping); // 打印的是拍手emoji的表情

  // symbols
  print(#s == new Symbol("s")); // true
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

函数

  // 声明返回值
  int add(int a, int b) {
    return a + b;
  }

  // 不声明返回值
  add2(int a, int b) {
    return a + b;
  }


  // =>是return语句的简写
  add3(a, b) => a + b; 

  // 无返回值
  add4(int a, int b) {
    int c=  a + b;
     print(c);
  }

  main() {
    print(add(1, 2)); // 3
    print(add2(2, 3)); // 5
    print(add3(1, 2)); // 3
  
    add4(1.2);// 3
  }
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

函数返回值

所有的函数都有返回值，如果没有指定return语句，那么该函数的返回值为null。

命名参数

  sayHello({String? name}) {
    print("hello, my name is $name");
  }

  sayHelloRequired({String required name}) {
    print("hello, my name is $name");
  }

  main() {
    // 打印 hello, my name is zhangsan
    sayHello(name: 'zhangsan');
    // 打印 hello, my name is
    sayHello();
  
    // 打印 hello, my name is zhangsan
    sayHelloRequired(name: 'zhangsan');
    //报错
    sayHelloRequired();
  }
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19

参数默认值

  // 命名参数的默认值  b默认为3，
  int add({int required a, int b = 3}) { 
    return a + b;
  }
1
2
3
4

lambda表达式

  test(Function callback) {
    callback("hello");
  }

  main() {
    test((param) {
      // 打印hello
      print(param);
    });
  }
1
2
3
4
5
6
7
8
9
10

运算符

  main() {
    // 与Java相同的运算符操作
    int a = 1;
    ++a;
    a++;
    var b = 1;
    print(a == b);  // false
    print(a * b); // 3
    bool real = false;
    real ? print('real') : print('not real'); // not real
    print(real && a == b); // false
    print(real || a == 3); // true
    print(a != 2); // true
    print(a <= b); // false
    var c = 9;
    c += 10;
    print("c = $c"); // c = 19
    print(1<<2); // 4

    // 与Java不太一样的运算符操作
    // is运算符用于判断一个变量是不是某个类型的数据
    // is!则是判断变量不是某个类型的数据
    var s = "hello";
    print(s is String); // true
    var num = 6;
    print(num is! String); // true

    // ~/才是取整运算符，如果使用/则是除法运算，不取整
    int k = 1;
    int j = 2;
    print(k / j); // 0.5
    print(k ~/ j); // 0

    // as运算符类似于Java中的cast操作，将一个对象强制类型转换
    (emp as Person).teach();

    // ??=运算符 如果 ??= 运算符前面的变量为null，则赋值，否则不赋值
    var param1 = "hello", param2 = null;
    param1 ??= "world";
    param2 ??= "world";
    print("param1 = $param1"); // param1 = hello
    print("param2 = $param2"); // param2 = world
  
    // ?.运算符
    var str1 = "hello world";
    var str2 = null;
    print(str1?.length); // 11
    print(str2?.length); // null 
    print(str2.length); // 报错
  }
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

级联操作

用…调用某个对象的方法（或者成员变量）时，返回值是这个对象本身

  class Person {
    eat() {
      print("I am eating...");
    }

    sleep() {
      print("I am sleeping...");
    }

    study() {
      print("I am studying...");
    }
  }

  main() {
    // 依次打印
    //  I am eating...
    //  I am sleeping...
    //  I am studying...
    new Person()..eat()
        ..sleep()
        ..study();
  }
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23

控制流程

if / else, switch, for /while, try / catch语句跟Java中都类似。

  main() {
    // if else语句
    int score = 80;
    if (score < 60) {
      print("so bad!");
    } else if (score >= 60 && score < 80) {
      print("just so so!");
    } else if (score >= 80) {
      print("good job!");
    }

    // switch语句
    String a = "hello";
    // case语句中的数据类型必须是跟switch中的类型一致
    switch (a) {
      case "hello":
        print("haha");
        break;
      case "world":
        print("heihei");
        break;
      default:
        print("WTF");
    }

  // for语句
    List<String> list = ["a", "b", "c"];
    for (int i = 0; i < list.length; i++) {
      print(list[i]);
    }
    for (var i in list) {
      print(i);
    }
    // 这里的箭头函数参数必须用圆括号扩起来
    list.forEach((item) => print(item));

    // while语句
    int start = 1;
    int sum = 0;
    while (start <= 100) {
      sum += start;
      start++;
    }
    print(sum);

    // try catch语句
    try {
      print(1 ~/ 0);
    } catch (e) {
      // IntegerDivisionByZeroException
      print(e);
    }
  
    try {
      1 ~/ 0;
    } on IntegerDivisionByZeroException { // 捕获指定类型的异常
      print("error"); // 打印出error
    } finally {
      print("over"); // 打印出over
    }
  }
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

类

类的定义与构造方法

Dart中不需要用private, protected, public等修饰成员变量或成员函数

  class Person {
    String name;
    int age;
    String gender;
  
    Person(this.name, this.age, this.gender);
  
    say() {
      print("hello, this is $name, I am $age years old, I am a $gender");
    }
  }
1
2
3
4
5
6
7
8
9
10
11

  //上述的 Person(this.name, this.age, this.gender);等同于
  Person(String name, int age, String gender) {
      this.name = name;
      this.age = age;
      this.gender = gender;
}
1
2
3
4
5
6

要调用Person类的成员变量或成员方法，可以用下面的代码：

  var p = new Person("zhangsan", 20, "male");
  p.say(); // hello, this is zhangsan, I am 20 years old, I am a male
  p.age = 50; // 重新赋值
  p.gender = "female"; // 重新赋值
  p.say(); // hello, this is zhangsan, I am 50 years old, I am a female
1
2
3
4
5

类的继承

Dart中使用extends关键字做类的继承

  class Human {
    String name;
    Human.fromJson(Map data) {
      print("Human's fromJson constructor");
    }
  }

  class Man extends Human {
    Man.fromJson(Map data) : super.fromJson(data) {
      print("Man's fromJson constructor");
    }
  }
1
2
3
4
5
6
7
8
9
10
11
12

由于Human类没有默认构造方法，只有一个命名构造方法fromJson，所以在Man类继承Human类时，需要调用父类的fromJson方法做初始化，而且必须使用Man.fromJson(Map data) : super.fromJson(data)这种写法，而不是像Java那样将super写到花括号中。

类的成员方法

一个类的成员方法是一个函数，为这个类提供某些行为。上面的代码中已经有了一些类的成员方法的定义，这些定义方式跟Java很类似，你可以为某个类的成员变量提供getter/setter方法。

  class Rectangle {
    num left, top, width, height;

    // 构造方法传入left, top, width, height几个参数
    Rectangle(this.left, this.top, this.width, this.height);

    // right, bottom两个成员变量提供getter/setter方法
    num get right => left + width;
    set right(num value) => left = value - width;
    num get bottom => top + height;
    set bottom(num value) => top = value - height;
}
1
2
3
4
5
6
7
8
9
10
11
12

mixins(with 关键字)

mixins是一个重复使用类中代码的方式

  class A {
    a() {
      print("A's a()");
    }
  }

  class B {
    b() {
      print("B's b()");
    }
  }

  // 使用with关键字，表示类C是由类A和类B混合而构成
  class C = A with B;

  main() {
    C c = new C();
    c.a(); // A's a()
    c.b(); // B's b()
  }
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20

异步

Dart提供了async await等异步操作，这种异步操作在Flutter开发中会经常遇到，比如网络或其他IO操作，文件选择等都需要用到异步的知识。
async和await往往是成对出现的，如果一个方法中有耗时的操作，你需要将这个方法设置成async，并给其中的耗时操作加上await关键字，如果这个方法有返回值，你需要将返回值塞到Future中并返回。

  Future<int> checkVersion() async {
    int version = await lookUpVersion();
    return version;
  }

  main() {
    checkVersion().then((version) {
      print('$version');
    });
  }
1
2
3
4
5
6
7
8
9
10

更多内容，欢迎关注公众号：