Dart 语法（二）

类和对象

• 使用class关键字声明类
• 使用new、构造函数创建一个对象
• 所有对象继承自Object
• Dart中默认生成setter和getter
• 属性和方法通过.访问
• final修饰的属性必须定义初始值，不能被修改
• 对象方法是不能重载的
• 属性、方法名前面添加_变成私有

void main() {
  LGPerson person = LGPerson();
  person.name = 'flutter';
  person.run();
}

class LGPerson{
  final String city = '长沙';
  String? name;
  int? age;

  void run() {
    print('name:$name age:$age');
  }
}

构造函数

• 默认构造函数是()
• 可以通过this进行赋值
• 构造方法中不能return，除非在前面添加factory修饰构造方法
• 使用const修饰构造函数，就变成常量对象
• 当一个对象所有成员属性都是final修饰时，该对象可以被创建为常量对象

void main() {
  // LGPerson person = LGPerson();
  LGPerson person = LGPerson(18,180,'flutter');
  LGPerson person1 = LGPerson.whitName('oc',180);

}

class LGPerson{
  String _name = 'swift';
  int? age;
  final height;

  LGPerson(this.age, this.height,this._name);
  //命名构造函数
  LGPerson.whitName(this._name,this.height);

  void run() {
    print('name:$name age:$age');
  }
}

单例对象

class FactoryClass {
  static FactoryClass? _instace;

  // factory FactoryClass(){
  //   if(_instace == null){
  //     _instace = FactoryClass._init();
  //   }
  //   return _instace!;
  // }

  // factory FactoryClass(){
  //   _instace ??= FactoryClass._init();
  //   return _instace!;
  // }

  // factory FactoryClass(){
  //   return  _instace ??= FactoryClass._init();
  // }

  factory FactoryClass() => _instace ??= FactoryClass._init();

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

初始化列表

• 给final变量赋值，在构造函数之前访问
• 校验传递函数的值

class Person {
  String name;
  int age;
  final height;

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

类方法

• 使用static修饰，不能访问非静态成员

void main(){
  Person.age = 10;
  Person.sum(20);
};

class Person {
  //静态属性
  static int age = 1;
  int currentCount = 0;
  //静态方法
  static int sum(int a){
    return a + age;
  }

  //实例方法
  int sum2(int a){
    return a + currentCount + age;
  }
}

对象操作符

• var修饰动态类型
• as强制转换类型，只在使用了as当前有效，在哪里调用，哪里进行转换
• is判断真实类型

void main(){
  //动态类型
  var p1 = Object();
  p1 = Person();
  //强制转化类型
  (p1 as Person).sum2(10);
 
  if(p1 is Person){
    
  }
}

class Person {
  int currentCount = 0;

  int sum2(int a){
    return a + currentCount;
  }
}

继承

• Dart是单继承
• extends关键字实现继承
• 会继承父类的默认构造方法
• 如果父类含有带有参数或者带有名字的构造方法，必须显性的去实现其中一个构造方法

void main(){
  Tearch t1 = Tearch();
  t1.currentCount = 10;
  t1.name = 'swift';
  t1.sum2(20);
}

class Person {
  int currentCount = 0;
  String? name;

  int sum2(int a){
    return a + currentCount;
  }
  Person(){
    print('Person -- Person');
  }
  Person.init();
}

class Tearch extends Person{
  Tearch.init() : super.init();
  
  int? age;

  //重写父类
  @override
  set name(String? _name) {
    // TODO: implement name
    super.name = _name;
  }
}

抽象类

• 不能被实例化的类，使用abstract修饰抽象类
• 子类继承抽象类，必须重写抽象类的属性和方法的实现
• implements修饰实现多个抽象类
• 类似OC中的协议

abstract class Person1 {
  int sum1(int a);
}

abstract class Person2 {
  int sum2(int a);
}

abstract class Person3 {
  String? name;
}

//多实现抽象类
class Tearch implements Person1,Person2,Person3{

  @override
  int sum1(int a) {
    // TODO: implement sum1
    throw UnimplementedError();
  }

  @override
  int sum2(int a) {
    // TODO: implement sum2
    throw UnimplementedError();
  }

  @override
  set name(String? _name) {
    // TODO: implement name
  }

}

//单继承抽象类
abstract class Person10 {
  int sum10(int a);
  String? age;
}

class Student extends Person10 {
  @override
  int sum10(int a) {
    // TODO: implement sum10
    throw UnimplementedError();
  }

  @override
  set age(String? _age) {
    // TODO: implement age
    super.age = _age;
  }
}

Mixins混入

• 实际上就是多继承
• 混入类中不能有构造方法
• 混入类最好不要有继承

class Person1 {
  int sum1(int a);
}

class Person2 {
  int sum2(int a);
}

class Person3 {
  String? name;
}

//Mixins混入
class Tearch extends Person1 with Person2,Person3{


}

重载操作符operator

• 类似oc中hash

void main(){
  Student s1 = Student(20);
  Student s2 = Student(30);

  print(s1 > s2);
}

class Student {
  int age;

  Student(this.age);

  bool operator > (Student other) => this.age > other.age;
}