类创建: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 {
@override
eat(){
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);
// 重写父类的方法
@override
bool get isAdult => (age ?? 0) > 20;
@override
void 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 {
@override
var runValue = 100;
@override
void eat() {
// TODO: implement eat
print("Person 吃了 ${runValue} 个萝卜");
}
@override
void runing() {
// TODO: implement runing
print("Person 跑了 ${runValue} 公里");
}
}
class Tiger extends Run with Eat {
// 抽象类中实现的方法
// 继承抽象类可以不用实现(子类继承父类方法,可以选择是否重新)
@override
void runing() {
// 继承抽象类,可以调用super
super.runing();
print("Tiger runing");
}
// eat 抽象类中需要实现的方法
@override
void 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{
@override
void 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 {
@override
void test3() {
// TODO: implement test3
print("需要实现的 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 {
@override
void mixinTest01() {
// TODO: implement mixinTest01
print("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 {
@override
void init() {
print("Test init start");
super.init();
print("Test init end");
}
}
void main() {
Test();
}
代码运行,执行结果如下图:文章来源:https://www.toymoban.com/news/detail-799128.html
文章来源地址https://www.toymoban.com/news/detail-799128.html
三者可以同时存在于一个类中,前后顺序是:extends>mixins>implements
如果都使用了同一个方法的实现,那么在子类中的这个方法的有效性优先级:mixins>extend>implements, mixins和implements中如果跟了多个,那么后面的会覆盖前面的,没有冲突的,则都会保留,所以会存在后面的会修改掉前面的一部分逻辑代码,不需要直接继承,就可以直接实现覆盖,避免了更复杂的多继承关系。
到了这里,关于[Flutter] extends、implements、mixin和 abstract、extension的使用介绍说明的文章就介绍完了。如果您还想了解更多内容,请在右上角搜索TOY模板网以前的文章或继续浏览下面的相关文章,希望大家以后多多支持TOY模板网!