1 class 类

(1) 构造函数

当class没有自定义构造函数时，系统会默认生成无参的构造函数；
如果class自定义了构造函数，那么默认构造函数为Person()就会被覆盖，不能使用了；
Dart中不允许函数重载, 要实现多个构造函数, 可采用命名构造函数 ```dart void main(List args) { var p1 = Person.fromMap({ “name”: “liLei”, “age”: 18, “height”: 1.88, }); print(p1); }

class Person { String? name; int? age; double? height;

Person(String name, int age, double height) { this.name = name; this.age = age; this.height = height; } // 语法糖, 和上面等价 Person(this.name, this.age, this.height); // 命名构造函数, 可以避免函数重载, 实现多个构造函数 Person.withNameAgeHeight(this.name, this.age, this.height); Person.fromMap(Map map) { this.name = map[‘name’]; this.age = map[‘age’]; this.height = map[‘height’]; }

@override String toString() { return “$name $age $height”; } }

<a name="Ih365"></a>
## (2) 初始化列表
```dart
void main(List<String> args) {
  var p1 = Person("why");
  print(p1);
}
class Person {
  final String name;
  final int age;  // 声明为常量
  // 初始化列表
  Person(this.name, {int? age}): this.age = age ?? 10 {
  }
}

(3) 常量构造函数

如果将构造方法前加 const进行修饰, 那么可以保证同一个参数, 创建出来的是同一个对象

void main(List<String> args) {
  var p1 = Person("why");  // 默认是new出来的
  var p2 = Person("why");
  print(identical(p1, p2));  // false
  var p3 = const Person("why");  // 要特别指明用const创建对象
  var p4 = const Person("why");
  print(identical(p3, p4));  // true
  const p5 = Person("why");  // 要特别指明是const对象
  const p6 = Person("why");
  print(identical(p5, p6));  // true
}
class Person {
  // 拥有常量构造方法的类中，所有的成员变量必须是final修饰的.
  final String name;
  // 初始化列表
  const Person(this.name);
}

(4) 工厂构造函数

普通的构造函数，会默认返回创建出来的对象，而工厂构造函数，需要手动返回一个对象
工厂构造函数不需要每次构建新的实例，且不会自动生成实例, 而是通过代码来决定返回的实例对象；
工厂构造函数类似于 static 静态成员，无法访问 this 指针；一般需要依赖其他类型构造函数； ```dart

main(List args) { var p1 = Person(‘why’); var p2 = Person(‘why’); print(identical(p1, p2)); // true }

class Person { String name;

// static表示类属性 static final Map _cache = {};

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

Person._internal(this.name); }

<a name="rzy0g"></a>
## (5) setter和getter
默认情况下，Dart中类定义的属性是可以直接被外界访问的。<br />但是某些情况下，我们希望监控这个类的属性被访问的过程，这个时候就可以使用setter和getter了
```dart
main(List<String> args) {
  final d = Dog("黄色");
  d.setColor = "黑色";
  print(d.getColor);
}
class Dog {
  String color;
  String get getColor {
    print("getColor");
    return color;
  }
  set setColor(String color) {
    this.color = color;
  }
  Dog(this.color);
}

2 extends 继承

extends可以继承普通类, 也可继承抽象类
只支持单继承, extends后面只能跟一个类
子类不能访问父类私有的方法和属性，
构造函数不能继承 ```dart main(List args) { var a = Animal(11); var b = Person(“ws”, 18); a.run(); b.run(); }

class Animal { int age; Animal(this.age); void run() { print(“animal run”); } }

class Person extends Animal { String name; Person(this.name, int age) : super(age); @override // 注解表示重写, 加不加都行 void run() { print(“people run”); } }

<a name="Gq052"></a>
# 3 with 混入
- with后可以接多个类, 用于实现多继承
- 被mixin指定的类不可以有构造方法
- mixin了多个类，同名方法执行取后mixin的类
```dart
main(List<String> args) {
  var superMan = SuperMan();
  superMan.run();
  superMan.fly();
}
mixin Runner {
  run() {
    print('在奔跑');
  }
}
mixin Flyer {
  fly() {
    print('在飞翔');
  }
}
class SuperMan with Runner, Flyer {
}

4 implements 实现

implements只能实现抽象类
后面可以跟多个抽象类
原来抽象类中所有的方法都必须被重新实现 ```dart // 抽象类一般不能实例化, 抽象类其实就是Go语言的接口 abstract class Shape { void getArea();

// 但可通过工厂构造函数实现实例化 external factory Shape(); // external只声明方法, 要在类的外部实现 }

class Rectangle implements Shape { int? len; // 必须实现抽象类的方法 int getArea() { return 100; } factory Rectangle(){ return Rectangle(); } } ```

前端