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