1.类的定义 & 构造函数

class Test{
  String value1;
  String value2;
  Test(this.value1,{this.value2});// zvalue2是可选参数
  // 使用命名构造函数
  Test.createWithValue1AndValue2(this.value1,this.value2);
  // 通过map构造
  Test.fromMap(Map<String,dynamic>map){
    this.value1 = map['value1'];
    this.value2 = map['value2'];
  }
  @override
  String toString(){
    return "$value1 $value2";
  }
}
// 创建
var test = Test.createWithValue1AndValue2("cy","job");
var test1 = Test.fromMap({
  "value1":"test1",
  "value2":"test2"
});

2.类的初始化列表

class Test{
  final String name;
  final String age;
  final String job;
  Test(this.name):age = 10{
    // 执行这里代码则代表Test对象已经初始化完毕
  }
// 如果age是可选值则可以如下
  Test(this.name,{int age},{string job}):thist.age = age ?? 10,this.job = job ?? "student"{// 判断初始化时是否给age赋值，如果没有赋值则给age赋默认值10
    
  }
}

3. 构造函数的重定向

一个类中有两个构造函数,可以调用其他构造函数实现重定向效果

class Test{
  String name;
  int id;
  Test(String name):this._internal(name,0);
  Test._internal(this.name,this.id);
}

var test = Test("cy");
print(test.age);// = > 0

4.常量构造函数

使用const函数进行修饰

class Test{
  final String name;
  const Test(this.name);
}

const test1 = Test("test1");
const test2 = Test("test1");
可以通过identical(test1,test2)进行对比会发现两个对象实际上指向同一内存空间 ->dart优化

5. 工厂构造函数

普通构造函数会默认返回创造出来的对象，不需要写return进行返回
工厂构造函数需要自己手动返回一个对象

常量构造函数一般情况下在类中只有一个，无法满足下列需求：
创建对象时，如果name相同返回对象是同一个对象，job相同返回对象也是同一个

class Test{
  String name;
  String job;
  static final Map<String,Person> _nameCache = {};
  static final Map<String,Person> _jobCache = {};
  Test(this.name,this.job);// 必须要手动实现构造函数
  factory Test.createWithName(String name){
    if(_nameCache.containsKey(name)){// 判断缓存中是否已经存在
      return _nameCache[name];//返回缓存数据
    }
    else{
      final test = Test(name,"默认值");
      _nameCache[name] = test;
      return test;
    }
  }
  factory Test.createWithJob(String job){
    if(_jobCache.containsKey(job)){// 判断缓存中是否已经存在
      return _jobCache[job];//返回缓存数据
    }
    else{
      final test = Test("默认值",job);
      _jobCache[job] = test;
      return test;
    }
  }
}

final test1 = Test.createWithName("cy");
final test12 = Test.createWithName("cy");
identical(test1,test2);
final test1 = Test.createWithJob("job");
final test12 = Test.createWithJob("job");
identical(test1,test2);

工厂构造函数：可以手动返回对象（普通的构造函数不可以）

6. 类的setter和getter

class Test{
  String name;
  // setter
  set setName(String name){
    this.name = name;
  }
  // getter
  String get getName{
    return name;
  }

//箭头函数写法
  set setName(String name) => this.name = name;
  String get getName => name；
}

7. 类中的继承

dart中不支持多继承，只有单继承

class Animal{
  int age;
  Animal(this.age);
}
class Dog extends Animal{
  String name;
  Person(this.name,int age):super(age);
}

8. 抽象类

可以只放类没有实现,但是抽象类不可以实例化

abstract class Test{
  int testFunc1();
  void testFunc2(){
    return "方法二";
  }
}
继承者自抽象类后，必须实现抽象类的抽象方法
class subTest extends Test{
  @override
  void testFunc1(){
    return 10;
  }
}

抽象类不可以实例化,但是可以哦通过工厂构造函数实现实例化效果

abstract class Test{
  int testFunc1();
  void testFunc2(){
    return "方法二";
  }
  factory Test(){
    return subTest;//返回一个子类
  }
}
class subTest extends Test{
  @override
  void testFunc1(){
    return 10;
  }
}

final test = Test();

9.隐式接口

class Ablities{
  void cooking(){}
}
class Car{
  void runing(){}
}

class Person implements Alities,Car{
  //当一个类当做接口使用时，实现这个接口的类必须实现这个接口中的所有方法
// 不可以看调用supper
  @override
  void cooking(){}
  @override
  void running(){}
 }

10.mixin混入

class Person{
  void eating{}
}
mixin Women{
  void babying{}
}
mixin Writer{
  void writing{}
}

class CollegeStudent extends Person with Women,Writer{
  @override
  void eating(){
    super.eating90;
  }
}

final student = CollegeStudent();
student.babying();
student.writing();

11.类属性和类方法

class Person{
  String name;//成员变量
  static String parent;//静态属性（类属性）
  // 对象方法
  void eating(){
    print("eating");
  }
  // 静态方法（类方法）
  static void running(){
    print("快跑");  
  }
}
调用
Person.running();