為什麼有 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();
}
複製程式碼可以看出要想會跳舞，必需是動物，必須學會走路。