Flutter系列之Dart类和对象

Dart是一门使用类和单继承的面向对象语言
所有的对象都是类的实例，并且所有的类都是Object的子类

1、定义

类的定义用class关键字
如果未显式定义构造函数，会默认一个空的构造函数
使用new关键字和构造函数来创建对象

1
2
3
4
5
6
7
8
9
10
11
1class Point {

2  num x;

3  num y;

4  num z;

5}

6

7void main() {

8  var point = new Point();

9  print(point.hasCode);//未定义父类的时候，默认继承自Object

10}

11

2、构造函数

如果只是简单的参数传递，可以在构造函数的参数前加this关键字定义
或者参数后加 : 再赋值

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
1class Point {

2    num x;

3    num y;

4    num z;

5    

6    Point(this.x, this.y, z) { //第一个值传递给this.x，第二个值传递给this.y

7            this.z = z;

8    }

9    

10    Point.fromeList(var list): //命名构造函数，格式为Class.name(var param)

11            x = list[0], y = list[1], z = list[2]{//使用冒号初始化变量

12    }

13

14    //当然，上面句你也可以简写为：

15    //Point.fromeList(var list):this(list[0], list[1], list[2]);

16

17     String toString() => 'x:$x  y:$y  z:$z';

18}

19

20void main() {

21    var p1 = new Point(1, 2, 3);

22    var p2 = new Point.fromeList([1, 2, 3]);

23    print(p1);//默认调用toString()函数

24}

25

如果你要创建一个不可变的对象，你可以定义编译时常量对象
需要在构造函数前加const

1
2
3
4
5
6
7
1class ImmutablePoint {

2    final num x;

3    final num y;

4    const ImmutablePoint(this.x, this.y); // 常量构造函数

5    static final ImmutablePoint origin = const ImmutablePoint(0, 0); // 创建一个常量对象不能用new，要用const

6}

7

3、Getters And Setters

Getter和Setter是用来读写一个对象属性的方法
每个字段都对应一个隐式的Getter和Setter
但是调用的时候是obj.x，而不是obj.x()

你可以使用get和set关键字扩展功能
如果字段为final或者const的话，那么它只有一个getter方法

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
1class Rectangle {

2    num left;

3    num top;

4    num width;

5    num height;

6

7    Rectangle(this.left, this.top, this.width, this.height);

8    

9    // right 和 bottom 两个属性的计算方法

10    num get right => left + width;

11    set right(num value) => left = value - width;

12    num get bottom => top + height;

13    set bottom(num value) => top = value - height;

14}

15

16main() {

17    var rect = new Rectangle(3, 4, 20, 15);

18    assert(rect.left == 3);

19    rect.right = 12;

20    assert(rect.left == -8);

21}

22

4、抽象类

在Dart中类和接口是统一的，类就是接口
如果你想重写部分功能，那么你可以继承一个类
如果你想实现某些功能，那么你也可以实现一个类

使用abstract关键字来定义抽象类，并且抽象类不能被实例化
抽象方法不需要关键字，直接以分号 ; 结束即可

1
2
3
4
5
6
7
8
9
10
11
12
13
14
1abstract class Shape { // 定义了一个 Shape 类/接口

2    num perimeter(); // 这是一个抽象方法，不需要abstract关键字，是隐式接口的一部分。

3}

4

5class Rectangle implements Shape { // Rectangle 实现了 Shape 接口

6    final num height, width; 

7    Rectangle(num this.height, num this.width);  // 紧凑的构造函数语法

8    num perimeter() => 2*height + 2*width;       // 实现了 Shape 接口要求的 perimeter 方法

9}

10

11class Square extends Rectangle { // Square 继承 Rectangle

12    Square(num size) : super(size, size); // 调用超类的构造函数

13}

14

5、工厂构造函数

Factory单独拿出来讲，因为这不仅仅是构造函数，更是一种模式
有时候为了返回一个之前已经创建的缓存对象，原始的构造方法已经不能满足要求
那么可以使用工厂模式来定义构造函数
并且用关键字new来获取之前已经创建的缓存对象

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
1class Logger { 

2    final String name; 

3    bool mute = false; 

4    

5    // 变量前加下划线表示私有属性 

6    static final Map<String, Logger> _cache = <String, Logger>{}; 

7    

8    factory Logger(String name) { 

9        if (_cache.containsKey(name)) { 

10            return _cache[name]; 

11        } else { 

12            final logger = new Logger._internal(name); 

13            _cache[name] = logger; 

14            return logger; 

15        } 

16    }

17

18    Logger._internal(this.name); 

19    

20    void log(String msg) { 

21        if (!mute) { 

22            print(msg); 

23        } 

24    } 

25} 

26

27var logger = new Logger('UI'); 

28logger.log('Button clicked');

29

本文图片资料来源出自“Dart语言中文社区”，允许转载，转载时请务必以超链接形式标明文章原始出处 。