Dart入门05 -- 私有成员，静态成员，继承，抽象类，隐式接

私有成员

• 在Java中有public，private，protected这些访问修饰符，可控制类class成员的访问权限，在Dart中没有这些访问修饰符，属性成员可通过下划线_，表明该属性是类class的私有成员，外界不能直接访问，只能通过方法访问，注意这里涉及到两个单独文件之间的访问；
• person类文件，代码如下：

class Person {
  String name;
  int age;
  //私有成员
  double _weight;

  //其中age为可选参数
  Person.init(this.name, this.age, this._weight);

  //使用set,get关键字的setter，getter方法
  set setName(String name) {
    this.name = name;
  }

  String get getName {
    return this.name;
  }

  double get getWeight {
    return this._weight;
  }
}

• main函数文件，代码如下：

import 'person.dart';

void main(List<String> args) {
  Person person1 = Person.init("cccc", 26, 125.5);
  //_weight 是私有成员 不能直接访问
  print(person1.getWeight);
}

静态成员

• 使用 static关键字来定义静态成员，包括 静态属性和静态函数方法；
• 静态成员 通过类名来调用；

void main(List<String> args) {
  Car car = new Car("bsj", 12500.0);
  //静态属性
  Car.speed = 125.6;
  //实例方法 调用者为实例对象
  car.run();
  //静态方法 调用者为类名
  Car.walk();
}

class Car {
  String name;
  static double speed;
  double weight;

  Car(this.name, this.weight);

  void run() {
    print("run");
  }

  static void walk() {
    print("walk");
  }
}

类的继承

• Dart中继承使用extends关键字，子类中使用super访问父类，不支持多继承；
• 父类中的所有成员变量和方法都会被继承，但是构造方法除外；
• 重写方法最好加上 @override 注解；
• 子类的构造方法在执行前，会隐式调用父类的无参数默认构造函数(没有参数且与类同名的构造方法)；
• 如果父类没有无参数默认构造函数，则子类的构造函数必须在初始化列表中通过super显式调用父类的某个构造函数，完成父类中属性的初始化；

main(List<String> args) {}

class Animal {
  int age;

  Animal(this.age);
}

class Person extends Animal {
  String name;
  
  //必须完成父类属性age的初始化 在初始化列表中完成
  Person(this.name, int age) : super(age);
}

抽象类

• 用abstract关键字修饰的类，称之为抽象类；
• 在Dart中没有具体实现的方法，称之为抽象方法；
• 抽象方法必须存在于抽象类中，抽象方法没有abstract关键字进行修饰，但是Java中可以，Java中的抽象类与抽象方法均可使用abstract关键字进行修饰，这是两者之间的区别；

void main(List<String> args) {
  Circle circle = new Circle();
  circle.draw();
  circle.show();
}

abstract class Shap {
  void draw();
  void show() {
    print("show");
  }
}

//Circle必须实现draw 抽象方法 否则会报错
class Circle extends Shap {
  @override
  void draw() {
    print("绘制圆形");
  }
}

• 抽象类不能实例化；
• 继承抽象类的子类 必须实现抽象类中定义的抽象方法，否则会报错；

main(List<String> args) {
  //抽象类不能实例化
  final s = Shape();

  //Map是系统的一个抽象类
  //Map能实例化 是因为Map内部实现了一个工厂构造函数 external factory Map()
  final map = Map();
  print(map.runtimeType);
}

//Shape是一个抽象类
abstract class Shape {
  //getArea是抽象方法 没有实现体的 由子类去实现
  void getArea();
}

//继承抽象类的子类 必须实现抽象类中定义的抽象方法
class Rectanle extends Shape {
  @override
  void getArea() {
    print("画矩形");
  }
}

• Map是系统的一个抽象类，其能实例化 是因为Map内部实现了一个工厂构造函数 external factory Map()；

隐式接口

• 在Dart中接口比较特殊，没有一个专门的关键字来声明接口；
• 默认情况下，定义的每个类都相当于默认也声明了一个接口，可称之为隐式接口，可以由其他类来实现，因为Dart不支持多继承；
• 类可通过implements关键字，将其他类当成接口，来实现其他类中定义的方法；
• 在开发中，我们通常将用于给别人实现的类 声明为抽象类；

main(List<String> args) {
  
}

class Animal {
  void eat() {
    print("eat");
  }
}

class Runnner {
  void run() {
    print("run");
  }
}

class Flyer {
  void fly() {
    print("fly");
  }
}

//当将一个类当作接口使用时，那么实现这个接口的类，必须实现这个接口中的所有方法
class Superman extends Animal implements Runnner, Flyer {

  @override
  void eat() {
    // TODO: implement eat
    super.eat();
  }

  @override
  void run() {
    // TODO: implement run
  }

  @override
  void fly() {
    // TODO: implement fly
  }
}

• Superman类继承自Animal，并实现Runnner和Flyer这两个接口，这里Runnner和Flyer本质是类class，可当作接口进行使用；
• 当将一个类当作接口使用时，那么实现这个接口的类，必须实现这个接口中的所有方法；

混入mixin

• 当当前类 实现(implements) 隐式接口类，默认必须实现 隐士接口类中 的所有方法；
• 现在需要 实现 当前类不想再 实现隐式接口类中的 所有方法，可使用混入mixin语法；
• 定义可混入的类时，不能用class关键字，而是使用mixin关键字；
• 当前类使用with进行混入，使用混入时可以使用super关键字；
• 当前类实现接口类 -- 案例代码：

void main(List<String> args) {
  
}

abstract class Runner {
  void run();
}

abstract class Flyer {
  void fly();
}

class Animal {
  void eat() {
    print("Animal eat");
  }
}

//SuperMan实现接口类Runner与Flyer
//必须实现Runner与Flyer中所有方法，否则会报错
class SuperMan extends Animal implements Runner, Flyer {
  @override
  void run() {
    // TODO: implement run
  }

  @override
  void fly() {
    // TODO: implement fly
  }
}

• SuperMan实现接口类Runner与Flyer；

• 必须实现Runner与Flyer中所有方法，否则会报错；

• 当前类with 混入类 -- 案例代码：

void main(List<String> args) {}

mixin Runner {
  void run() {}
}

mixin Flyer {
  void fly() {}
}

class Animal {
  void eat() {
    print("Animal eat");
  }
}

//SuperMan with 混入类Runner与Flyer
//可有选择的实现Runner与Flyer中的方法
class SuperMan extends Animal with Runner, Flyer {
  @override
  void run() {
    // TODO: implement run
    super.run();
  }
}

• SuperMan with 混入类Runner与Flyer；
• 可有选择的实现Runner与Flyer中的方法；
• 使用混入时，Superman实现时可以使用super关键字，调用Runner中的实现；