类 - Part I

类的知识点较多，所以分成两节进行讲解，本节是Part I，下一节是Part II。

类是对象的蓝本，用于创建对象。

类的声明是使用关键字class，所有类都直接或间接继承最顶端的Object类。

*示例代码使用了dart核心库的identical函数，用于检查两个变量是否指向同一对象

属性和方法

类中可以声明数据和函数，即对象的属性和方法。

普通的属性和方法是与对象实例绑定，它们被称之为实例变量和实例方法；使用static修饰的属性和方法，它们与类绑定，通常称为类变量和类方法。

实例变量和实例方法、类变量和类方法，在类中都可以通过名称直接访问，实例变量和实例方法还可以通过this访问；在类的外部，实例变量和方法是通过实例.变量方式进行访问，而类变量和类方法必须通过类名.变量方式才能访问

1. // 声明一个表示'大剑'（《黑暗之魂》系列游戏的一类武器）的类
2. class GreatSword {
3. // 实例变量
4. String name; // 名称
5. final int damage = 100; // 基础伤害值（不可变）
6. int extraDamage = 0; // 其他附加伤害

8. // 类变量
9. static String category = 'weapon'; // 大剑的分类是武器

11. // 类方法
12. static upgrade(GreatSword sword) { // 升级，即增加附加伤害
13. sword.extraDamage += 10;
14. }

16. // 实例方法
17. info() => 'GreatSword - damage: ${damage} , extraDamage: ${this.extraDamage}'; // 通过名称或this访问实例变量
18. }

20. main() {
21. // 使用默认构造函数（见下一小节）进行实例化
22. var sword = new GreatSword();
23. print(sword.damage);
24. print(sword.info()); // GreatSword - damage: 100 , extraDamage: 0

26. // 使用类方法
27. GreatSword.upgrade(sword);
28. print(sword.extraDamage);
29. print(sword.info()); // GreatSword - damage: 100 , extraDamage: 10
30. }

构造函数

构造函数用于将类进行实例化（即创建对象），需要配合关键字new或const使用（在 Dart 2.0 中，new与const变为可选）。

没有显式声明构造函数的类，将默认拥有一个与类同名且没有参数的构造函数（无参默认构造函数）。

构造函数最常见的操作是使用参数对属性赋值，Dart 为此提供了简写方式（在参数列表中直接使用this.属性）。

除了普通的构造函数，Dart 还支持类名.构造函数名方式的命名构造函数

1. class GreatSword {
2. String name; // 名称
3. final int damage = 100; // 基础伤害值
4. int extraDamage = 0; // 其他附加伤害

6. // 构造函数
7. GreatSword(String name) {
8. this.name = name;
9. }
10. // 以上构造函数的简写方式
11. // GreatSword(this.name);

13. // 命名构造函数
14. GreatSword.enhanced(this.name, this.extraDamage);
15. // 等同于以下写法
16. // GreatSword.enhanced(String name, int extraDamage) {
17. //   this.name = name;
18. //   this.extraDamage = extraDamage;
19. // }
20. }

22. main() {
23. // 使用不同构造函数进行实例化
24. var sword = new GreatSword('Claymore'); // 普通大剑
25. var enhancedSword = new GreatSword.enhanced('Claymore', 20); // 强化版大剑
26. }

默认情况下，构造函数总是会自动新建一个对象，函数体内不需要也不能使用return语句。

如果不需要构造函数每次调用都新建对象，比如从缓存中获取已存在的对象，则可以使用工厂构造函数。

使用factory修饰的构造函数是工厂构造函数，跟普通构造函数不同，它必须使用return语句返回对象

1. class GreatSword {
2. String name; // 名称

4. // 使用Map类型（后续章节将进行讲解）作为对象缓存
5. static final Map cache = {};

7. // 工厂构造函数
8. factory GreatSword(String name) {
9. // 对象已存在缓存中
10. if (cache.containsKey(name)) {
11. return cache[name];
12. } else {
13. // 对象不存在缓存中，使用库私有的（后续章节将进行讲解）构造函数新建对象
14. final sword = new GreatSword._(name);
15. cache[name] = sword; // 存入缓存
16. return sword;
17. }
18. }

20. // 库私有的（后续章节将进行讲解）命名构造函数
21. GreatSword._(this.name);
22. }

24. main() {
25. // 进行多次实例化
26. var sword1 = new GreatSword('Claymore');
27. var sword2 = new GreatSword('Claymore');
28. // 使用顶层函数identical检查是否同一对象
29. print(identical(sword1, sword2)); // true - 是同一对象
30. }

如果希望创建不可变对象，可以将所有实例变量使用final修饰，构造函数使用const修饰，最后使用const创建对象即可

1. // 声明一个表示'篝火'（《黑暗之魂》系列游戏的存盘点）的类
2. class Bonfire {
3. final String name; // 名称

5. const Bonfire(this.name);
6. }

8. main() {
9. // 使用const进行多次实例化
10. var bonfire1 = const Bonfire('home');
11. var bonfire2 = const Bonfire('home');
12. // 使用顶层函数identical检查是否同一对象
13. print(identical(bonfire1, bonfire2)); // true - 是同一对象
14. // bonfire1.name = 'castle'; // 错误，尝试修改不可变对象
15. }

初始化列表

构造函数还支持初始化列表，书写方式是在参数列表后跟一个以冒号开头的，使用逗号分隔的赋值列表。

初始化列表先于构造函数体执行，常用于final属性的初始化，即没有初始化的final属性可以在初始化列表中进行赋值。

初始化列表还可使用this进行构造函数转发，使得构造函数逻辑得以复用，构造函数转发和赋值操作不能同时出现

1. class GreatSword {
2. String name; // 名称
3. final int damage; // 基础伤害值（没有初始化）
4. int extraDamage = 0; // 其他附加伤害

6. // 在初始化列表中设置final变量damage
7. GreatSword(this.name, [this.extraDamage = 0]) : damage = 100; // 普通大剑基础伤害100

9. // 在初始化列表中调用静态方法计算extraDamage
10. GreatSword.magic(this.name, this.damage) : extraDamage = magicPower(damage); // 魔法大剑的附加伤害要根据基础伤害计算得出

12. // 通过初始化列表转发到其他构造函数，其中this代表类名
13. GreatSword.bastard(): this('Bastard Sword', 10); // 混种大剑
14. GreatSword.moonlight(): this.magic('Moonlight GreatSword', 90); // 月光大剑

16. // 计算魔法武器的附加伤害
17. static magicPower(int damage) {
18. return damage * 0.15;
19. }
20. }

22. main() {
23. var sword = new GreatSword('Claymore');
24. var bastard = new GreatSword.bastard();
25. var moonlight = new GreatSword.moonlight();
26. print(sword.name); // Claymore
27. print(sword.damage); // 100
28. print(sword.extraDamage); // 0
29. print(bastard.name); // Bastard Sword
30. print(bastard.damage); // 100
31. print(bastard.extraDamage); // 10
32. print(moonlight.name); // Moonlight GreatSword
33. print(moonlight.damage); // 90
34. print(moonlight.extraDamage); // 13.5
35. }

Getter/Setter 方法

跟很多语言不同，Dart 通过一种特殊的getter/setter方法对对象属性进行读写，它们虽是方法却有跟属性一样的访问方式。

所有普通属性都有一对隐含的getter/setter，final属性只有getter。

自定义getter/setter也是支持的，书写方式是在方法名前添加get或set，getter有返回值无参数而setter正好相反

1. class GreatSword {
2. String name; // 名称
3. final int damage = 100; // 基础伤害值
4. int extraDamage = 0; // 其他附加伤害

6. // damage隐含的getter
7. // int get damage => damage;

9. // name和extraDamage隐含的getter和setter
10. // String get name => name;
11. // set name(String name) => this.name = name;
12. // int get extraDamage => extraDamage;
13. // set extraDamage(int extraDamage) => this.extraDamage = extraDamage;

15. // 自定义的getter和setter
16. // 总伤害
17. int get totalDamage {
18. return damage + extraDamage; // 基础伤害与附加伤害之和
19. }
20. set totalDamage(int totalDamage) {
21. extraDamage = totalDamage - damage; // 通过总伤害计算出附加伤害
22. }

24. // 打印信息
25. info() {
26. return '${name} - totalDamage: ' + this.totalDamage.toString(); // 通过this或直接访问属性
27. }
28. }

30. main() {
31. // 所有对属性的读写都是通过getter和setter
32. var sword = new GreatSword();
33. sword.name = 'GreatSword';
34. sword.totalDamage = 200;
35. print(sword.damage); // 100
36. print(sword.extraDamage); // 100
37. print(sword.info()); // GreatSword - totalDamage: 200

39. sword.damage = 180; // 错误，damage的setter不存在
40. }

getter和setter带来的好处是，你可以随时更改属性的内部实现，而且不用修改外部调用代码

1. // 版本1的GreatSword
2. class GreatSword1 {
3. final String name = 'GreatSword';
4. }

6. // 版本2的GreatSword，将属性name转换为一个getter
7. class GreatSword2 {
8. String get name {
9. return greatName();
10. }

12. greatName() => 'GreatSword';
13. }

15. main() {
16. // 使用两个不同版本的GreatSword，对name的访问方式不变
17. var sword = new GreatSword1();
18. print(sword.name); // GreatSword
19. sword = new GreatSword2();
20. print(sword.name); // GreatSword
21. }

子类

使用extends来创建子类，子类中使用super来访问父类。

除了构造函数，父类所有的属性（setter/getter）和方法都被子类继承，而且都可以被重写（override）。

子类的构造函数在执行前，将隐含调用父类的无参默认构造函数（没有参数且与类同名的构造函数）。

如果父类没有无参默认构造函数，则子类的构造函数必须在初始化列表中通过super显式调用父类的某个构造函数。

1. // 大剑
2. class GreatSword {
3. String name; // 名称
4. final int damage = 100; // 基础伤害值

6. // 总伤害的getter
7. int get totalDamage => damage; // 总伤害

9. // 一个参数的构造函数
10. GreatSword(this.name);
11. }

13. // 特大剑
14. class UltraGreatSword extends GreatSword {
15. int extraDamage = 20; // 附加伤害值

17. // 重写getter
18. int get totalDamage => super.damage + extraDamage; // 父类的伤害加上自己的附加伤害为总伤害（super可省略）

20. // 父类没有无参默认构造函数，必须使用super（代表父类名）调用父类的构造函数
21. UltraGreatSword(String name) : extraDamage = 50, super(name);
22. }

24. main() {
25. var black = new UltraGreatSword('Black Knight Greatsword');
26. print(black.name); // Black Knight Greatsword
27. print(black.damage); // 100
28. print(black.extraDamage); // 50
29. }