Dart 基礎之Mixin（混入）

爲何有 Mixin

Mixin(混入)。

有下面一個場景：

狗，鳥，人都是動物。

鳥會飛。

狗會跑，會游泳。

人會跑，會游泳,會飛？

抽象這種場景，對於單繼承語言來講，咱們有接口(interface)，來規範，抽象事物共同的行爲，約束，規範，Dart 雖然沒有 interface 關鍵字，但也不影響。其實現以下：

abstract class Animal {

}

abstract class Run {
  void run() => print("會跑");
}

abstract class Fly {
  void fly() => print("會飛");
}

abstract class Swim {
  void swim() => print("會游泳");
}

class Bird extends Animal implements Fly {
  @override
  void fly() {
    // TODO: implement fly
    //super.run();//編譯報錯，它會認爲抽象類 Fly中的fly()方法是抽象的（真實的並非抽象的），
    print("會飛");
  }
}

class Dog extends Animal implements Run, Swim {
  @override
  void run() {
    // TODO: implement run
    print("會跑");
  }

  @override
  void swim() {
    // TODO: implement swim
    print("會游泳");
  }
}

class Person extends Animal implements Run, Swim, Fly {
  @override
  void fly() {
    // TODO: implement fly
    print("會飛");
  }

  @override
  void run() {
    // TODO: implement run
    print("會跑");
  }

  @override
  void swim() {
    // TODO: implement swim
    print("會游泳");
  }
}

複製代碼

從上面實現代碼來了看，仍是存在問題的，Bird，Dog，PerSon 實現接口的時候都要實現接口裏面的方法，但其實能夠看到 run(),swim()方法都是同樣的。秉着消滅重複代碼的原則來講，接口這種實現仍是有點點問題的。

這裏提一下 Java8 接口裏面的 default 關鍵字。

Java8 以前，接口是不能有實體方法的，可是如今能夠了，它是這麼操做的。

public interface Face {

    default void HelloWorld(){
        System.out.println("Default Hello World ");
    }
}

class FaceImpl implements Face {

}

public class Test {

    public static void main(String[] args) {
        FaceImpl face= new FaceImpl();
        face.HelloWorld();
    }
}

複製代碼

FaceImpl 能夠不用實現 HelloWorld(),而能夠直接調用它，那 default 有啥用？Java8 以前的接口，每當咱們在擴展接口功能的時候，對應接口的實現類也必須重寫實現擴展接口的方法。這時候可能改動就很大。若是這種接口功能的擴展改動就在 SDK 裏面，那改動會至關的大。而 default 打破了 Java 以前版本對接口的語法限制(接口裏面只能有抽象方法  )，從而使得接口在進行擴展的時候，不會破壞與接口相關的實現類代碼。

說這些是爲了更好的認識 Mixin。

在 dart 中，有能更好的實現上面場景的方式：

abstract class Animal {}

mixin Run {
  void run() => print("會跑");
}

mixin Fly {
  void fly() => print("會飛");
}

mixin Swim {
  void swim() => print("會游泳");
}

class Bird extends Animal with Fly {
  @override
  void fly() {
    super.fly(); //合情合理合法
  }
}

class Dog extends Animal with Run, Swim {
  @override
  void run() {
    super.run();
  }

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

class Person extends Animal with Run, Swim, Fly {
  @override
  void fly() {
    super.fly(); //合情合理合法
  }

  @override
  void run() {
    super.run();
  }

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

void main() {
  Person person = new Person();
  person.fly();
  person.run();
  person.swim();
}

複製代碼

可見這種實現方式主要的關鍵字就是 mixin,with。

mixin 能減小代碼冗餘，能在多個類層次結構中複用代碼，相比約束性很強的接口來講顯得更加自由。

minxin 是一種特殊的多重繼承，適用於如下場景:

• 但願爲類提供許多可選功能.

• 但願在許多不一樣的類中使用一個特定的功能.

Mixin 的特色

線性化

若是在兩個 Mixin 模塊都有一個同名方法，這兩個模塊同時混入一個類，那最終調用的會是哪一個模塊的方法呢？寫個代碼跑一下。。。

//Object
class O {
  String getMessage() => "O";
}

mixin A {
  String getMessage() => 'A';
}

mixin B {
  String getMessage() => "B";
}

class AB extends O with A, B {}

class BA extends O with B, A {}

void main() {
  String result1  = "";
  String result2  = "";

  AB ab = AB();
  result1= ab.getMessage();
  print("ab is ${ab is A}");
  print("ab is ${ab is B}");
  print("ab is ${ab is O}");

  BA ba = BA();
  result2 += ba.getMessage();
  print("ba is ${ba is B}");
  print("ba is ${ba is A}");
  print("ba is ${ba is O}");

  print(result1);
  print(result2);
}

複製代碼

輸出

ab is true
ab is true
ab is true
ba is true
ba is true
ba is true
B
A

複製代碼

由此可知:

• with 修飾的會覆蓋 extends 中修飾的同名方法.

• with 列表中後一個模塊功能會覆蓋以前的

Mixin 的 限定

對類的限定

咱們限定行走這種功能行爲只能在動物身上：

class Animal {}

mixin Walk on Animal {
  void walk() {
    print("會走路了");
  }
}

class ZhiWu with Walk {} //這是錯誤的寫法，編譯經過不了

class Person extends Animal with Walk {}

複製代碼

能夠看出 on 關鍵字限定了 Walk 這種功能只能在 Animal 的子類混入。

對功能模塊的限定

有一種場景，相似人要先學會走路，而後慢慢纔會跳舞，也可能一生也不會。。。

class Animal{

}

mixin Walk {
  void walk() {
    print("會走路了");
  }
}

mixin Dance on Animal, Walk {
  void dance() {
    print("竟然會跳舞了");
  }
}

//class Person with Dance {} 錯誤的寫法，編譯不經過

//class Person with Walk, Dance {} 錯誤的寫法，編譯不經過

class Person extends Animal with Walk, Dance {}

void main() {
  Person person = new Person();
  person.walk();
  person.dance();
}


複製代碼

能夠看出要想會跳舞，必需是動物，必須學會走路。

小結

mixin: 定義了功能模塊。

on： 限定了功能模塊的使用類型。

with: 負責功能模塊的組合。