Dart 例子实战 标准构造函数,可选参数,默认参数,初始化列表,命名构造函数,工厂构造函数,命名工厂构造函数,get,set,静态方法,抽象方法,抽象类,泛型,dart编程小技巧

1.标准构造函数,可选参数,默认参数,初始化列表,命名构造函数,工厂构造函数,命名工厂构造函数,get,set,静态方法,抽象方法,抽象类 

//所有的类都继承自Object
class Person {
  String name;
  int age;
  Person(this.name, this.age); //标准构造方法

  @override
  String toString() {
    // 重写了父级的toString的方法
    return "name:$name,age:age";
  }
}

class Student extends Person {
  String _school; //_表示是私有变量
  String city; //城市
  String country; //国家
  String name;

  //如果继承的父类没有默认构造方法(无参数的)，就要调用父类的构造方法
  //:后面的表示式就是初始化列表
  //this._school初始化自由参数
  //name,age交由父级初始化
  //{}里面的就是可选参数，或者用[]
  //=就是默认参数
  //初始化列表多个表示式的时候，用,隔开
  //构造方法有方法体的，用{}
  //这个事标准构造方法
  Student(this._school, name, int age, {this.city, this.country = '中国'})
      : name = "$country-$city",
        super(name, age) {
    print("构造方法体不是必须的");
  }

  //命名构造方法 [类名+.+方法名]
  //可以多个，但是标准构造方法只能一个
  //也可以有方法体
  Student.per(Student stu) : super(stu.name, stu.age);

  //命名工厂构造方法: factory [类名+.+方法名]
  //这种形式不需要把final的变量作为参数，比较灵活
  //如果事上面的模式，有final的变量，必须要初始化
  factory Student.fac(String school, String name, int age) {
    return Student(school, name, age);
  }

  //_school是私有属性，外部访问要公有
  //可以直接实例化的per.school访问
  String get school=>_school;

  //设置的时候，控制修改
  //实例化per.school="123";赋值的时候会调用
  set school(String val){
    _school=val;
  }
 
  //静态方法 方法前加static
  //调用的时候是用[类.方法名]
  static doPrint(String str){
    print("doPring$str");
  }
}

//工厂构造方法
//也可以理解为单例模式
class Logger {
  static Logger _logger;

  Logger._create();

  factory Logger() {
    if (_logger == null) {
      _logger = Logger._create(); //实例化一般用私有的命名构造方法实现
    }
    return _logger;
  }
}

//抽象类和抽象方法(没有实现的方法)
//抽象类里面不一定一定要有抽象方法，但是有抽象方法的类必须是抽象类
//继承抽象类，必须实现抽象方法
abstract class Study{
  void flutterStydy();
}

class FlutterStudy extends Study{
  @override
  //实现抽象方法
  void flutterStydy() {
    print("flutterStydy");
  }

}

final变量没有初始化的错误：

2.mixins 用with连接词

//mixins 是一种重用代码的方式
//with 后面添加名字，多个用 ，分割
//只能继承自Object字类，不能有构造函数，不能调用super
//下面就是一个mixins,可以类，也可以抽象类
abstract class Studys{
  void flutterStydy();
}

class Member extends Person with Studys{

  Member(String name, int age) : super(name, age); //这是继承实现父级构造函数

  //这个是mixins的复用Studys的特性(必须实现抽象类的方法)
  //mixins就是继承类的特性
  @override
  void flutterStydy() {
    // TODO: implement flutterStydy
  }

}

3.泛型

//泛型是解决类，接口，方法的复用性，以及对不特定数据类型的支持
//提高复用性
//T可以实任意类型

class Cache<T> {

  static final Map<String, Object> _cache = Map();

  T getItem(String key){
    return _cache[key];
  }

  void setItem(String key, T value){
    _cache[key]=value;
  }
}

class TestCache{
  void start(){
    Cache<String> c1= Cache();
    Cache<int> c2=Cache();
    c1.setItem("name", "张三");  //值只能是String
    c2.setItem("age", 18); //值只能是int
  }
}

//泛型的类型约束

class GenericMember<T extends Person> {
  T _person;

  GenericMember(this._person);

  String getName() {
    return "Name is ${_person.name}";
  }
}

class TestGenericMember {
  void start() {
    //Student是Person的子类，参考下面
    GenericMember<Student> gm = GenericMember(Student("学校", "名字", 18));
    print(gm.getName()); //Name is 名字
  }
}

//参考：
//所有的类都继承自Object
class Person {
  String name;
  int age;
  Person(this.name, this.age); //标准构造方法

  @override
  String toString() {
    // 重写了父级的toString的方法
    return "name:$name,age:age";
  }
}

class Student extends Person {
  String _school; //_表示是私有变量
  String city; //城市
  String country; //国家
  String name;

  //如果继承的父类没有默认构造方法(无参数的)，就要调用父类的构造方法
  //:后面的表示式就是初始化列表
  //this._school初始化自由参数
  //name,age交由父级初始化
  //{}里面的就是可选参数，或者用[]
  //=就是默认参数
  //初始化列表多个表示式的时候，用,隔开
  //构造方法有方法体的，用{}
  //这个事标准构造方法
  Student(this._school, name, int age, {this.city, this.country = '中国'})
      : name = "$country-$city",
        super(name, age) {
    print("构造方法体不是必须的");
  }

  //命名构造方法 [类名+.+方法名]
  //可以多个，但是标准构造方法只能一个
  //也可以有方法体
  Student.per(Student stu) : super(stu.name, stu.age);

  //命名工厂构造方法: factory [类名+.+方法名]
  //这种形式不需要把final的变量作为参数，比较灵活
  //如果事上面的模式，有final的变量，必须要初始化
  factory Student.fac(String school, String name, int age) {
    return Student(school, name, age);
  }

  //_school是私有属性，外部访问要公有
  //可以直接实例化的per.school访问
  String get school => _school;

  //设置的时候，控制修改
  //实例化per.school="123";赋值的时候会调用
  set school(String val) {
    _school = val;
  }

  //静态方法 方法前加static
  //调用的时候是用[类.方法名]
  static doPrint(String str) {
    print("doPring$str");
  }
}

 4.dart编程小技巧

//封装，继承，多态
//封装要大到类型的封装，类的封装和抽象，小到方法的封装
//封装目的在于提高复用性和可维护性
//不要在一个方法体里面写太多代码，小于100行
//点点点习惯，1.点看类有哪些属性和方法 2.点看源码 3.点看源码里面的其他的引用，看究竟
void skill(){
  // 1.安全的调用 ?.
  List list; //这个list不确定是否存在，你直接调用list.length就会抛异常
  print(list?.length); //这样就不会报错，存在才会访问length

  // 2.设置默认值
  print(list?.length??-1); //list不存在的时候，获取的是-1，存在就取list.length

  //条件判断0,'',null
  list.addAll([0,'',null]);

  //这样固然可以，但是太冗余
  if(list[0] == null || list[0] == 0 || list[0] == ''){
    print('list[0] is empty ');
  }

  //这样就简洁多了，多个也方便添加
  if([null,0,''].contains(list[0])){
    print('list[0] is empty ');
  }

}

也可以参考dart的最佳实践     http://dart.goodev.org/guides/language/effective-dart/usage#section