1、属性、方法

/*
* Dart中默认会生成getter和sett方法
* 属性和方法都是通过.访问
* final修饰的属性必须定义初始值
* dart不支持重载
* 变量或者方法前面添加下划线，为私有属性，同一个文件可以访问，外部文件不可以访问
* */
class Person {
  final String name = 'sj';
  int ?age;
  int ?_height;
  void rum() {
    print('name:$name age:$age');
  }
}

2、构造方法

构造函数可以不写函数体
1、传入this属性的构造函数
Person(this.age, this._height);
2、命名构造函数
Person.whitName(this.age, this._height);
3、当一个对象的所有成员属性都是final的时候，那么这个对象可以被创建为常量对象
(如：final int age, final int _height)
const Person(this.age, this._height);

class Person {
  final String name = 'sj';
  int ?age;
  int ?_height;
  // 1、构造函数
  Person(this.age, this._height);
  Person({this.age, this._height});
  // 2、命名构造函数
  Person.whitName(this.age, this._height);
}

4、初始化列表
校验传递的值

class Person {
  String name;
  int age;
  final height;
  Person(this.name, this.age, int h): height = h, assert(h >= 0) {
      print('name:$name age:$age height:$height');
  }
}

3、单例

class FactoryClass {
  static FactoryClass? _instance;
  // factory 构造函数可以有返回值
  factory FactoryClass() {
    // if(_instance == null) {
    //   _instance = FactoryClass._init();
    // }
    // return _instance!;
    return _instance ??= FactoryClass._init();
  }
  // 可以使用箭头函数
  // factory FactoryClass() => _instance ??= FactoryClass._init();

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

4、static属性和方法

1、..操作符，返回对象(例如 对象..方法 -> 返回当前对象)

class StaticClass {
  // 静态属性
  static int count = 0;
  int currentCount = 10;
  // 静态方法
  static int sum(int a) {
    return a + count;
  }
  // 实例方法
  int sum1(int a) {
    return currentCount + a + count;
  }
}

void staticDemo() {
  // s1为Object
  var s1 = Object();
  s1 = StaticClass();
  // 将s1转换为StaticClass
  if (s1 is StaticClass) {
    print(s1.sum1(10));
    // ..操作符，返回对象
    s1..currentCount = 15..sum1(10);
  } else {
    print((s1 as StaticClass).sum1(10));
  }
}

5、继承

// person.dart
class Person {
  String? name;
  int? age;
  int? _heihgt;
  bool get isFree => _heihgt! < 10;
  run() {
    print("Person run");
  }

  Person(this.age);
  Person.init();
  Person.withName(this.name);
}
// student.dart
class Student extends Person {
  // 如果父类有构造函数，子类要显示的调用
  final String subName;
  // 构造方法需要给subName赋上初始值
  Student():subName = 'sj', super.init();
  Student.withName(String? name): subName= name!, super.withName(name);
  study() {
    print('认真学习');
  }
  @override
  run() {
    print("Student run...");
  }
  @override
  bool get isFree => age! < 18;
  @override
  String toString() {
    // TODO: implement toString
    return "Student extends Person";
  }
}

6、abstruct

abstructDemo() {
  AbstructClass as = SubClass();
  as.sum(10, 20);
}

abstract class AbstructClass {
  // 抽象方法
  int sum(int a, int b);
}

abstract class AbsctructClass1 {
  int sub(int a, int b);
}

class SubClass implements AbstructClass, AbsctructClass1 {
  @override
  int sum(int a, int b) {
    // TODO: implement sum
    print('a + b = ${a + b}');
    return a + b;
  }

  @override
  int sub(int a, int b) {
    // TODO: implement sub
    print('a - b = ${a - b}');
    return a - b;
  }
}

7、Minxin(混入)

/*
* 混入
* 说白了就是多继承
* 作为混入类，是不能实现构造方法的。
* */
mixinDemo() {
  D d = D();
  d.a();
}

class A {
  a() => print("a.....");
}

class B {
  a() => print("b.....");
}

class C {
  a() => print("c.....");
}

class D extends A with B, C {}
class E = A with B,C;

8、操作符重载

operatoDemo() {
  OperatorClass op1 = OperatorClass(10);
  OperatorClass op2 = OperatorClass(20);
  print(op1 > op2);
}

class OperatorClass {
  int age;
  OperatorClass(this.age);
  bool operator > (OperatorClass other) => this.age > other.age;
}