一、基本类型
Dart没有byte、char和float，int、double都是64位的
bool done = true;
int num = 2;
double x = 3.14;
二、常量
final表示运行时常量（在程序运行的时候赋值，赋值后值不再改变）；const编译时常量（在程序编译的时候赋值，赋值后值不再改变）
final bool visible = false;
final int amount = 100;
final double y = 2.7;
const bool debug = true;
const int sum = 42;
const double z = 1.2;
三、类型推断
var done1 = true;
var num1 = 2;
var x1 = 3.14;
四、Dart里的所有都是对象，包括int、函数
五、String
Dart中的String跟Java中一样，都是不可变对象，不同的是在Dart中比较两个字符串内容是否相等用==，比较是否是同一对象用identical()
String str = "foo";
var str1 = "foo";
var str2 = str1.toUpperCase();
var str3 = str1.substring(0);
var str4 = str1.substring(0, 1);
var length = str1.length;
var str5 = str1.trimLeft();
var str6 = str1.trimRight();
var str7 = str1.trim();
var str8 = str1.split('');
var startBool = str1.startsWith('');
var endBool = str1.endsWith('');
var str9 = str1.contains('');
六、List、Set、Map
///List
//使用构造函数创建List对象
//等同于 var list = new List<int>();
var list = List<int>();
list.add(1);
list.add(2);
//通过字面量创建对象，泛型参数可以变量中推断出来
//推荐使用字面量方式创建对象
var list2 = [1, 2];
//没有元素，显示指定泛型参数
var list3 = <int>[];
list3.add(1);
list3.add(2);
//list4指向一个常量，因此不能添加元素
var list4 = const [1, 2];
//不能添加元素，相当于 const list5 = const[1,2];
const list5 = [1, 2];
//for in循环List
for (var e in list) {
print(e);
}
///Set
//Set只能通过构造函数创建
var set = Set<String>();
set.add('foo');
set.add('bar');
assert(set.contains('foo'));
///Map
var map = Map<String, int>();
//添加
map['foo'] = 1;
map['bar'] = 3;
//修改
map['foo'] = 4;
//可以判断是否key是否存在
if (map['foobar'] == null) {
print('map does not contain foobar');
}
//map2指向一个常量，因此不能添加元素
var map2 = const{
'foo': 1,
'bar': 3,
};
var map3 = <String, int>{};
七、Object、dynamic
Dart中万物皆对象，这些对象的父类就是Object
Object o = 'string';
o = 42;
o.toString();
Object和dynamic都可以接受任何类型的参数，但两者区别非常大；Object相对来说更安全，类型系统会保证其类型安全。dynamic则是告诉编译器，不用类型检测，当调用一个不存在的方法时，会执行 noSuchMethod() 方法，默认情况下（在 Object 里实现）它会抛出 NoSuchMethodError
dynamic obj = 'str';
//编译可以通过，但运行时会抛出NoSuchMethodError
obj['foo'] = 4;
//为了运行时类型检测，Dart提供了关键字 is、is!
dynamic obj1 = <String, int>{};
if (obj1 is Map<String, int>) {
obj1['bar'] = 1;
}
//Dart也提供了关键字 as 来进行强制类型转换，但为了安全推荐使用is
var map = obj as Map<String, int>;
八、if else、do while、while、switch（switch也支持string和enum）
var success = true;
if (success) {
print('done');
} else {
print('fail');
}
for (var i = 0; i < 5; i++) {
print(i);
}
var sum = 0;
var j = 1;
do {
sum += j;
++j;
} while (j < 5);
while (sum-- > 0) {
print(sum);
}
var type = "1";
switch (type) {
case '1':
break;
case '2':
break;
default:
break;
}
九、函数
//普通函数
int foo1(int x) {
return x;
}
//带可选参数的函数
int foo2(int x, [int y]) {
//int也可以是null
if (y != null) {
return x + y;
}
return x;
}
//带默认参数的函数
int foo3(int x, [int y = 0]) {
return x + y;
}
//具名参数
void demo1() {
//具名参数的顺序可以是任意的
//所有具名参数都是可选的
foo4(x: 1, y: 2);
}
int foo4({int x, int y}) {
return x + y;
}
//具名参数带默认值
int foo5({int x = 0, int y = 0}) {
return x + y;
}
//如果想告诉用户某个具名参数是必须的，可以用注解 @required
//@required是meta包里提供的API
int foo6({@required int x, @required int y}) {
return x + y;
}
//函数还可以在函数内部定义
typedef Adder = int Function(int, int);
Adder makeAdder(int extra) {
int adder(int x, int y) {
return x + y + extra;
}
return adder;
}
//写法二
Adder makeAdder2(int extra) {
return (int x, int y) {
return x + y + extra;
};
}
//写法三
Adder makeAdder3(int extra) {
return (x, y) => x + y + extra;
}
void demo2() {
var adder = makeAdder(2);
print(adder(1, 2));
}
十、异常
//捕获异常
try {
//抛出异常
throw Exception('');
} on FormatException catch (e) {
//捕获特定类型的异常
print(e.message);
} catch (e) {
//捕获所有异常
} finally {
}
//跟Java不同，Dart可以抛出任意类型
throw 1;
十一、类
class Class1 {
int x;
int y;
Class1(int x, int y) {
this.x = x;
this.y = y;
}
}
//简便写法
class Class2 {
int x;
int y;
Class2(this.x, this.y);
}
使用初始化列表（initializer list）对对象进行初始化，initializer list 会在构造函数的函数体运行前执行
class Class3 {
int x;
int y;
Class3(int x, int y)
: x = x,
y = y {
//...
}
}
Dart 具有垃圾收集功能，对象的使用跟 Java 里几乎是一样的。Dart 使用 package 的概念来管理源码和可见性。它没有 public、private 之类的访问权限控制符，默认情况下，所有的符号都是公开的。如果我们不想某个变量对包的外部可见，可以使用下划线开头来给变量命名。
int _x = 0;
继承
//对象构造时它跟 Java、C++ 都不太一样：
//先执行子类 initializer list，但只初始化自己的成员变量
//初始化父类的成员变量
//执行父类构造函数的函数体
//执行之类构造函数的函数体
//基于这个初始化顺序，推荐是把 super() 放在 initializer list 的最后。
//此外，在 initializer list 里不能访问 this（也就是说，只能调用静态方法）
class Class4 extends Class1 {
//父类的构造函数只能在 initializer list 里调用
Class4(int x, int y) : super(x, y);
}
虽然 Dart 是单继承的，但它也提供了一定程度的多重继承支持，Dart 把支持多重继承的类叫做 mixin。
class Class5 extends Class1 with Bark {
Class5(int x, int y) : super(x, y);
}
十二、泛型
跟 Java 不同，Dart 的泛型参数类型在运行时是保留的。
十三、Future
Dart 是单线程的，主线程由一个事件循环来执行（类似 Android 的主线程）。对于异步代码，我们通过 Future 来获取结果
void future1() {
var file = File('');
file.exists().then((exists) => print(''))
.catchError((e) => print(e));
}
void future2() async {
var file = File('');
try {
var exists = await file.exists();
print(exists);
} catch (e) {
print(e);
}
}
网友评论