一.类和对象:

Dart是一个面向对象的语言，面向对象中非常重要的概念就是类，类产生了对象。

1.类的定义

/**
 * 在Dart中，定义类用class关键字
 * 类通常有两部分组成：成员（member）和方法（method）。
 * 定义类的伪代码如下：
 * class 类名 {
 *   类型 成员名;
 *   返回值类型 方法名(参数列表) {
 *       方法体
 *   }
 * }
 * 
 * 这里有一个注意点: 我们在方法中使用属性(成员/实例变量)时，并没有加this；
 * Dart的开发风格中，在方法中通常使用属性时，会省略this，但是有命名冲突时，this不能省略
 * 
 * 
 * 当类中没有明确指定构造方法时，将默认拥有一个无参的构造方法
 * 下面的Person中我们就是在调用这个构造方法.
 * 我们也可以根据自己的需求，定义自己的构造方法:
 * 注意：**当有了自己的构造方法时，默认的构造方法将会失效，不能使用
 * 1.当然，你可能希望明确的写一个默认的构造方法，但是会和我们自定义的构造方法冲突；
 * 2.这是因为Dart本身不支持函数的重载（名称相同, 参数不同的方式）
 */
main(List<String> args) {
  // var p = Perosn();
  var p = Perosn("ws", 10);
  print(p.name); //ws
  print(p.age); //10
}

class Perosn {
  String name;
  int age;
  //普通构造方法
  // Perosn(String name, int age) {
  //   this.age = age;
  //   this.name = name;
  // }
  //语法糖
  Perosn(this.name, this.age);
}

2.构造方法:

• 普通构造方法/命名构造方法

/**
 * 当类中没有明确指定构造方法时，将默认拥有一个无参的构造方法
 * 下面的Person中我们就是在调用这个构造方法.
 * 我们也可以根据自己的需求，定义自己的构造方法:
 * 注意：**当有了自己的构造方法时，默认的构造方法将会失效，不能使用
 * 1.当然，你可能希望明确的写一个默认的构造方法，但是会和我们自定义的构造方法冲突；
 * 2.这是因为Dart本身不支持函数的重载（名称相同, 参数不同的方式）
 *
 *
 *
 * Object 和dynamic的区别
 * Object调用不属于自己的方法,编译时会报错
 * dynamic调用不属于自己的方法,编译时不会报错 但是运行时会报错
 * 
 * dynamic它是一种类型 是一个明确类型 和 String int等一样
 */
main(List<String> args) {
  //创建person对象
  // var p = Perosn();
  // var p = Perosn("ws", 10);
  var p = Perosn.withNameAgeHeight("ws", 10, 190);
  print(p.toString()); //ws 10 190.0

// Object 和dynamic的区别
  // ws_dynamicAndObjectAction();

  var p1 = Perosn.fromMap({"name": "ws", "age": 29, "height": 1.78});
  //重写tostring之前
  print(p1); //Instance of 'Perosn'
  //重写tostring之后
  print(p1); //ws 29 1.78
}

//Object 和dynamic的区别
ws_dynamicAndObjectAction() {
  // Object obj = "ws1";
  // print(obj.substring(1));//编译时报错
  dynamic obj1 = 123;
  print(obj1.substring(1)); //编译时不报错 运行时报错
}

class Perosn {
  String name = '';
  int age = 0;
  double height = 0;
  // 普通构造方法
  // Perosn(String name, int age) {
  //   this.age = age;
  //   this.name = name;
  // }
  //语法糖
  // Perosn(this.name, this.age);
  // Perosn(this.name, this.age,this.height);

  //命名构造方法
  Perosn.withNameAgeHeight(this.name, this.age, this.height);
  Perosn.fromMap(Map<String, dynamic> map) {
    this.name = map['name'];
    this.age = map['age'];
    this.height = map['height'];
  }
  //重写tostring方法
  @override
  String toString() {
    // TODO: implement toString
    return '$name $age $height';
    // return super.toString();
  }
}

• 初始化列表

main(List<String> args) {}

class Person {
  String name;
  //设置初始值方式1:
  int age;
  // int age = 10;
  //设置初始值方式2:初始化列表
  Person(this.name) : age = 10;
}

• 重定向构造方法

main(List<String> args) {
  var p = Person("ws");
  print('${p.age}  ${p.name}'); // 0  ws
}

class Person {
  String name;
  int age;
  //初始化列表
  // Person(this.name):age = 0;
  //构造函数的重定向
  Person(String name) : this._internal(name, 0);
  Person._internal(this.name, this.age);
}

• 常量构造方法

/**
 * 常量构造方法
 * 在某些情况下，传入相同值时，我们希望返回同一个对象，这个时候，可以使用常量构造方法.
 * ******这里我们使用identical(对象1, 对象2)函数来判断两个对象是否是同一个对象:
 * 
 * 如果将构造方法前加const进行修饰，那么可以保证同一个参数，创建出来的对象是相同的,这样的构造方法就称之为常量构造方法。
 * 
 * 常量构造方法有一些注意点:
 * 注意一：拥有常量构造方法的类中，所有的成员变量必须是final修饰的.
 * 注意二: 为了可以通过常量构造方法，创建出相同的对象，不再使用 new关键字，而是使用const关键字
 * 注意三: 如果是将结果赋值给const修饰的标识符时，const可以省略.
 * 
 * 
 */
main(List<String> args) {
  Dog p = Dog("xh");
  print('name is ${p.name} , age is ${p.age}'); //name is xh , age is 0

  var p1 = Person("ws");
  var p2 = Person("ws");
  print(identical(p1, p2)); //false

  var p3 = const Person("ws");
  var p4 = const Person("ws");
  print(identical(p3, p4)); //true

  const p5 = Person("ws");
  const p6 = Person("ws");
  print(identical(p5, p6)); //true

  final ws = Person("ws");
  final ws1 = Person("ws");
  print(identical(ws, ws1)); //false
}

class Dog {
  String name;
  int age;
  //初始化列表
  // Person(this.name) : age = 10;
  //重定向构造函数
  Dog(String name) : this.initWithData(name, 0);
  //命名构造函数
  Dog.initWithData(this.name, this.age);
}

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

• 工厂构造方法

/**
 * 普通的构造函数:会默认返回创建出来的对象 不需要写return返回值的
 * 工厂构造函数(factory):需要自己手动的返回一个我们的对象
 * 
 * 
 * 工厂构造函数最大的特点:就是可以手动的返回一个对象
 */

main(List<String> args) {
  final s1 = Student("ws");
  final s2 = Student("Ws");
  print(identical(s1, s2)); //false

  final p1 = Person.withName("ws");
  final p2 = Person.withName("ws");
  final p3 = Person.withName("ws3");
  final p4 = Person.withName("ws3");
  print(identical(p1, p2)); //true
  print(identical(p2, p3)); //false
  print(identical(p3, p4)); //true
  print(identical(p1, p2)); //true

  /**
   * 为何使用final修饰对象 而不用var  因为这是命名规范,类似swift 使用let不用var  es6使用const
   * 不用let    就是防止创建的对象被恶意修改
   */
}

class Student {
  String name;
  Student(this.name);
}

class Person {
  String name;
  String color;
  static final Map<String, Person> _nameCache = {};
  static final Map<String, Person> _colorCache = {};

  factory Person.withName(String name) {
    if (_nameCache.containsKey(name)) {
      // return _nameCache[name];
      return _nameCache[name]!;
    } else {
      final p = Person(name, "default");
      _nameCache[name] = p;
      return p;
    }
  }

  factory Person.withColor(String color) {
    if (_colorCache.containsKey(color)) {
      // return _colorCache[color];
      return _colorCache[color]!;
    } else {
      final p = Person("default", color);
      _colorCache[color] = p;
      return p;
    }
  }
  //自定义构造函数
  Person(this.name, this.color);
}

3.类的setter和getter

main(List<String> args) {
  final p = Person();
  //直接访问属性
  p.name = "ws";
  print(p.name); //ws
  print(p.getName); //ws
  //通过setter和getter来访问
  p.setName = "ws1";
  print(p.getName); //ws1
}

class Person {
  String name = "";
  //setter 标准写法
  set setName(String name) {
    this.name = name;
  }
  //setter的箭头函数写法
  // set setName(String name) => this.name = name;

  //getter 标准写法
  String get getName {
    return this.name;
  }
  //getter 箭头函数的写法
  // String get getName => this.name;
}

4.类的继承

Dart中的继承使用extends关键字，子类中使用super来访问父类。

/**
 * 1.父类中的所有成员变量和方法都会被继承,，但是构造方法除外。
 * 2.子类的构造方法在执行前，将隐含调用父类的无参默认构造方法（没有参数且与类同名的构造方法）。
 * 3.如果父类没有无参默认构造方法，则子类的构造方法必须在初始化列表中通过super显式调用父类的某个构造方
 * 法。
 */
main(List<String> args) {
  final p = Person("ws", 29);
  print(p.name); //ws
  print(p.age); //29
}

class Animal {
  int age;
  Animal(this.age);
  Animal.withDate(this.age);
}

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

5.抽象类

抽象类是使用abstract声明的类

/**
 * 抽象类
 * 所以在定义很多通用的**调用接口**时, 我们通常会让调用者传入父类，通过多态来实现更加灵活的调用方式。
 * 但是，父类本身可能并不需要对某些方法进行具体的实现，所以父类中定义的方法,，我们可以定义为抽象方法。
 * 
 * 抽象方法:在Dart中没有具体实现的方法(没有方法体)，就是抽象方法。
 * 1.抽象方法，必须存在于抽象类中。
 * 2.抽象类是使用abstract声明的类
 * 
 * 注意事项:
 * **注意一：**抽象类不能实例化.(不能通过普通的构造函数进行实例化,但是可以通过工厂构造函数进行实例化)
 * **注意二：**抽象类中的抽象方法必须被子类实现, 抽象类中的已经被实现方法, 可以不被子类重写.
 * 
 */
main(List<String> args) {
  // 抽象类不能实例化.
  // final s = Shape();//报错
  //可以使用工厂构造函数实例化
  // final m = Map();
  // final s = Shape();
}

//抽象类
abstract class Shape {
  //只有方法的声明,没有方法的实现
  int ws_getAreaAction();
  //当然也可以有方法的实现
  String ws_getInfoAction() {
    return "形状";
  }

  //工厂构造函数
  // factory Shape() {
  //   // return Shape();//此行代码死循环
  // }
}

//继承于抽象类,必须实现抽象类中的抽象方法
class Rectangle extends Shape {
  @override
  int ws_getAreaAction() {
    return 100;
  }
}

//普通类
class Person {
  //普通类必须有方法的实现
  // void ws_runAction();//报错
}

6.隐式接口

/**
 * Dart中没有哪一个关键字是来定义接口的
 * 没有这些关键字interface/protocol
 * 默认情况下所有的类都是隐式接口
 * Dart只支持单继承
 * 当将一个类当做接口使用时,那么实现这个接口的类,必须实现这个接口中的所有方法
 */
main(List<String> args) {
  final wm = woman();
  wm.ws_runAction(); //跑
  wm.ws_flyAction(); //飞
}

abstract class Runner {
  ws_runAction();
}

abstract class Flyer {
  ws_flyAction();
}

class woman implements Runner, Flyer {
  @override
  ws_runAction() {
    print('跑');
  }

  @override
  ws_flyAction() {
    print('飞');
  }
}

7.Mixin混入

/**
 * Dart中没有哪一个关键字是来定义接口的
 * 
 * 如果混入 父类 和 自己都有相同的方法  执行: 如果自己有就用自己的  自己没有就用混入的  混入没有才用父类的
 */
main(List<String> args) {
  final sm = SuperMan();
  sm.ws_runAction(); //跑 //混入run
  sm.ws_flyAction(); //飞
}

mixin Runner {
  void ws_runAction() {
    print("跑");
  }
}

mixin Flyer {
  void ws_flyAction() {
    print("飞");
  }
}

class Animal {
  ws_eatAction() {
    print("吃");
  }

  void ws_runAction() {
    print("父类跑");
  }
}

class SuperMan extends Animal with Runner, Flyer {
  @override
  void ws_runAction() {
    super.ws_runAction();
    print("混入run");
  }
}

8.类属性和方法

main(List<String> args) {
  var stu = Student();
  stu.name = 'ws';
  stu.sno = 99;
  stu.ws_studyAction();

  Student.time = '8点';
  // stu.time = '8点'; 错误做法, 实例对象不能访问类成员
  Student.ws_attendClassAction();
  // stu.ws_attendClassAction(); 错误做法, 实现对象不能访问类方法
}

class Student {
  //成员变量
  String name = "";
  int sno = 0;
  //静态属性(类属性)
  static String time = "";

  //对象方法
  ws_studyAction() {
    print('$name学习外语');
  }

  //静态方法(类方法)
  static ws_attendClassAction() {
    print('去上外语课');
  }
}

9.枚举类型

枚举也是一种特殊的类, 通常用于表示固定数量的常量值。枚举使用enum关键字来进行定义。

main(List<String> args) {
  final color = Colors.pink;
  switch (color) {
    case Colors.red:
      print("red");
      break;
    case Colors.blue:
      print("blue");
      break;
    case Colors.green:
      print("green");
      break;
    case Colors.pink:
      print("pink");
      break;
    default:
      print('其他颜色');
  }
  print(Colors.values); //[Colors.red, Colors.blue, Colors.green, Colors.pink]
  print(Colors.red.index); //0
  print(Colors.pink.index); //3
}

enum Colors { red, blue, green, pink }