变量与类型

• 变量
  类型 变量名 = 值；
  如果一个变量在定义之后没有赋值，则默认等于null

• 类型
  基本类型 bool,num(int & double),String ,enum
  泛型 List Map

• var
  1.接受任何类型的变量
  2.一旦赋值，无法改变类型，由此可看是一个强类型语言

• dynamic 与Object

dynamic a = 'str';
print(a.length);//正确

Object a = 'str';
print(a.length);//错误

dynamic 很容易引起运行时错误

控制流语句

• 条件判断

• if 与其他语言差别不大

• Debug模式下接受bool类型，Release接受任何类型(但是除了bool类型，其他都判断为false)

• switch 语句

• 非空case在执行完之后必须以break、return、continue的方式结束

• 空case继续执行

• 循环语句

• for 与其他语言差别不大

• while 可以看做减缓版的for

• do-white 先执行一次，然后再判断

• 跳转语句

• break 结束整个循环

• continue 结束当前循环

函数

• 声明

• 没有显示声明返回值类型默认当做dynamic

• 函数返回值没有类型判断

• 语法简写
  => 表示

• 函数变量

• 作为参数

void main() {
  var calPower = (n) {
    return n * n;
  };
print(calPowder(5));
}

• 参数传递
• 层层传递

void main() {
  printPower(calPower(8));
}
void printPowder(var power) {
  print(power);
}
int calPower(int n) {
  return n * n;
}

• 可选位置参数
• 可以用[]来标记可选的参数位置

void main() {
  int m1 = calMultiplication(4);
print(m1);//16

int m2 = calMultiplication(4,5);
print(m2);
}

int calMultiplication(int 1,[int 5]) {
  if(b != null) {
    return a * b;
  }else {
      return a * a;
    }
}

• 可选命名参数
• 可以用 {} 来标记可选的命名参数

void main() {
  int m1 = calMultiplication(4);
print(m1);//16

int m2 = calMultiplication(4,b: 5);
print(m2);
}

int calMultiplication(int 1,[int 5]) {
  if(b != null) {
    return a * b;
  }else {
      return a * a;
    }
}

类和对象

• 定义
• class
• 构造函数
• 与类同名

class Person {
  int age;
  String name;

  Person(int age, String name) {
    this.age = age;
    this.name = name;  
  }

  int howOld() {
    return age;
}

• 空的构造函数

class Person {
  int age;
  String name;

  int howOld() {
    reutrn age;
  }
}

• 没有析构函数 => 垃圾回收

• 命名构造函数

• 更加方便

class Person {
    int age;
    String name;
    Person(this.age,this.name);
    Person.fromList(List<dynamic>list) {
        age = list[0]
        name = list[1]
    }

    int howOld() {
        return age;
    }
}

void main() {
    Person a = new Person(20,'小A');
    print(a.howOld());

    Person b = new Person.fromList([30,'小B']);
    print(b.howOld());
}

继承与多态

• 继承
• 继承一个基类: extends
• 调用基类方法： super
• 多态
• 没有很大差别

class Person {
    int age;
    String name;
    Person(this.age,this.name);
    Person.fromList(List<dynamic>list) {
        age = list[0]
        name = list[1]
    }

    int howOld() {
        return age;
    }
}

class Male extends Person {
    Male(int age, String name) : super(age,name);

    @override
    int howOld() {
        return age + 1;
    }
}

void main() {
    Person a = new Person(20,'小A');
    print(a.howOld());

    Person b = new Person.fromList([30,'小B']);
    print(b.howOld());

    Person c = new Male(20,'小C');
    print(c.howOld());
}

抽象类与接口

• 抽象类
• 关键字： abstract
• 不能实例化
• 抽象函数： 声明但不实现
• 派生类必须重写抽象类所有的抽象函数

abstract class Person {
    String getName();

    int getAge() {
        return 20;
    }
}

class Male extends Person {
    String getName() {
        return '小A'；
    }
}

void main() {
    Person a = new Person();

    Person b = new Male();
    print(b.getName());
}

• 接口
• 关键字： implements
• Dart每个类都是接口
• 必须实现构造函数外所有的成员函数

abstract class Person {
    String getName();

    int getAge() {
        return 20;
    }
}

class Male extends Person {
    String getName() {
        return '小A';
    }
}

class AA implements Male {
    @override 
    int getAge() {
        return 20;
    }

    @override
    String getName() {
        return 'AA';
    }
}

静态与权限

• 静态与非静态的成员、成员函数

• 权限
• 无关键字
• 使用符号"_" 标识权限
• 不存在针对类的访问权限，只有针对包(package) 的

异步支持

• Future + async + await

异步运算async -> 延迟队列(await) -> 等待结果(Future) 

• 简介一个异步支持
• async 与 await(await 关键字必须在async函数内部使用)

void main() {
  String data = '初始化data';
  getData(data);
}

getData(String data) async {
  print(data); //初始化data

  data = await Future.delayed(Duration(seconds: 2),() {
    return '网络数据';
  }) as String;
  
  print(data);//网络数据
}

• Future
• 表示异步操作的最终完成(或失败)
• 只会有一个结果
• 返回值仍然是Future类型

Future.then

void main() {
  Future<String> future = getData();
  future.then((data) {
    print(data);
  });
}

Future<String> getData() async {
  return await Future.delayed(Duration(seconds: 2),() {
    return '网络数据';
  });
}

• 异常错误

void main() {
  Future<String> future = getData();
  future.then((data) {
    print(data);
  }).catchError((e) {
      print(e);
  });
}

Future<String> getData() async {
  return await Future.delayed(Duration(seconds: 2),() {
    throw AssertionError("Error");
  });
}

void main() {
  Future<String> future = getData();
  future.then((data) {
    print(data);
  },onError: (e) {
      print(e);
  });
}

Future<String> getData() async {
  return await Future.delayed(Duration(seconds: 2),() {
    throw AssertionError("Error");
  });
}

• Future.whenComplete

• 标识无论成功或者失败，都会调用

• Future.wait

• 等待多个异步执行任务执行结束后再执行

• 接受一个Future数组参数

void main() {
  Future.wait([
    Future.delayed(new Duration(seconds: 2),() {
      return "hellow";
    }),
    Future.delayed(new Duration(seconds: 2),() {
      return " worrld";
    })
  ]).then((reuslts) {
    print(reuslts[0] + reuslts[1]);
  }).catchError((e) {
    print(e);
  });
}

文档学习

• 语法概览
  语法概览
• 博客
  简书博客