Dart中的单例 四种模式

import 'dart:convert';


/*


设计模式(如单例)的多个实现方式
Dart中的单例
  工厂构造Factory constructor
  静态变量Static field with getter
  静态变量Static field
  常量和工厂构造constconstructor & factory


 */
//工厂构造 Factory constructor
class FactoryManage {
  FactoryManage._f();
  static final FactoryManage _manage = FactoryManage._f();
  factory FactoryManage() {
    print('factory');
    return _manage;
  }
}

//静态变量 Static field with getter
class StaticFun {
  StaticFun._privateConstructor();
  static final StaticFun _instance = StaticFun._privateConstructor();
  static StaticFun get instance {
    print(2);
  }
}

//静态变量 Static field
class StaticTion {
  StaticTion._privateConstructor();
  static final StaticTion instance = StaticTion._privateConstructor();
}

//常量和工厂构造 const constructor & factory
class ConstTion {
  factory ConstTion() => const ConstTion._internal_();
  const ConstTion._internal_();
}

main() {
  //静态成员无需实例即可进行访问
  // print(Person.name);
  // Person.show();

  //继承类
  // B c=new B('jack',12,'男');
  // c.run();
  // c.getInfo();
  //抽象类
  // E  f=new E();
  // f.run();
  // f.eat();
  //接口
  Mysql mysql = new Mysql('uri');
  mysql.add('+++++');
  // FactoryManage a = FactoryManage(); //工厂构造
  // StaticFun b = StaticFun.instance; //静态变量
  // StaticTion c = StaticTion.instance; //静态变量
  // ConstTion d = new ConstTion();
}

/*
 静态成员：使用static关键字实现类级别的函数和变量，静态方法不能访问非静态成员
  类的继承：子类通过extends关键字来继承父类，子类不能重写父类的getter和setter，类初始化之后super意思是子类构造函数传递给父类中，子类重写父类的方法添加@override
  抽象类：抽象类主要用abstract关键字定义，dart中抽象方法不能使用abstract声明dart中没有方法体的方法称为抽象类，
  接口：dart中普通类和抽象类都可以作为接口被实现，还有implements关键字实现

 */
//静态成员
class Person {
  //用Static关键字声明静态成员
  static var name = 'jack';
  var sex = '女';
  static void show() {
    //静态方法可以访问静态成员，但是不可以访问非静态成员呢
    print(name);
  }

  void getInfo() {
    //  非静态方法可以访问静态和非静态成员
    show();
    print(name);
    print(this.sex);
  }
}

//继承类
class A {
  String name;
  num age;
  A(this.name, this.age);
  void getInfo() {
    print("${name}----${age}");
  }

  demo() {
    print('${name}-------');
  }
}

class B extends A {
  String sex;
  //super 关键字吧 name，age传递给父类
  B(String name, num age, String sex) : super(name, age) {
    this.sex = sex;
  }
  run() {
    print("${this.name}---${this.age}--${this.sex}");
    super.demo(); //直接掉父类方法
  }
}

//抽象类  抽象类无法直接被实例化
abstract class D {
  eat(); //抽象方法
  run() {
    print('我是抽象类里面的普通方法');
  }
}

class E extends D {
  @override
  eat() {
    print('吃吃吃');
  }
}

//接口
abstract class Db {
  String uri;
  add(String data);
  save();
  delete();
}

class Mysql implements Db {
  @override
  String uri;
  Mysql(this.uri);
  @override
  add(data) {
    print('add方法');
  }

  @override
  delete() {
    return null;
  }

  @override
  save() {
    return null;
  }
}