本文主要是介绍[Flutter] extends、implements、mixin和 abstract、extension的使用介绍说明，希望对大家解决编程问题提供一定的参考价值，需要的开发者们随着小编来一起学习吧！
类创建：abstract（抽象类）、extension（扩展）
1.abstract（抽象类）
- dart 抽象类主要用于定义标准，子类可以继承抽象类，也可以实现抽象类接口。
- 抽象类通过abstract 关键字来定义。
- 抽象类不可以被实例化，只有继承他的子类可以。
- 子类继承抽象类必须实现里面的抽象方法。
- 抽象类作为接口，必须实现抽象类里面的所有属性和方法。
- 多态就是父类定义一个属性或者方法，父类不去实现，让子类去实现，这就叫多态。
/** 定义一个Animal 类要求它的子类必须包含eat方法 */abstract class Animal {eat(); //抽象方法 子类中必须实现printInfo(){print('我是一个抽象类中的普通方法');}
}class Dog extends Animal {@override //覆写抽象父类的方法eat(){print('小狗在吃骨头');}
}class Cat extends Animal {@overrideeat(){print('小猫在吃🐟');}
}main(){Dog d = new Dog();d.eat(); //小狗在吃骨头d.printInfo(); //我是一个抽象类中的普通方法Cat c = new Cat();c.eat(); //小猫在吃🐟
}
2.extension（扩展）
关键词:on 表示针对某一类型的扩展，针对某一类型的实例化对象可以直接调用方法使用。
为现有类扩展没有的方法。
举例：
extension TextOverflowUtil on String {String toCharacterBreakStr() {if (isEmpty) {return this;}var breakWorkds = '';for (var element in runes) {breakWorkds += String.fromCharCode(element);breakWorkds += '\u200B';}return breakWorkds;}
}
使用：
//引入拓展文件地址
import 'package:**************_ext.dart';......Text((title ?? "--").toCharacterBreakStr(),style: HYXStyles.blacksBold15,overflow: TextOverflow.visible,),类引入：extends（继承）, implements（接口实现）, mixin(混入)
1.extends（继承），在flutter中继承是单继承。
- 子类重写超类的方法要用@override
- 子类调用超类的方法要用super
- 子类会继承父类里面可见的属性和方法，但是不会继承构造函数
- 子类能复写父类的getter 和 setter 方法
- 子类可以继承父类的非私有变量
class Person {String? name;int? age;Person(this.name, this.age);//思想是私有的，使用_thought 对子类不可见String? _thought;//计算这个人类是否成年bool get isAdult => (age ?? 0) >= 18;void run() {print("运行 person 类了");}
}class Student extends Person {// 子类的构造函数，并使用super 调用了超类的方法, name 必传，age 可以为空, {int? age} 可选的意思Student(String name, {int? age}) : super(name, age);// 重写父类的方法@overridebool get isAdult => (age ?? 0) > 20;@overridevoid run() {// 如果把这里注释掉，就无法调用到超类的run() 方法了。super.run();print("运行 student 类了");}// 子类自己的方法void studentRun() {print("运行 studentRun 类了");}
}
继承的局限在于：在flutter中只能单继承，灵活度不高。所以有后面的这两个implements、和mixin来弥补。
2. implements（接口实现）
可多个接口实现（任何单独的都很苍白，对比才能更立体）。规范定义一个系统的属性和方法的命名，具体实现需要在每一个具体的类中体现，且子类需要全部实现implements后的类的所有属性和方法。结合抽象类示例：
abstract class Run {var runValue;void runing() {print("runing");}
}abstract class Eat {void eat();
}class Person implements Run, Eat {@overridevar runValue = 100;@overridevoid eat() {// TODO: implement eatprint("Person 吃了 ${runValue} 个萝卜");}@overridevoid runing() {// TODO: implement runingprint("Person 跑了 ${runValue} 公里");}
}class Tiger extends Run with Eat {// 抽象类中实现的方法// 继承抽象类可以不用实现（子类继承父类方法，可以选择是否重新）@overridevoid runing() {// 继承抽象类，可以调用supersuper.runing();print("Tiger runing");}// eat 抽象类中需要实现的方法@overridevoid eat() {print("Tiger eat");}
}void main() {Person person = Person();person.runing();person.eat();Tiger tiger = Tiger();tiger.runing();tiger.eat();
}
接口的局限在于：一个子类必须全部实现所有的属性和方法。mixin可以解决这个问题
3.mixin（混入），在现有类的基础上，引入一些新的变量。
- 作为mixins 的类只能继承自object，不能继承其他的类。
- 作为mixins 的类不能有构造函数。
- 一个类可以mixins 多个mixin 类。
- mixins 不是继承，也不是接口，而是一种全新的特性。
关键字：
with：子类混入某个类的时候使用
class MixinModel with TextMixin{}on：定义基于某个类型的mixin
mixin TextMixin1 on BaseMixin{}最基础的mixin：
// mixin 本身可以是抽象的，可以定义各种方法和属性，等待后续类去实现
mixin TextMixin {
// 定义属性var mixinValue = 2;// 抽象方法void mixinTest01();void mixinTest02() {print("mixinTest02 的输出");}
}class MixinModel with TextMixin{@overridevoid mixinTest01() {// 该函数mixin 定义未实现，混入对象，必须要实现print("mixinTest01 需要实现此方法: ${mixinValue}");}}void main(){MixinModel model = MixinModel();model.mixinTest01();model.mixinTest02();print("mixinValue 调用的输出: ${model.mixinValue}");
}
运行结果：
mixin 本身可以是抽象的，可以定义各种的方法和属性，等待后续的类去实现
on 关键字，基于某个类型的mixin
当使用on 关键字（限定类型），则表示该mixin 只能在那个类的子类中使用，这就代表了mixin 中可以调用那个类的方法和属性。
class BaseMixin {void method() {print("method 的输出");}
}mixin TextMixin1 on BaseMixin {void test1() {print("test1");}int testValue = 2;void test2() {method();}void test3();
}class Test extends BaseMixin with TextMixin1 {@overridevoid test3() {// TODO: implement test3print("需要实现的 test3");}}void main() {Test test = Test();test.test1();test.test2();test.test3();print(test.testValue);
}
运行上面代码：
多个mixin
前面我们学习了简单的mixin，mixin 的限定on 关键字，现在我们来看一下，多个mixin 是怎么实现的。
mixin TextMixin1 {
// 定义属性var mixinValue = 1;// 抽象方法void mixinTest01();void mixinTest02() {print(" TextMixin1 中 mixinTest02 的输出");}
}mixin TextMixin2 {
// 定义属性var mixinValue = 2;void mixinTest03() {print("TextMixin2 中 mixinTest03 的输出");}
}class Test with TextMixin1, TextMixin2 {@overridevoid mixinTest01() {// TODO: implement mixinTest01print("TextMixin1 中的抽象方法 mixinTest01 的实现");}
}void main() {Test test = Test();test.mixinTest01();test.mixinTest02();test.mixinTest03();print(test.mixinValue);
}
运行上面的代码，输出结果如下图：
mixin 怎么实现多继承
dart 是单继承的语言，但是有些时候，我们也需要实现多继承的关系，既然mixin 是dart 语言中的一种新特性，那么我们该怎么使用mixin 来实现多继承的关系呢？这里将揭晓答案，请看代码：
class BaseMixin {void init() {print("BaseMixin init");}BaseMixin() {init();}
}mixin TextMixin1 on BaseMixin {void init() {print("TextMixin1 init start");super.init();print("TextMixin1 init end");}
}mixin TextMixin2 on BaseMixin {void init() {print("TextMixin2 init start");super.init();print("TextMixin2 init end");}
}class Test extends BaseMixin with TextMixin1, TextMixin2 {@overridevoid init() {print("Test init start");super.init();print("Test init end");}
}void main() {Test();
}
代码运行，执行结果如下图：
三者可以同时存在于一个类中，前后顺序是：extends>mixins>implements
如果都使用了同一个方法的实现，那么在子类中的这个方法的有效性优先级：mixins>extend>implements, mixins和implements中如果跟了多个，那么后面的会覆盖前面的，没有冲突的，则都会保留，所以会存在后面的会修改掉前面的一部分逻辑代码，不需要直接继承，就可以直接实现覆盖，避免了更复杂的多继承关系。
这篇关于[Flutter] extends、implements、mixin和 abstract、extension的使用介绍说明的文章就介绍到这儿，希望我们推荐的文章对编程师们有所帮助！
