四.Dart语法学习3

Class学习

Dart 也是一门面向对象的语言，Dart是单继承，根类是Object；使用关键字extends继承，同时也支持mixin(混入)、implements、extension等

类声明 class关键字申明 + 类名 + extends + 父类（extends 可省略，默认继承Object）

class Person extends Object {
  //属性
  String name;
  int age;
  bool gender;

  //构造函数（Constructors）
  Person(this.name, this.age, this.gender);

  // public method
  move() {
    _run();
  }

  // private method
  _run() {
    print("奔跑前行");
  }
}

一般一个类由属性，构造函数，函数（public，private）等构成 Dart中私有函数用_作为前缀

类构造函数

默认构造函数

Dart的class 未定义构造函数的时候，会自动生成一个无参的默认构造函数，并且会调用超类的没有参数的构造函数 。形式是以类名命名的不带参数的构造函数,比如Person 类默认 Person()，一旦我们自己实现了构造函数(普通构造函数，命名构造函数等都算)，这个默认的就会失效；

class Chinese extends Person {
  //默认构造函数（可省略）
  Chinese() : super();
}

普通构造函数

Dart函数没有重载，我们定义一个和类名一样的带参数的构造函数，默认的无参构造函数就失效

 Person(this.name, this.age, this.gender);

//等效
  Person(String name, int age, bool gender) {
    this.name = name;
    this.age = age;
    this.gender = gender;
  }

上边是语法糖形式，两者基本等效，不同的是上边是在对象构造完成前赋值，下边一个是对象构造完成后赋值的
区别：当属性被final关键字修饰时,上边语法糖形式不会报错，下边会报错

class Person {
  //属性
  final String name;
  int age;
  bool gender;

  //构造函数
  // Person(this.name, this.age, this.gender);//不报错

//报错 All final variables must be initialized, but 'name' is not.
  Person(String name, int age, bool gender) {
    this.name = name;
    this.age = age;
    this.gender = gender;
  }

  // public method
  move() {
    _run();
  }

命名构造函数Dart 函数不支持重载，我们可以通过命名构造函数去实现多个构造函数以满足我们的需求。类名.函数的形式

  Person.initWithName(String name) {
     this.name = name;
   }

  Person.initWithGender(bool gender) {
    this.gender = gender;
  }

//调用：
  var p1 = Person.initWithName("Dart");
  var p2 = Person.initWithGender(false);

工厂方法构造函数（factory修饰，return 返回实例；工厂构造函数不能使用this关键字，调用工厂构造函数可以使用关键字new）

官方描述：当你使用factory关键词时，你能控制在使用构造函数时，并不总是创建一个新的该类的对象，比如它可能会从缓存中返回一个已有的实例，或者是返回子类的实例。

场景：

避免创建过多的重复实例，如果已创建该实例，则从缓存中拿出；
调用子类的构造函数(工厂模式 factory pattern)；
实现单例模式.

class Animal {
  String name;
  double weight;
  bool gender;

  Animal.initWithName(String name) : this.initWithNameAndWeight(name, 0.0);
  Animal.initWithNameAndWeight(this.name, this.weight);
  factory Animal(int type, String name) {
    if (type == 0) {
      return Dog.initWithName(name);
    }
    return Cat.initWithName(name);
  }

 factory Animal.getInstance(int type) {
     if (type == 0) {
       return Dog.initWithName("");
     }
     return Cat.initWithName("");
   }
}

class Dog extends Animal {
  Dog.initWithName(String name) : super.initWithName(name);
}

class Cat extends Animal {
  Cat.initWithName(String name) : super.initWithName(name);
}

//调用
void main() {
  var animal = new Animal(0, "旺财");
  var animal1 = new Animal(1, "加菲");
}

单例对象生成

class Singleton  {
  /// 单例对象
  static Singleton _instance;

  /// 内部构造方法，可避免外部暴露构造函数，进行实例化
  Singleton._internal();

  /// 工厂构造方法，这里使用命名构造函数方式进行声明
  factory Singleton.getInstance() {
    if (_instance == null) {
      _instance = Singleton._internal();
    }
    return _instance;
  }
}

常量构造函数（使用常量构造器创建两个相等的编译时常量，它们会指向同一个对象）

如果你的类需要成为永远不会更改的对象，则可以使这些对象成为编译时常量。定义const构造函数要确保所有实例变量都是final

常量构造函数需以const关键字修饰
const构造函数必须用于成员变量都是final的类
构建常量实例必须使用定义的常量构造函数
如果实例化时不加const修饰符，即使调用的是常量构造函数，实例化的对象也不是常量实例


class ConstObject {
  final String name;
  final String des;
  const ConstObject(this.name, this.des);
}

//使用
void main() {
  var c1 = const ConstObject("小名", "小名来自浙江省杭州市");
  var c2 = const ConstObject("小名", "小名来自浙江省杭州市");
  var c3 = ConstObject("小名", "小名来自浙江省杭州市");
  var c4 = const ConstObject("小名1", "小名来自浙江省杭州市");
  print(identical(c1, c2));//true
  print(identical(c1, c3));//false 因为c3没有 调用const修饰 构造函数
  print(identical(c1, c4));//false 因为c4中常量变量跟c1不完全一致，所以也不是生成一个对象
}

构造函数注意：

初始化列表

Animal(String name, double weight): name = name,weight = weight,gender = false;

初始化列表会在初始化构造方法体执行之前执行

用逗号隔开

常用来设置final修饰变量的值

一旦我们实现了构造函数，默认无参命名函数就会失效，我们的子类定义的构造函数必需显示调用父类自定义的构造函数

class Animal {
  String name;
  Float weight;
}

class Dog extends Animal {
//这里正确的。不报错。因为等价 Dog.initWithName(String name) : super();
  Dog.initWithName(String name);
}

下面是错误的

The superclass 'Animal' doesn't have a zero argument constructor.
Try declaring a zero argument constructor in 'Animal', or explicitly invoking a different constructor in 'Animal'

class Animal {
  String name;
  double weight;
  Animal(this.name, this.weight);
 Animal.initWithName(this.name);
}

class Dog extends Animal{
  Dog.initWithName(String name);
}

因为默认无名无参构造函数失效了。子类Dog构造函数的时候需要显示调用父类构造函数即可

 Dog.initWithName(String name) :super(name,0.0);
//或者
 Dog.initWithName(String name) : super.initWithName(name);

构造函数重定向

可能两个构造函数有相同的实现，这时候我们转发一下；一个可重定向函数的函数体是空的，同时构造函数的调用是在冒号之后的。

  Animal.initWithName(String name) : this.initWithNameAndWeight(name,0.0);
  Animal.initWithNameAndWeight(this.name, this.weight);

类的 setter getter函数

get()和set()方法是Dart 语言提供的专门用来读取和写入对象的属性的方法。
每一个类的实例，系统都隐式的包含有get()和set() 方法。也可以自己手动实现set get函数


  set name1(String info) => this.name = name;
  get name1 => this.name;

    //使用
    void main() {
      var animal = new Animal.initWithName("旺财");
      print(animal.name1);//旺财
      animal.name1 = "大黄";
      print(animal.name1);//大黄
  }

下一节会将extends mixin implements extension等知识点

四.Dart语法学习3

Class学习

类声明 class关键字申明 + 类名 + extends + 父类（extends 可省略，默认继承Object）

类构造函数

类的 setter getter函数

类声明 `class`关键字申明 + `类名` + `extends` + `父类`（extends 可省略，默认继承Object）