Dart介绍

Dart是强类型语言，但是兼有JavaScript的动态性。在Dart中，类型声明是可选的，可以使用类型推导，也可以显式声明。Dart语句以分号结尾，不可省略。

变量

Dart与java相比，String、int、bool、double基本一致，对于String，既可以使用单引号也可以使用双引号。

1
2
3
4
5
6
7
String str = "test";
String str = 'test';
// num表示数值类型，int和double都是num的子类型
num number = 10;
int a = 10;
double b = 3.14;
bool sign = true;

变量的声明

变量可以通过类型值显式声明，也可以通过类型推断进行声明，包括var、const、final以及dynamic和Object。

  1. 使用var声明时，可以接收任何类型的变量，一旦在声明时被赋值，类型便会被确定，不可以再修改。但是如果一开始没有直接赋值，那么变量默认是dynamic类型。

    1
    2
    3
    4
    5
    6
    7
    8
    var t = "hello world";
    // 类型已被确定为String，不可再修改为int。
    t = 123;

    var s;
    s = "hello world";
    // 可以正常修改，不会报错
    s = 123;

  2. const和final用于声明常量，区别在于：const常量是编译时常量，必须要是一个在程序编译时完全固定的常量。final常量是运行时常量，是惰性初始化，第一次使用才会初始化。

    1
    2
    3
    4
    5
    final str = "hello world";
    const str = "hello world";
    // 获取当前时间，由于是动态获取的，所以不能用const声明
    final time1 = new DateTime.now();
    const time2 = new DateTime.now();

    实例变量也可以是final，但不能是const。

    1
    2
    3
    4
    5
    class A{}
    void main(){
        final a = new A();	// OK
        const b = new A();	// Err
    }

    const还可以用于创建常量值，以及声明常量值的构造函数。任何变量都可以赋一个常量值。

    1
    2
    3
    4
    5
    6
    7
    8
    9
    10
    11
    12
    13
    var foo = const [];
    final bar = const [];
    // 可以从const声明的初始化表达式中省略const
    const bar = [];
    // 但是不能改变const变量的值
    bar = [42];	// err
    // 可以更改一个非final的非const变量的值，即使其曾经有一个const值
    foo = [1, 2, 3];
    // 有些类提供常量构造函数，要使用常量构造函数创建编译时常量，需要将const放在构造函数名前
    class Person{
        const Person();
    }
    var p = const Person();

  3. Object是dart所有对象的根基类，也就是说所有类型都是Object的子类（包括Function和Null），所以任何类型的数据都可以赋值给Object声明的对象。dynamic是与int这样一样的类型关键词，该类型声明的变量也可以赋值任意对象。

    1
    2
    3
    4
    5
    6
    dynamic s1;
    Object s2;
    s1 = "Hello dynamic";
    s2 = "Hello Object";
    s1 = 123;	// OK
    s2 = 123;	// OK

变量的默认值

在dart中所有的东西都是对象，因此未初始化的变量初始值都为null，包括数字类型。

字符串拼接

dart中的字符串拼接有以下几种方式。15091988134

1
2
3
4
5
String s1 = "First string is" + "TestString";	// First String is TestString
String str1 = '单引号字符串'	// 单引号字符串换行然后拼接
    '换行'
    '然后拼接';
String str2 = "左侧字符串"'拼接'"右侧字符串";	// 左侧字符串拼接右侧字符串

List和Map

List相当于java的数组和集合的综合体，在dart中，数组和集合都能用List表示。

1
2
3
4
5
6
7
8
9
10
11
12
List list = [];
var list2 = [1, 2, 3, 4];
list.add(3);
list.remove();

var map = {};
var map2 = {
    "key1": "value1",
    "key2": "value2",
    "key3": "value3"
};
map["key4"] = "value4";

枚举

和java相同。

1
enum Color{ red, green, blue };

可见性修饰符

dart中只有public和private两种可见性修饰符，默认为public，在变量名前加一个_声明为private。

1
2
var a = 10;	// public
var _b = 20; // private

基本语句

if…else、switch…case

基本和java一样。

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
var a = 10;
if(a < 9) {
    ...
}else if(a > 12) {
    ...
}else {
    ...
}

switch(a) {
    case 10:
        ...
        break;
    case 9:
        ...
        break;
    default:
      	...
        break;
}

for、while、do…while

基本和java一样。

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
var list = [7, 4, 3, 'dart', true];
// forEach
list.forEach((element) { print(element); });
// for..in
for(var item in list) {
    print(item);
}
// 标准for
for(var i = 0; i<list.length; i++) {
    print(list[i]);
}

var i = 0;
while(i < 10) {
    sum += i;
    i++;
}

do {
    sum += i;
    i++;
}while(i<10);

函数

构造函数

1
2
3
4
5
6
7
8
9
10
11
12
13
14
Person person = Person(2, 3);
var map = {"x": 2, "y": 3};
Person person1 = Person.fromJson(map);
class Person {
  int x = 0;
  int y = 0;
  //普通构造函数写法
  Person(this.x, this.y);
  //命名构造函数，使用命名构造函数可以创建多个构造函数
  Person.fromJson(Map json) {
    x = json['x'];
    y = json['y'];
  }
}

表达式函数

和Kotlin类似，在Dart中对于比较简单的函数，也可以用=>来表达。

1
2
3
4
// 无参匿名函数
fun1() => print("无参匿名函数");
// 有参匿名函数
fun2(name, type) => print("名字：$name, 类型：$type");

函数可选参数

与java不同，dart不支持重载，但是可以通过可选参数来实现。可选参数可以在函数定义时将可选参数用{}包住。

1
2
3
4
5
6
7
8
9
10
// String?表示该参数默认值为null，也可以手动指定默认值，如int age = -1
void printInfo(name,{int age = -1,String? info}){
    print("name: $name, age: $age, $info");
}
void main(){
    printInfo("张三");
    printInfo("李四", age:18);
    printInfo("王五",info:"这是王五");
    printInfo("Soria",age:18,info: "这里是soria的小窝~");
}

继承、混入和实现

dart有三种继承或实现其他类的方式，分别是extends、with、implements，三种可以混合使用。其中with和implements都可以多继承，extends只能继承一个。优先级顺序为with>extends>implements。当with或implements后跟了多个类的时候，优先级最右边大于左边，依次类推，例如extends a with b, c implements d, h，优先级为c>b>a>h>d。

dart中没有interface关键字，一般实现接口都用抽象类abstract。

1
2
3
4
5
6
7
8
9
10
11
12
13
abstract class Fruit{ getName() => print("eat fruit."); }

class Apple{ getName() => print("eat apple."); }

mixin Banana{ getName() => print("eat banana."); }

class Dinner extends Apple with Banana implements Fruit{}

// with优先级最高，输出eat banana.
void main(){
    final dinner = Dinner();
    dinner.getName();
}

mixin

要使用with关键字，需要使用mixin声明。

1
2
3
4
5
6
7
// 也可以省略掉class，直接mixin Student{ ... }
mixin class Student {
  var name = "soria", age = 18;
  getInfo() => print("$name: $age");
}

class TestA with Student {}

被mixin修饰的类不能声明构造函数，所以也不能被实例化。同时也不能被继承，只能使用with混入。