HelloDart-构造函数特性

Dart的构造函数花样比较多，使用起来十分灵活。其主要特性如下

全部类都继承自Object类
如果一个类没有声明构造函数，默认会有一个无参构造

命名构造函数
在Dart中，可以使用命名构造函数来创建对象

class Human{
  String gender;
  Human.male(){
    this.gender="male";
  }
  Human.female(){
    this.gender="female";
  }
}

语法糖，一个带成员变量的构造函数，只要参数跟成员命名一致并带上this关键字可以轻松完成赋值，不需要在构造函数体中对成员变量进行赋值。
```
class Person{
  int age;
  String name;
  String gender;
  //自动赋值
  Person(this.age, this.name, this.gender);
}
```

子类的构造函数会默认继承超类的无参构造，如果父超类类没有无参构造必须手动指定其他构造函数。简单点讲

如果超类拥有无参构造，子类的所有构造函数都默认继承这一个无参构造，除非手动指定继承其他构造函数
如果超类有带参构造或者命名构造函数，并且没有无参构造。那么子类的构造函数必须手动指定所继承的父类构造函数
具体可以参考以下栗子，生物类biology带有一个默认无参构造，Human带有一个有参构造，其超类带有无参构造所以无所手动指定超类构造函数。而Teacher类继承自Human类，必须指定继承的构造函数

//生物类，自带一个默认无参构造函数
class Biology {
  Biology() {
    print("this is a biology");
  }
}

//人类，继承自生物类，带有岁数，性别，姓名有参构造，默认继承父类的无参构造
class Human extends Biology {
  int age;
  String name;
  String gender;

  Human(this.age, this.name, this.gender) {
    print(
        "this is a human-> age = ${this.age},name = ${this.name},gender = ${this.gender}");
  }
}

class Teacher extends Human {
  Teacher(int age, String name, String gender) : super(age, name, gender) {
    print(
        "this is a teacher-> age = ${this.age},name = ${this.name},gender = ${this.gender}");
  }
}

打印如下

main(){
    Teacher(57,"王阳明","男");
}
this is a biology
this is a human-> age = 57,name = 王阳明,gender = 男
this is a teacher-> age = 57,name = 王阳明,gender = 男

使用:指定构造函数，如果子类的超类有多个构造函数，使用冒号:来指定子类继承自哪个构造函数

//动物有很多种种类
class Animal {
  String flyAbility;

  String swimAbility;
  //能飞的
  Animal.flyGuy(this.flyAbility);
  //能游的
  Animal.swimGuy(this.swimAbility);
}
//海豚，能游的
class Dolphin extends Animal {
  Dolphin(String swimAbility) : super.flyGuy(swimAbility);
}

类名构造函数只能有声明一个，其他构造函数只能以命名构造函数存在。
如下，Animal类只能有一个类名构造函数Animal(this.flyAbility);，再声明一个新的构造函数IDE报错，编译时不会通过。
```
class Animal {
  String flyAbility;

  String swimAbility;
  
  Animal(this.flyAbility);
  
  Animal.flyGuy(this.flyAbility);

  Animal.swimGuy(this.swimAbility);
  
}
```

构造函数初始化列表
对于一个有参构造，可以在声明代码中使用:去给参数赋值。并且这个初始化的动作的执行顺序是高于超类的构造函数的，下面是个例子

class Student extends Human {
  String studentNum;

  Student(Map<String, dynamic> map)
      : studentNum = map["studentNum"],
        super(map["age"], map["name"], map["gender"]) {
    print(
        "this is a Student-> studentNum = ${this.studentNum}, age = ${this
            .age},name = ${this.name},gender = ${this.gender}");
  }
}

将上面的生物-人类栗子拿一下，创建一个Student类，多了一个成员属性StudentNum，运行结果如下

void main() {
  Map<String, dynamic> map = Map();
  map["name"] = "小明";
  map["age"] = 13;
  map["gender"] = "男";
  map["studentNum"] = "num2333";
  Student(map);
}
this is a biology
this is a human-> age = 13,name = 小明,gender = 男
this is a Student-> studentNum = num2333, age = 13,name = 小明,gender = 男

Student类中并没有进行任何赋值动作，打印的时候studentNum的值已经携带出来了，证明了下面的这个Dart的构造函数执行顺序

构造函数执行顺序
1. 子类构造函数的初始化代码
2. 超类构造函数体
3. 子类构造函数体
构造函数重定向
子类的构造函数，可以指向从一个函数指向另一个构造函数
```
//人类
class Human {
  //姓名
  String name;
  //房子数量
  int houseCount;
  //有钱人有名有房
  Human.richMan(this.name, this.houseCount);
  //穷人房子数量为0，只有名字
  Human.poorGuy(String name) : this.richMan(name, 0);
}
```
抽象一个Human类，抽象出来姓名跟房子数量两个成员变量。
定义一个富人命名函数，一个穷人命名函数。穷人函数重定向富人函数，只是房子数量默认为0(扎心)。
常量构造函数
如果一个类需要一个编译时就决定的常量用来作为基准，例如儿童免票规则的基准是一米二。
```
class FreeTicketStandard {
  //使用常量构造函数创建的一米二身高基准
  static final FreeTicketStandard FREE_STANDARD = const FreeTicketStandard(1.2);
  //身高  
  final double height;
  //必须使用const修饰的构造函数才可以用于创建常量构造函数
  const FreeTicketStandard(this.height);
}
```
现在构造出来了一个用于测量儿童是否有免票资格的基准常量类，但是需要注意的是：
使用这种命名方式，用于常量化的构造函数必须是使用const修饰的构造函数，而且该构造函数中的参数必须是final修饰的成员变量，才可以使用这种方式

工厂构造函数
使用factory实现工厂模式。实际应用场景很多，例如你想要一个类只有限制功能，并且不能由用户手动创建，就可以使用factory配合匿名构造函数来实现。
例如抽象一杯饮料，只有S/M/L的产品卖。价格分别是8,10,12。

class Tea {
  //价格
  String price;
  static const String S_SIZE = "S";
  static const String M_SIZE = "M";
  static const String L_SIZE = "L";
  //工厂构造方法，方法名必须同类名
  factory Tea(String size) {
    switch(size){
      case S_SIZE:
        return Tea._produce("8");
      case M_SIZE:
        return Tea._produce("10");
      case L_SIZE:
        return Tea._produce("12");
      default:
        return null;
    }
  }
  //匿名命名构造函数
  Tea._produce(this.price){
      print("价格是${this.price}");
  }
}

使用factory构造函数必须注意，factory修饰的构造函数的名称必须是该类的类名。

感谢以下文章作者的无私分享
flutter-dart 类的构造函数

HelloDart-构造函数特性

猜你喜欢