class Person {
  String name;
  int age;
  final bool? sexy; //final修饰的属性必须有初始值
  String? _hobby; //私有属性外部无法访问
  int? _height;
  static int? num; //静态属性

  //默认构造函数
  // Person();

  //构造函数：在形参的位置，只有构造函数能使用this
  // ： 初始化列表，可以对final修饰的属性赋值，可以进行一些数据的校验
  Person(this.name, this.age) : sexy = true, assert(age >= 0);

  //相当于下面
  // Person (String name, int age) {
  //   this.name = name;
  //   this.age = age;
  // }

  //命名构造函数
  //Flutter中的命名构造函数允许你在一个类中定义多个构造函数，以提供更多的创建对象的选项，使得代码更加灵活和易于维护。
  Person.all(this.name, this.age, this._height, this._hobby) : sexy = true;

  void run() {
    debugPrint('$name 跑起来了');
  }

  void setHobby(String hobby) {
    _hobby = hobby;
  }

  String getHobyy() {
    return _hobby ?? '';
  }

  //私有方法，外部无法访问
  int _getHeight() {
    return _height ?? 0;
  }

  //静态方法
  static addNum(int a) {
    num = num ?? 0 + a;
  }

  //计算属性
  /// 计算属性有以下几点特点：
  /// 它们不存储数据，而是在需要时根据现有数据进行计算。
  /// 计算属性的定义以get关键字开始，后面是属性的名字，没有参数列表。
  /// 计算属性的访问方式与普通属性相同，不需要使用括号。
  int get nianlingChengShengao {
    return age * (_height ?? 0);
  }

  // 操作符
  bool operator >(Person other) {
    return age > other.age;
  }

  @override
  String toString() {
    return 'name: $name, age: $age, height: ${_getHeight()}';
  }
}

Person p = Person('xiaoming', 18);
Person p1 = Person.all('xiaoming', 18, 180, 'basketball');
debugPrint('p.name = ${p.name}, p.age = ${p.age}');
p.run();
debugPrint('------------------------------------');
debugPrint('$p');
debugPrint('------------------------------------');
debugPrint(p.getHobyy());
p.setHobby('basketball');
debugPrint(p.getHobyy());
debugPrint('----------------静态属性和方法--------------------');
debugPrint('${Person.num}');
debugPrint('${Person.addNum(10)}');
debugPrint('${Person.num}');
debugPrint('------------------计算属性------------------');
debugPrint('${p.nianlingChengShengao}');
debugPrint('------------------操作符------------------');
Person p2 = Person('tom', 17);
debugPrint('${p > p2}');

var obj = Object();
obj = Person('xiaoming', 18);

//类型判断
if (obj is Person) {
    obj.run();// xiaoming 跑起来了
}

//强制类型转换
(obj as Person).run();// xiaoming 跑起来了

class Person {
  final String name;
  final int age;
  //当一个对象所有的成员属性都是final的时候，那么这个对象可以被创建为常量对象，使用const修饰构造函数。
  const Person(this.name, this.age);
}

class XYManager {
  static XYManager? _instance;
  //构造函数要想显示返回，需要在前边使用 factory 关键字
  factory XYManager() {
    _instance ??= XYManager._init();
    // if (_instance == null) {
    //   _instance =  XYManager._init();
    // }
    return _instance!;
  }

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

//单例对象的验证
var manager = XYManager();
var manager2 = XYManager();
debugPrint('${manager == manager2}');

class Student extends Person {
  /* Dart中的继承
   * 使用extends继承一个类
   * 子类会继承除了构造方法以外的属性和方法
   * Dart是单继承的
   */

  final int schoolNum;

  Student(String name, int age)
      : schoolNum = 0,
        super(name, age); //super调用需要在初始化列表的最后位置

  Student.allProperty(String name, int age, int height, String hobby)
      : schoolNum = 0,
        super.all(name, age, height, hobby);

  void study() {
    debugPrint('一个名字叫$name的学生，正在学习');
  }

  @override //重写父类方法
  void run() {
    debugPrint('一个名字叫$name的学生，正在奔跑');
  }
}

Student st = Student('xiaoming', 18);
st.run();// 一个名字叫xiaoming的学生，正在奔跑

abstract class Animal {
  String? name;
  //抽象方法
  void makeSound();

  //实例方法:可以作为默认实现
  void run() {
    debugPrint('正在跑动');
  }
}

class Dog extends Animal {
  @override
  void makeSound() {
    debugPrint("汪汪汪！");
  }

  @override
  void run() {
    debugPrint('一只叫$name的狗正在跑动');
  }
}

Dog dog = Dog();
dog.name = 'xiaohei';
dog.makeSound();// 汪汪汪！
dog.run();// 一只叫xiaohei的狗正在跑动