定义
字面意思理解成混合，它可以混合多个类，达到多继承的效果。
当继承多个mixin，mixin内重写覆盖了同一个方法，则调用方法时会命中最后with的mixin对应的方法。如果需要链路调用，使用super。
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
| mixin A {
test() {
print('A');
}
}
mixin B {
test() {
print('B');
}
}
class C {
test() {
print('C');
}
}
class D extends C with A, B {}
class E extends C with B, A {}
main() {
D d = D();
d.test();
E e = E();
e.test();
}
output:
B
A
class D extends C with A, B {}
可以理解成：
class CA = C with A;
class CAB = CA with B;
class D extends CAS {}
所以输出结果为B
class E extends C with B, A {}
class CB = C with B;
class CBA = CB with A;
class E extends CBA;
所以输出结果为A
|
on
on关键字用来限制mixin的使用，这个mixin只能使用在on指定的类或者其子类。
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
| abstract class Base {
a() {
print("base a()");
}
b() {
print("base b()");
}
c() {
print("base c()");
}
}
mixin A on Base {
a() {
print("A.a()");
}
b() {
print("A.b()");
super.b();
}
}
mixin A2 on Base {
a() {
print("A2.a()");
super.a();
}
}
class B extends Base {
a() {
print("B.a()");
super.a();
}
b() {
print("B.b()");
super.b();
}
c() {
print("B.c()");
super.c();
}
}
class G extends B with A, A2 {
}
testMixins() {
G t = new G();
t.a();
t.b();
t.c();
}
output：ß
A2.a()
A.a()
A.b()
B.b()
base b()
B.c()
base c()
|
参考