Dart--类静态成员 操作符 类的继承

1.Dart中的静态成员：

（1）使用static关键字来实现类级别的变量和函数

（2）静态方法不能访问非静态成员，非静态方法可以访问静态成员

class Person {
  static String name = '大拿';
  int age = 20;

  static void show() {
    print('name:$name');
  }

  /**
   * 非静态方法可以调用静态成员
   */
  void printInfo() {
    //访问静态属性
    print(name);
    //访问非静态属性
    print(this.age);
    //调用静态方法
    show();
  }
  
  //静态方法
static void printUserInfo() {
    //静态属性
    print(name);
    //静态方法
    show();
    //print(this.age); //静态方法没法访问非静态属性
    //this.printInfo(); //静态方法没法访问非静态方法
  }
}

void main() {
  print(Person.name);
  Person.show();

  //实例化对象
  Person p = new Person();
  p.printInfo();
  Person.printUserInfo();
}

2.Dart中的对象操作符:

? 条件运算符(了解)

as 类型转换

is 类型判断

.. 级联操作(连缀)

class Person {
  late String name;
  late int age;

  Person(this.name, this.age);

  void printInfo() {
    print('name:${this.name},age:${this.age}');
  }
}

void main() {
  //1.？条件运算符
  //在dart高一些版本中，只有可空类型会用到
  Person? p;
  p?.printInfo();
  Person p2 = new Person('Jack', 25);
  p2?.printInfo();

  //2.is类型判断
  if (p is Person?) {
    print('p是Person类型对象');
  }
  //任何类的基类都是Object类
  if (p2 is Object) {
    print('该类的基类是Object');
  }
  if (p2 is Person) {
    p2.name = 'Bob';
    p2.printInfo();
  }

  //3.as类型转换
  var p3;
  p3 = '';
  p3 = new Person('李四', 50);
  (p3 as Person).printInfo();
  //较新的版本这么写也不报错
  // p3.printInfo();
  Person p4;
  p4 = new Person('Cat', 15);
  //一开始就指定了具体类型的，后续就无法赋其他类型的值了
  //p4='';

  //4..级联操作(连缀)
  Person pp = new Person('Rose', 18);
  pp
    ..printInfo()
    ..name = 'Jack'
    ..age = 20
    ..printInfo();
}

3.Dart中类的继承

（1）子类使用extends关键词来继承父类

（2）子类会继承父类里面可见的属性和方法，但是不会继承构造函数(但是可以继承没有参数的构造函数)

（3）子类能复写父类的方法 getter和setter

class Father {
  String name = '';
  int age = 20;

  Father() {
    print('Father');
  }

  void printInfo() {
    print('name:${this.name},age:${this.age}');
  }
}

class Son extends Father {}

void main() {
  Son son = new Son();
  son.printInfo();
}

class Father {
  String name = '';
  int age = 20;

  Father(this.name, this.age);

  void printInfo() {
    print('name:${this.name},age:${this.age}');
  }
}

class Son extends Father {
  String sex = '';

  //super的意思是在执行子类的构造函数之前，把参数赋值给父类的构造函数
  Son(String name, int age, String sex) : super(name, age) {
    print('Son');
    this.sex = sex;
  }

  void run() {
    print('name:"${this.name},age:${this.age},sex:${this.sex}');
  }
}

void main() {
  Son son = new Son('Jack', 25, '男');
  son.printInfo();
  son.run();
}

除了上述给父类的构造函数传参，还可以给命名构造函数传参:

class Father {
  String name = '';
  int age = 20;

  Father(this.name, this.age);

  Father.xxx(this.name, this.age);

  void printInfo() {
    print('name:${this.name},age:${this.age}');
  }
}

class Son extends Father {
  String sex = '';

  Son(String name, int age, String sex) : super.xxx(name, age) {
    print('Son');
    this.sex = sex;
  }

  void run() {
    print('name:"${this.name},age:${this.age},sex:${this.sex}');
  }
}

void main() {
  Son son = new Son('Jack', 25, '男');
  son.printInfo();
  son.run();
}

覆写父类的方法：

class Animal {
  String name = '';
  int age = 1;

  Animal(this.name, this.age);

  void printInfo() {
    print('name:${this.name},age:${this.age}');
  }
}

class Dog extends Animal {
  Dog(super.name, super.age);

  @override
  void printInfo() {
    super.printInfo();
    print('Dog name:${this.name},age:${this.age}');
  }
}

void main() {
  Dog dog = new Dog('Dogger', 30);
  dog.printInfo();
}