变量

  1. var a = 1;
  2. int b = 10;
  3. double c = 0.5;
  4. String s = "hello";
  5. dynamic d = 0.5;
  7. final Num = count;  // final 只能赋值一次
  8. const Num1 = 10; // const赋值必须是编译时常量
  9. //区别一：final 要求变量只能初始化一次，并不要求赋的值一定是编译时常量，可以是常量也可以不是。而 const 要求在声明时初始化，并且赋值必需为编译时常量。
  10. //区别二：final 是惰性初始化，即在运行时第一次使用前才初始化。而 const 是在编译时就确定值了。
  13. // numbers
  14. var a = 0;
  15. int b = 1;
  16. double c = 0.1;
  18. // strings
  19. var s1 = 'hello';
  20. String s2 = "world";
  22. // booleans
  23. var real = true;
  24. bool isReal = false;
  26. // lists
  27. var arr = [1, 2, 3, 4, 5];
  28. List<String> arr2 = ['hello', 'world', "123", "456"];
  29. List<dynamic> arr3 = [1, true, 'haha', 1.0];
  31. // maps
  32. var map = new Map();
  33. map['name'] = 'zhangsan';
  34. map['age'] = 10;
  35. Map m = new Map();
  36. m['a'] = 'a';
  38. //runes，Dart 中 使用runes 来获取UTF-32字符集的字符。String的 codeUnitAt and codeUnit属性可以获取UTF-16字符集的字符
  39. var clapping = '\u{1f44f}';
  40. print(clapping); // 打印的是拍手emoji的表情
  42. // symbols
  43. print(#s == new Symbol("s")); // true

函数

  1. // 声明返回值
  2. int add(int a, int b) {
  3.   return a + b;
  4. }
  6. // 不声明返回值
  7. add2(int a, int b) {
  8.   return a + b;
  9. }
  12. // =>是return语句的简写
  13. add3(a, b) => a + b; 
  15. // 无返回值
  16. add4(int a, int b) {
  17.   int c=  a + b;
  18.    print(c);
  19. }
  21. main() {
  22.   print(add(1, 2)); // 3
  23.   print(add2(2, 3)); // 5
  24.   print(add3(1, 2)); // 3
  26.   add4(1.2);// 3
  27. }

函数返回值

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

命名参数

  1. sayHello({String? name}) {
  2.   print("hello, my name is $name");
  3. }
  5. sayHelloRequired({String required name}) {
  6.   print("hello, my name is $name");
  7. }
  9. main() {
  10.   // 打印 hello, my name is zhangsan
  11.   sayHello(name: 'zhangsan');
  12.   // 打印 hello, my name is
  13.   sayHello();
  15.   // 打印 hello, my name is zhangsan
  16.   sayHelloRequired(name: 'zhangsan');
  17.   //报错
  18.   sayHelloRequired();
  19. }

参数默认值

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

lambda表达式

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

运算符

  1. main() {
  2.   // 与Java相同的运算符操作
  3.   int a = 1;
  4.   ++a;
  5.   a++;
  6.   var b = 1;
  7.   print(a == b);  // false
  8.   print(a * b); // 3
  9.   bool real = false;
  10.   real ? print('real') : print('not real'); // not real
  11.   print(real && a == b); // false
  12.   print(real || a == 3); // true
  13.   print(a != 2); // true
  14.   print(a <= b); // false
  15.   var c = 9;
  16.   c += 10;
  17.   print("c = $c"); // c = 19
  18.   print(1<<2); // 4
  20.   // 与Java不太一样的运算符操作
  21.   // is运算符用于判断一个变量是不是某个类型的数据
  22.   // is!则是判断变量不是某个类型的数据
  23.   var s = "hello";
  24.   print(s is String); // true
  25.   var num = 6;
  26.   print(num is! String); // true
  28.   // ~/才是取整运算符，如果使用/则是除法运算，不取整
  29.   int k = 1;
  30.   int j = 2;
  31.   print(k / j); // 0.5
  32.   print(k ~/ j); // 0
  34.   // as运算符类似于Java中的cast操作，将一个对象强制类型转换
  35.   (emp as Person).teach();
  37.   // ??=运算符 如果 ??= 运算符前面的变量为null，则赋值，否则不赋值
  38.   var param1 = "hello", param2 = null;
  39.   param1 ??= "world";
  40.   param2 ??= "world";
  41.   print("param1 = $param1"); // param1 = hello
  42.   print("param2 = $param2"); // param2 = world
  44.   // ?.运算符
  45.   var str1 = "hello world";
  46.   var str2 = null;
  47.   print(str1?.length); // 11
  48.   print(str2?.length); // null 
  49.   print(str2.length); // 报错
  50. }

级联操作

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

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

控制流程

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

  1. main() {
  2.   // if else语句
  3.   int score = 80;
  4.   if (score < 60) {
  5.     print("so bad!");
  6.   } else if (score >= 60 && score < 80) {
  7.     print("just so so!");
  8.   } else if (score >= 80) {
  9.     print("good job!");
  10.   }
  12.   // switch语句
  13.   String a = "hello";
  14.   // case语句中的数据类型必须是跟switch中的类型一致
  15.   switch (a) {
  16.     case "hello":
  17.       print("haha");
  18.       break;
  19.     case "world":
  20.       print("heihei");
  21.       break;
  22.     default:
  23.       print("WTF");
  24.   }
  26.   // for语句
  27.   List<String> list = ["a", "b", "c"];
  28.   for (int i = 0; i < list.length; i++) {
  29.     print(list[i]);
  30.   }
  31.   for (var i in list) {
  32.     print(i);
  33.   }
  34.   // 这里的箭头函数参数必须用圆括号扩起来
  35.   list.forEach((item) => print(item));
  37.   // while语句
  38.   int start = 1;
  39.   int sum = 0;
  40.   while (start <= 100) {
  41.     sum += start;
  42.     start++;
  43.   }
  44.   print(sum);
  46.   // try catch语句
  47.   try {
  48.     print(1 ~/ 0);
  49.   } catch (e) {
  50.     // IntegerDivisionByZeroException
  51.     print(e);
  52.   }
  54.   try {
  55.     1 ~/ 0;
  56.   } on IntegerDivisionByZeroException { // 捕获指定类型的异常
  57.     print("error"); // 打印出error
  58.   } finally {
  59.     print("over"); // 打印出over
  60.   }
  61. }

类

类的定义与构造方法

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

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

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

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

类的继承

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

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

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

类的成员方法

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

  1. class Rectangle {
  2.   num left, top, width, height;
  4.   // 构造方法传入left, top, width, height几个参数
  5.   Rectangle(this.left, this.top, this.width, this.height);
  7.   // right, bottom两个成员变量提供getter/setter方法
  8.   num get right => left + width;
  9.   set right(num value) => left = value - width;
  10.   num get bottom => top + height;
  11.   set bottom(num value) => top = value - height;
  12. }

mixins(with 关键字)

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

  1. class A {
  2.   a() {
  3.     print("A's a()");
  4.   }
  5. }
  7. class B {
  8.   b() {
  9.     print("B's b()");
  10.   }
  11. }
  13. // 使用with关键字，表示类C是由类A和类B混合而构成
  14. class C = A with B;
  16. main() {
  17.   C c = new C();
  18.   c.a(); // A's a()
  19.   c.b(); // B's b()
  20. }

异步

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

  1. Future<int> checkVersion() async {
  2.   int version = await lookUpVersion();
  3.   return version;
  4. }
  6. main() {
  7.   checkVersion().then((version) {
  8.     print('$version');
  9.   });
  10. }