变量与类型
变量
类型 变量名 = 值；
如果一个变量在定义之后没有赋值，则默认等于null类型
基本类型 bool,num(int & double),String ,enum
泛型 List Mapvar
1.接受任何类型的变量
2.一旦赋值，无法改变类型，由此可看是一个强类型语言dynamic 与Object
| Object | 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';
}
}
静态与权限
- 静态与非静态的成员、成员函数
| 静态 | 非静态 | |
|---|---|---|
| 修饰 | 无 | static |
| 属于 | 对象 | 类 |
| 访问 | 成员、静态成员、成员函数、静态成员函数 | 只能访问静态成员和静态成员函数 |
- 权限
- 无关键字
- 使用符号"_" 标识权限
- 不存在针对类的访问权限，只有针对包(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);
});
}
