Dart学习笔记-面向对象编程（二）

一、继承、继承中的构造函数

• 键字extends继承一个类
• 子类会继承父类可见的属性和方法，不会继承构造方法
• 子类能够复写父类的方法、getter和setter
• 单继承

class Person {
  String name;
  int age;
  String _birthday;
  
  bool get isAdult => age > 18;
  
  void run(){
    print("Person run...");
  }
}

class Student extends Person{
  
  @override
  bool get isAdult => age > 15;
  
  @override
  void run(){
    print("Student run...");
  }
  
  @override
  String toString(){
    return("Student toString");
  }
  
  void study(){
    print("Student study...");
  }
}

• 继承中的构造方法
• 子类的构造方法默认会调用父类无名无参的构造方法
• 如果父类没有无名午餐的构造方法，则需要显示调用父类构造方法
• 在构造方法参数后使用：显示调用父类构造方法

class Person {
  String name;
  int age;
  String _birthday;
  
  bool get isAdult => age > 18;
  
  Person(this.name);
  Person.withName(this.name);
  
  void run(){
    print("Person run...");
  }
}

class Student extends Person{
  
  Student(String name) : super(name);
}

• 构造方法执行顺序
• 父类的构造方法在子类构造方法体开始执行的位置调用
• 如果有初始化列表，初始化列表会在父类构造方法之前执行

class Person {
  String name;
  int age;
  bool get isAdult => age > 18;
  
  Person(this.name);
  Person.withName(this.name);
  
  void run(){
    print("Person run...");
  }
}

class Student extends Person{
  final String gender;
  Student(String name,String g) : gender = g,super(name);
}

二、抽象类

• 抽象类使用abstract标识，不能直接被实例化
• 抽象方法不用abstract修饰，无实现
• 抽象类可以没有抽象方法
• 有抽象方法的类一定得声明为抽象类

abstract class Person{
  void run();
}

class Student extends Person{
  @override
  void run(){
    print("run...");
  }
}

三、接口

• 类和接口是统一的，类就是接口
• 每个类都隐式定义了一个包含所有实例成员的接口
• 如果是复用已有类的实现，使用继承（extends）
• 如果只是使用已有类的外在行为，使用接口（implements）

class Person {
  String name;
  int age;  
  void run(){
    print("Person run...");
  }
}


class Student implements Person{
  @override
  String name;
  @override
  int age; 
  @override
  void run(){
    print("run...");
  }
}

建议使用抽象类作为接口

abstract class Person{
  void run();
}

class Student implements Person{
  @override
  void run(){
    print("run...");
  }
}

四、Mixins，操作符的覆写

1、Mixins

• Mixins类似于多继承，是在多类继承中重用一个类代码的方式，Mixin不能直接使用，必须配合继承
• 作为Mixin的类不能有显示声明构造函数
• 作为Mixin的类智能继承自Object
• 使用关键字with连接一个或多个mixin

顺序问题

• 如果2个或多个超类拥有相同签名的A方法，那么子类会以继承的最后一个超类中的A方法为准。
• 若子类也重写了改方法也已子类为准
• 优先级顺序是：子类自己实现>Mixin>继承，如果有多个Mixin，则已最后的Mixin为主

class A {
  String getMessage() => 'A';
}
 
class B {
  String getMessage() => 'B';
}
 
class P {
  String getMessage() => 'P';
}
 
class AB extends P with A, B {}
 
class BA extends P with B, A {}
 
class C extends P with B, A {
  String getMessage() => 'C'; //优先级最高的是在具体类中的方法。
}
 
//关系连接：implements实现、extends继承、with混入
class CC extends P with B implements A {
  
} 

  var cc = CC();
  print(cc.getMessage());//=>B

使用mixin进行类组合

abstract class Person{
  String name;
  int age;
  void run();
}


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

//mixin on的使用，使用这个mixin的class必须继承自Animal
mixin Boy on Animal implements  Person{
  @override
  String name;
  @override
  int age;
  @override
  void run(){
    print("Person run...");
  }
  
  void playBall(){
    print("playBall...");
  }
}

mixin Girle implements  Person {
  @override
  String name;
  @override
  int age;
  @override
  void run(){
    print("Person run...");
  }
  
  void dance(){
    print("dance...");
  }
}


class Cat{
  void eat(){
    print("eat...");
  }
}

此时我们可以使用快捷方式组合class

class A = Cat with Girle;

var a = A();
a.run();

2、操作符的覆写

• 操作符覆写
• 覆写需要在类中定义

返回类型 operator操作符（参数1、参数2.....）{
     实现体
     return 返回值
}

class Person {
  int age;
  bool operator > (Person person){
    return this.age > person.age;
  }
}

  var p1= Person();
  p1.age = 18;
  var p2= Person();
  p2.age = 13;
  
  print(p1>p2);//ture