Flutter入门（四）Dart面向对象

• Dart 中的类与对象
• Dart 中的构造函数
• Dart的工厂构造函数，单例，初始化列表
• Dart类方法和对象操作符
• Dart的继承
• Dart的抽象类和接口
• DartMixins混入

1.Dart 中的类于对象

void main() {
  //构造函数与类同名
  Person p = Person();
  //当和Person类在同一文件里，Person所有属性和方法都能被访问
  //属性和方法都通过`.`语法访问
  p._study();
  p.name = "MG";
  p.age = 18;
}

class Person {
  String? name;
  int? age;
  //final定义的属性必须定义初始值
  final double height = 181.2;

  void _study() {
    print('$name age:$age, height:$height 学习');
  }

  void toScholl() {
    print('去学校');
  }
  //方法是不能重载的(方法的名称是寻找方法的唯一标识)
  // void toScholl(int a) {
  // }
}

• 使用class关键字声明一个类
• 创建对象可以使用new加上构造函数
• 所有对象都继承object类
• 每一个类会默认生成构造函数，就是类名本身
• Dart中默认会生成getter和setter方法
• 属性和方法都通过.语法访问
• final定义的属性必须定义初始值
• Dart 中对象方法是不能重载的(方法的名称是寻找方法的唯一标识)
• 在名称前加_表示私有，在同一文件下私有是可以被访问的

2.Dart 中的构造函数

class Person {
  final String name;
  final int age;
  //final定义的属性必须定义初始值
  final double height = 181.2;

  //构造函数，外界调用则需要传参数
  // Person(String name, int age) {
  //   //当成员属性和参数名称一样，会导致值赋值不了
  //   // name = name;
  //   _age = age;
  // }
  //作为参数this语法只能在构造函数中使用
  //当一个对象所有的成员属性都是`final`时，那么这个对象可以被创建为常量对象,使用const修饰构造函数
  const Person(this.name, this.age);
  //命名构造函数
  // Person.withName();

  void _study() {
    print('$name age:$age, height:$height 学习');
  }
}

• Dart中自定义了构造函数后，默认构造函数就会失效
• Dart 中当一个对象所有的成员属性都是final时，那么这个对象可以被创建为常量对象，使用const修饰构造函数

3.Dart的工厂构造函数，单例，初始化列表

3.1工厂构造方法，单例

class FactoryClass {
 //需要一个单例
 static FactoryClass? _instances;

 //Dart中构造函数没有返回值,如果需要返回可以添加 Factory 工厂构造方法
 factory FactoryClass()  => _instances ??= FactoryClass._init();

 //私有命名构造函数
 FactoryClass._init();
}

3.2初始化列表

初始化列表作用：

• 给final变量赋值
• 校验传递的值

class Person {
  String name;
  int age;
  final int height;
  
  //用:标识赋值
  Person(this.name, this.age, int h)
      : height = h,
        //校验在打印之前
        assert(h >= 0),
        assert(age >= 0) {
    print('name:$name age:$age, height:$height');
  }
}

4Dart类方法和对象操作符

4.1类方法

class StaticClass {
  //静态属性，外部访问是用类名方法,方法也是同理
  // StaticClass.count
  // StaticClass.sum(10);
  static int count = 1; //在内存中只有一份
  int currentCount = 10;
  //如果是常量也需要用static修饰
  static const String name = "mg";
  //静态方法,静态方法里可以访问静态成员,但是静态方法中不能访问非静态成员
  static int sum(int a) {
    //静态方法中不能访问非静态成员
    // return count + a + currentCount;
    return count + a;
  }

  //实例方法，则是两者都可以访问
  int sum2(int b) {
    return count + b + currentCount;
  }

  //解析：
  //静态成员，静态方法是通过类名访问的，那么这时类的实例可能还没有出来，所以在静态方法中不能访问非静态成员
}

4.2对象操作符

• ?条件运算符
• as类型转换
• is类型判断
• ..级联操作(连缀)

void staticDemo() {
  var s1;
  s1 = StaticClass();
  print(s1.sum2(2));
  s1 = null;
  //在这里执行就会报错，这里我们加上条件运算符号？，就能解决
  // print(s1.sum2(3));
  print(s1?.sum2(3));

  var s2 = Object();
  s2 = StaticClass();
  //由于在声明时s2为Object类型，后又改变为StaticClass，编译器不知道会报错
  //我们采用类型转符as解决，类型转换符只在当下有效
  print((s2 as StaticClass).sum2(2));
  //除此之外我们还能先判断类型is
  if (s2 is StaticClass) {
    // print(s2.sum2(3));
    //级联操作..，采用级联操作返回的是调用者本身，那么我们就能继续再调用，函数式编程
    s2
      ..currentCount = 15
      ..sum2(2);
  }
}

5Dart的继承

• Dart继承使用extends继承一个类
• Dart是单继承
• Dart子类会继承除了构造方法以外的属性和方法

void extendsDemo() {
  Student st = Student.withName("MG");
  //继承子类能访问父类的方法
  st.run();
  st.name = "MG";
  st.age = 18;
  //也不能访问私有属性
  // st._heght = 180
  print(st.isFree); //输出 true
}

class Person {
  String? name;
  int? age;
  int? _height;
  bool get isFree {
    _height ??= 0;
    return _height! < 180;
  }

  Person.withName(String? name);

  void run() {
    print("Person run...");
  }
}

//
class Student extends Person {
  final subName;
  //当父类有自定义构造方法时，子类必须创建
  //初始化列表必须放在super前面
  Student.withName(String? name) : subName = name!, super.withName(name);

  void study() {
    print('认真学习');
  }
  //@override标识复写父类的
  //也可以去掉。不过为了代码可读性建议保留
  @override
  bool get isFree => age! < 19;
}

6Dart的抽象类和接口

• 抽象类不能被实例化
• 抽象类使用abstract修饰

//Dart抽象类
void abstractDemo() {
  //抽象类的好处，直接使用父类的对象，调用子类的方法 --- 多态
  abstractClass as = subClass();
  print(as.sum(10, 20));
}

//抽象类
abstract class abstractClass {
  //没有实现的方法---抽象方法
  //抽象方法必须放在抽象类中
  int sum(int a, int b);
}

//子类继承抽象类
class subClass extends abstractClass {
  //必须实现抽象类中的方法
  @override
  int sum(int a, int b) {
    print('a + b = ${a+b}');
    return a + b;
  }
}

如果想要实现多个抽象类的方法呢？
由于Dart是单继承，就不能使用继承extends了，我们可以采用implements实现,如果使用implements就必须实现类中的所有东西

//Dart抽象类
void abstractDemo() {
  //抽象类的好处，直接使用父类的对象，调用子类的方法 --- 多态
  subClass as = subClass();
  as.sum(10, 20);
  as.sum1(10, 20);
  as.sum2(10, 20);
  as.run();
}

//抽象类
abstract class abstractClass {
  //没有实现的方法---抽象方法
  //抽象方法必须放在抽象类中
  int sum(int a, int b);
}

abstract class abstractClass1 {
  //没有实现的方法---抽象方法
  //抽象方法必须放在抽象类中
  int sum1(int a, int b);
}

abstract class abstractClass2 {
  //没有实现的方法---抽象方法
  //抽象方法必须放在抽象类中
  int sum2(int a, int b);
}

class a {
  String name = '啊';
  run() {
    print('run...');
  }
}

//implements类似于接口
class subClass implements abstractClass,abstractClass1,abstractClass2,a {

  //必须实现抽象类中的方法
  @override
  int sum(int a, int b) {
    print('a + b = ${a+b}');
    return a + b;
  }

  @override
  int sum1(int a, int b) {
    print('a + b = ${a+b}');
    return a + b;
  }

  @override
  int sum2(int a, int b) {
    print('a + b = ${a+b}');
    return a + b;
  }

  @override
  String name = 'a';

  @override
  run() {
    print('run...');
  }
}

7DartMixins混入

void mixinsDemo() {
  //声明一个D的对象
  D d = D();
  //d可以调用a
  d.a();
  //d可以调用b
  d.b();
  //d可以调用c
  d.c();
  //如果A，B，C类中的方法都是同名方法，这里只打印C的方法
  //C是最后一个，会覆盖掉前面的方法
}

class A {
  a() => print('a....');
}
class B {
  b() => print('b....');
}
class C {
  c() => print('c....');
}

//加入with，将B，C二类称作D的混入
class D extends A with B,C {

}

• Mixins用来实现多继承功能的
• 混入的类中有构造方法则不能使用
• 当混入的类继承其他类时，编译器会报错，不过可以运行。原因是怕继承的类有非默认的构造方法