2019-09-20: 九: Flutter之Dart第六节(类和对象)?

九: Flutter之Dart第六节(类和对象)?

Dart 是一个面向对象的语言、面向对象中非常重要的概念就是类、类产生了对象。
这一节，我们就具体来学习类和对象、但是Dart对类进行了很多其他语言没有的特性、一起探讨。

9.1: 类的定义

在Dart中、定义类用class关键字。
类通常有两部分组成：成员(member) 和 方法 (method)。
定义类的伪代码如下:

class 类名 {
   类型 成员名
   返回值类型 方法名(参数列表) {
     方法体
   }
 }

编写一个简单的Person类

• 这里有一个注意点：我们在方法中使用属性(成员变量/实例变量)时、并没有加this；
• Dart的开发风格中、在方法中通常使用属性时、会省略this、但是有命名冲突时、this不能省略。

class Person {
 String name;

 eat() {
   print('$name在吃东西');
 }
}

main(List args) {
 // 2: 我们在方法中使用属性并没有使用this、一般我们都是省略的、但是如果在方法中使用属性的时候、如果有命名
 // 冲突的话、this不能省略

 // 1: 创建类的对象, 直接使用Person() 也可以创建
 var p = new Person();

 // 2: 给对象的属性赋值
 p.name = 'lishengbing';

 // 3: 调用对象方法
 p.eat();

 //打印： lishengbing在吃东西
}

9.2: 构造方法

9.2.1: 普通构造方法

我们知道、当通过类创建一个对象时、会调用这个类的构造方法

• 当类中没有明确指定的构造方法时、将默认拥有一个无参的构造方法

• 前面的Person中我们就是在调用这个构造方法、我们也可以根据自己的需求、定义自己的构造方法。

• 注意1: 当有了自己的构造方法时、默认的构造方法将会失效、不能使用
  -- 当然、你可能希望明确的写一个默认的构造方法、但是会和我们自定义的构造方法冲突
  -- 这是因为Dart语言本身不支持函数的重载(名称相同、参数不同的方式)

• 注意2: 这里我还实现了toString方法。

class Person {
 String name;
 int age;

 // 明确指定了构造方法、如果没有指定默认是Person()
 Person(String name, int age) {
   this.name = name;
   this.age = age;
 }

 @override
 String toString() {
   return 'name = ${name}, age = ${age}';
 }
}

另外、在实现构造方法时、通常做的事情就是通过 **参数给属性 **赋值，如上this.name = name
为了简化了这一过程、Dart提供了一种更加简洁的语法糖形式
上面的构造方法可以优化成下面的写法：

// 明确指定了构造方法、如果没有指定默认是Person()
 Person(String name, int age) {
   this.name = name;
   this.age = age;
 }

 // 等同于上面优化构造方法
 Person(this.name, this.age);

9.2.2: 命名构造方法

但是在开发中、我们确实希望实现更多的构造方法、怎么办呢？

• 因为不支持方法(函数)的重载、所以我们没办法创建相同名称的构造方法。我们需要使用命名构造方法。

class People {
 String name;
 int age;

 People() {
  name = '';
   age = 0;
 }

 // 命名构造方法, withArgments可以随便变化
 People.withArgments(String name, int age) {
   this.name = name;
   this.age = age;
 }

// 优化上面的构造方法
 //People.withArgments(this.name, this.age);

 @override
 String toString() {
     return 'name=${name} age=${age}';
  }
}

/*
* name= age=0
 name=lishengbing age=28
*/
main(List args) {
 var p = new People();
 print(p);
 var p1 = new People.withArgments('lishengbing', 28);
 print(p1);
}

在之后的开发中、我们也可以利用命名构造方法、提供更加便捷的创建对象的方式

• 比如开发中、我们需要经常将一个Map转成对象、可以提供如下的构造方法

// 新的构造方法
 People.fromMap(Map map) {
   this.name = map['name'];
   this.age = map['age'];
 }
var p3 = new People.fromMap({'name': 'lishengbing', 'age': 29});
 // name=lishengbing age=29
 print(p3);

9.2.3: 初始化列表

我们来重新定义一个类Point、传入x/y、可以得到它的距离distance:

初始化列表

class Point {
 final num x;
 final num y;
 final distance;

// 错误写法

Point(this.x, this.y) {
  distance = sqrt(x * x + y * y);
}*/

 // 正确写法
 Point(this.x, this.y) : distance = sqrt(x * x + y * y);

}

上面这种初始化变量的方法、我们称之为初始化列表(Initializer list)

9.2.4: 重定向构造方法

在某些情况下、我们希望在一个构造方法中去调用另一个构造方法、这时候我们就可以使用重定向构造方法。

• 在一个构造函数中、去调用另一个构造函数(注意：是在冒号后面使用this调用)

class Person01 {
 String name;
 int age;

 Person01(this.name, this.age);
 Person01.fromName(String name) : this('lishengbing', 30);
}

9.2.5: 常量构造方法

在某些时候下、传入相同值时、我们希望返回同一个对象、这个时候、可以使用常量构造方法
默认情况下、创建对象时、即使传入相同的参数、创建出来的对象也不是同一个对象，看下面的代码：

• 我们使用identical(对象1， 对象2)函数来判断两个对象是否是同一个对象

class Person02 {
 String name;
 Person02(this.name);
}

main(List args) {
 var p1 = Person02('lishengbing');
 var p2 = Person02('lishengbing');

 // false
 print(identical(p1, p2));
}

• 但是如果将构造方法前加上 const进行修饰的话、那么可以保证同一个参数、创建出来的对象是相同的。
  这样的构造函数就叫做常量构造方法

class Person02 {
final  String name;
const  Person02(this.name);
}

main(List args) {
 var p1 = const Person02('lishengbing');
 var p2 = const Person02('lishengbing');

 // true
 print(identical(p1, p2));
}

常量构造方法有一些注意点：

• 注意一：拥有常量构造方法的类中、所有的成员变量必须是final学校修饰的、如final String name;
• 注意二：为了可以使用常量构造方法、创建出相同的对象，不再使用new 关键字、而是使用const关键字
  -- 如果是将结果赋值给const修饰的标识符时、const可以省略。

9.2.5: 工厂构造方法

Dart 提供了factory关键字、用于通过工厂去获取对象。
工厂获取得到的对象传入同一个参数、得到的是同一个对象
传入不同的参数、获取的对象不是同一个对象。

main(List args) {
 var p1 = Person03('object');
 var p2 = Person03('object');

 // 工厂构造方法获取对象比较=true
 print('工厂构造方法获取对象比较=${identical(p1, p2)}');
}

class Person03 {
 String name;

 static final Map _cache = {};

 factory Person03(String name) {
   if (_cache.containsKey(name)) {
       return _cache[name];
  }else {
       final p = Person03._internal(name);
       _cache[name] = p;
       return p;
   }
 }

 Person03._internal(this.name);

}

9.2.6: setting & getting

默认情况下、Dart中类定义的属性是可以被外界直接访问的
但是某些情况下、我们希望监控这个类的属性被访问的过程、这个时候就可以使用setting 和 getting了

main(List args) {
 final d = Dog('黄色');

 //打印就是: dog color = 黑色
 d.setColor = '黑色';
 
 //打印就是: dog color = 红色
 d.color = '红色';
 print('dog color = ${d.getColor}');
}


class Dog {
 String color;

 String get getColor {
   return color;
 }

 set setColor(String color) {
   this.color = color;
 }

 Dog(this.color);
}

9.2.7: 类的继承(仅支持单继承、多继承不可以)

1: 面向对象的其中一大特性就是继承、继承不仅可以减少我们的代码量、也是多态的使用前提

2: dart 中的继承使用extends 关键字、子类中使用super来访问父类；

3: 父类中的所有成员变量和方法都会被继承、但是构造方法除外.

main(List args) {
 var p = new Person04();
 p.age = 10;
 p.run();
 /// 奔跑ing
 /// 继承=10
 print('继承=${p.age}');
}

class Animal {
 int age;
 run() {
  print('奔跑ing');
 }
}

class Person04 extends Animal {

}

9.2.7(1): 子类可以拥有自己的成员变量、并且可以对父类的方法进行重写

class Person04 extends Animal {
 @override
 run() {
  // TODO: implement run
   1: 如果子类重写了父类的方法，打印父类的方法
   //我是Person04类的重写run方法
   //继承=10
   print('我是Person04类的重写run方法');
 }
}

9.2.7(2): 子类中可以调用父类的构造方法、对某些属性进行初始化

• 子类的构造方法在执行前， 将隐式调用父类的默认的无参数的构造方法(没有参数且类同名的构造方法)
• 如果父类没有无参默认构造方法、则子类的构造方法必须在初始化列表中通过super显式调用父类的某个构造方法。

class Animal {
 int age;
 run() {
   print('奔跑ing');
 }

 // 只要这样写、该类就没有了无参默认构造函数
 Animal(this.age);
}

class Person04 extends Animal {

 String name;

 Person04(String name, int age) : name=name, super(age);

 @override
 run() {
   // TODO: implement run
   // 1: 如果子类重写了父类的方法，打印父类的方法
   // 我是Person04类的重写run方法
   // 继承=10
   print('我是Person04类的重写run方法');
 }

 @override
 String toString() {
     print('toString-');
  }
}

9.2.8: 抽象类

我们知道、继承是多态使用的前提
所以在定义很多通用的通用接口时我们通常会让调用者传入父类、通过多态类实现更加灵活的调用方式。

但是、父类本身可能并不需要对某些方法进行具体的实现、所以父类中定义的方法、我们可以定义为抽象类。

什么是抽象方法？在Dart中没有具体实现的方法(没有方法体)、就是抽象方法。

• 抽象方法、必须存在于抽象类中。
• 抽象类是使用abstract 声明的类。
  下面这个Shape类就是一个抽象类、其中包含了一个抽象方法

abstract class Shape {
  getArea();
}

class Circle extends Shape {

  double r;
  Circle(this.r);

  @override
  getArea() {
    // TODO: implement getArea
    return r * r * 3.14;
  }
}

class Reactangle extends Shape {

  double w;
  double h;
  Reactangle(this.w, this.h);

  @override
  getArea() {
    // TODO: implement getArea
    return w * h;
  }
}

注意事项：

• 注意一：** 抽象类中不能实例化；
• 注意二：** 抽象类中的抽象方法必须被子类实现、抽象类中的已经被实现方法、可以不被子类重写；

9.2.9: 隐式接口

Dart中的接口比较特殊、没有一个专门的关键字来声明接口
默认情况下、定义的每一个类都相当于默认也声明了一个接口、可以由其他的类来实现(因为Dart不支持多继承)

在开发中、我们通常将用于给别人来实现的类声明为抽象类：

abstract class Runner {
  run();
}

abstract class Flyer {
  fly();
}

class SuperMan implements Runner, Flyer {
  @override
  run() {
    // TODO: implement run
    print('超人在跑');
  }

  @override
  fly() {
    // TODO: implement fly
    print('超人在飞');
  }
}

9.2.10: Mixin混入

在通过implements实现某个类时、类中所有的方法都必须被重载实现(无论这个类原来是否已经实现过该方法)

但是在某些情况下、一个类可能希望直接复用之前类的原有实现方案、怎么做呢？

• 使用继承吗？但是Dart只支持单继承、那么意味着你只能复用一个类的实现

Dart提供了另外一种方案：Mixin混入的方式

• 除了可以class 定义类之外、也可以通过mixin关键字来定义一个类
• 只是通过mixin定义的类用于被其他类混入使用、通过with关键字来进行混入。

main(List args) {
  var superMan = SuperMain();
  superMan.run();
  superMan.fly();
  /*
  在奔跑...
  在飞翔... 
  */
}

mixin Runner1 {
  run() {
    print('在奔跑...');
  }
}

mixin Flyer1 {
  fly() {
    print('在飞翔...');
  }
}

/// implements的方式必须要求对其中的方法进行重新实现
class SuperMain0 implements Runner1, Flyer1 {

  @override
  run() {
    // TODO: implement run
    return null;
  }

  @override
  fly() {
    // TODO: implement fly
    return null;
  }
}

class SuperMain with Runner1, Flyer1 {

}

9.2.11: 类成员和方法

前面我们在类中定义的成员和方法都属于对象级别的、在开发中、我们有时候也需要定义类级别的成员和方法

在Dart中我们使用static关键字类定义：

main(List args) {
  var stu = Student();
  stu.name = 'lishengbing';
  stu.age = 66;
  stu.study();

  Student.time = '早上10点';
  Student.attendClass();
  // lishengbing在学习
  // 去上课
}

class Student {
  String name;
  int age;

  static String time;

  study() {
    print('$name在学习');
  }

  static attendClass() {
    print('去上课');
  }
}

9.2.12: 枚举的类型

枚举在开发中也非常常见、枚举也是一种特殊的类、通常用于表示数量的常量值。

1: 枚举的定义

枚举使用enum关键字来进行定义

// 1: 枚举的定义

main(List args) {
  // Colors.red
  print(Colors.red);
  // values, [Colors.red, Colors.green, Colors.blue]
  print(Colors.values);
  // index, 0
  print(Colors.red.index);
}

enum Colors {
  red,
  green,
  blue
}

2: 枚举的属性

枚举类型中有两个比较常见的属性

• index: 用于表示每个枚举常量的索引、从0开始
  如：print(Colors.red.index);
• values：包含每个枚举值的List
  如：print(Colors.values);

3: 枚举的注意事项

• 注意1: 您不能子类化、混合或者实现枚举。
• 注意2: 不能显式实例化一个枚举。

9.3: 泛型

1: 为什么使用范型?

......

2: List和Map的范型

main(List args) {
// 1: 创建List的方式
var name1 = ['lishengbing', 'zhangsan', 'wangxiao', 111];
// List
// List