java 泛型四则_第8章 Dart面向对象 -- 类的继承与混入(Mixin)

最新推荐文章于 2022-05-31 17:49:42 发布

Aviationbamboo

最新推荐文章于 2022-05-31 17:49:42 发布

阅读量368

点赞数

文章标签： java 泛型四则

本文链接：https://blog.csdn.net/weixin_34357697/article/details/114227347

版权

继承(extends)是面向对象开发方法中非常重要的一个特征，继承体现着现实世界中“一般”与“特殊”的关系。对于拥有“一般”性质的类我们称之为“父类”或者“超类”，拥有“特殊”性质的类我们称之为“子类”。比如“动物”和“鸟”，动物是一般的概念，鸟是特殊的概念，可以通过“鸟是一种特殊的动物”这句话逻辑是否成立来判断继承关系是否成立。

1. Dart中的继承

与Java语言类似，Dart语言标榜自己为“单继承”，也就是一个类只能有一个直接的父类。如果一个类没有显式地声明父类，那么它会默认继承Object类。此外Dart语言又提供了混入(Mixin)的语法，允许子类在继承父类时混入其他类。关于混入(Mixin)的理解，请参照本章第7节的内容理解。

Dart语言中使用extends作为继承关键字，子类会继承父类的数据和函数。

示例代码：猫类继承动物类

main() {

var a = new Animal();

var b = new Cat();

a.name = "动物";

b.name = "猫";

b.color = "黑色";

a.eat();

b.eat();

b..climb();

}

class Animal{

String name;

void eat(){

print("${name}:进食");

}

class Cat extends Animal{

String color;

void climb(){

print("${color}的${name}:爬树");

}

运行结果

22d2d19c97d8

运行结果

2. 函数重写

重写在面向对象中体现的现实意义是“子类与父类在同一行为上有不同的表现形式”。同Java语言类似，Dart语言也支持函数的重写，子类重写父类的函数后，对象调用的即为子类的同名函数。

演示示例：在第1节的例子的Cat类中重写Animal类的eat函数。

main() {

var a = new Animal();

var b = new Cat();

a.name = "动物";

b.name = "猫";

b.color = "黑色";

a.eat();

b.eat();

b..climb();

}

class Animal{

String name;

void eat(){

print("${name}:进食");

}

class Cat extends Animal{

String color;

@override

void eat(){//子类重写父类的eat方法

print("${color}的${name}:吃鱼");

}

void climb(){

print("${color}的${name}:爬树");

}

运行结果

22d2d19c97d8

运行结果

3. 操作符重写

同C++语言类似，Dart语言支持操作符的重写，常规的四则运算和比较运算符都可以进行重写，其中只有!=不可重写，a!=b相当于!(a==b)的语法糖。

示例代码：

重写了==和+的Rectangle类，当两个对象的width和height一致认为它们是“相等”的，两个Rectangle相加则将两者的width和height进行相加后得到新的Rectangle对象

main() {

var a = new Rectangle(10,10);

var b = new Rectangle(5, 5);

var c = new Rectangle(10, 10);

print(a == b);

print(a == c);

var d = a + b;

print("${a.width}:${a.height}");

print("${d.width}:${d.height}");

print(a == d);

}

class Rectangle{

int width;

int height;

Rectangle(this.width,this.height){}

@override

bool operator ==(dynamic other) {

if(other is! Rectangle){

return false;

}

Rectangle temp = other;

return (temp.width == width && temp.height == height);

}

@override

Rectangle operator +(dynamic other){

if(other is! Rectangle){

return this;

}

Rectangle temp = other;

return new Rectangle( this.width + temp.width, this.height + temp.height);

}

运行结果

22d2d19c97d8

运行结果

4. 抽象类

抽象abstract是面向对象中的一个非常重要的概念，通常用于描述父类拥有一种行为但无法给出细节实现，而需要通过子类来实现抽象的细节。这种情况下父类被定义为抽象类，子类继承父类后实现其中的抽象方法。

同Java语言类似，Dart中的抽象类也使用abstract来实现，不过抽象函数无需使用abstract，直接给出定义不给出方法体实现即可

抽象类中可以有数据，可以有常规函数，可以有抽象函数，但抽象类不能实例化。子类继承抽象类后必须实现其中的抽象函数。

演示示例：Dog类继承Animal抽象类

main(){

var d = new Dog();

d.name = "dog";

d.eat();

d.display();

}

abstract class Animal{

String name; //数据

void display(){ //普通函数

print("名字是:${name}");

}

void eat(); //抽象函数

}

class Dog extends Animal{

@override

void eat() { //实现抽象函数

print("eat");

}

运行结果

22d2d19c97d8

运行结果

5. 接口

Dart语言中没有接口(interface)的关键字，但是有实现(implements)关键字，Dart中可以将类(是否为抽象无关)当做隐式接口直接使用，当需要使用接口时，可以声明类来代替。(个人认为抽象类更适合对接口的理解)

演示示例：

在第4节的示例基础上，添加swimable类和walkable类作为接口使用，Dog类继承Animal类并实现swimable和walkable接口

main(){

var d = new Dog();

d.name = "dog";

d.eat();

d.display();

d.swim();

d.walk();

}

abstract class Animal{

String name;

void display(){

print("名字是:${name}");

}

void eat(); //抽象方法

}

abstract class swimable{ //抽象类作为接口

void swim();

}

class walkable{ //普通类作为接口

void walk(){}

}

class Dog extends Animal implements swimable, walkable{

@override

void eat() {

print("eat");

}

@override

void swim() {

print("swim");

}

@override

void walk() {

print("walk");

}

运行结果

22d2d19c97d8

运行结果

6. 泛型继承

上一章中，提到了泛型编程中的继承问题，在使用泛型编程时也可以使用extends关键字约束输入泛型的类型。

演示示例

被泛型约束的函数，当传入泛型int时，只能计算整数加法，且在声明对象x时泛型只能传入num类型及其子类

main(){

var a = 3;

var b = 3.14;

var c = 4;

var x = DataUtil();

var f = x.addition(a, c);

print(f);

}

class DataUtil{

T addition(T a, T b){

return a+b;

}

运行结果：7

7. 混入(mixin)

本章节内容借鉴了简书用户Vadaski的文章【译】Dart | 什么是Mixin，在此对其表示感谢。

问题

我们来看下面这张关于动物(Animal)，哺乳动物(Mammal)，鸟(Bird)和鱼(Fish)的继承关系图

22d2d19c97d8

继承关系图

这里有一个名为Animal的超类，它有三个子类(Mammal，Bird和Fish)。在底部，我们有具体的一些子类。

小方块代表行为。例如，

黄色方块表示具有此行为的类的实例可以步行(walk)。

蓝色方块表示具有此行为的类的实例可以游泳(swim)。

灰色方块表示具有此行为的类的实例可以飞行(fly)。

有些动物有共同的行为：猫(Cat)和鸽子(Dove)都可以行走，但是猫不能飞。

这些行为与此分类正交，因此我们无法在超类中实现这些行为。

在Java语言中我们可以借助接口(Interface)来实现相关的设计，Dart中也可以利用隐式接口来完成相应的设计。

如果不同的子类在某种行为上表现的都不相同，那么使用接口来实现设计是一种良好的设计。

但如果不同的子类在实现某种行为上有着同样的表现，那么使用接口来实现设计可能会造成代码的冗余。(接口实现强制重写函数)

所以除了上述两种方式，我们也可以利用混入方式(Mixin)来完成相应的设计

实现

对三种行为分别定义三个类描述它们，分别是Walker，Swimmer和Flyer

class Walker {

void walk() {

print("I'm walking");

}

class Swimmer {

void swim() {

print("I'm swimming");

}

class Flyer{

void fly() {

print("I'm flying");

}

如果不想这三个类被实例化，可以使用抽象类+工厂方式定义

abstract class Walker {

factory Walker._() => null;

void walk() {

print("I'm walking");

}

使用混入的关键字是with，它的后面可以跟随一个或多个类名

class Cat extends Mammal with Walker {}

class Dove extends Bird with Walker, Flyer {}

使用时允许Cat和Dove调用Mixin的walk函数，不允许Cat调用未Mixin的Fly函数

main(){

Cat cat = Cat();

Dove dove = Dove();

cat.walk();

dove.walk();

dove.fly();

}

理解

如果Mixin的类和继承类，或者混入的类之间有相同的方法，在调用时会产生什么样的情况，看下面的例子。

演示示例

AB和BA类都使用A和B Mixin继承至P类，但顺序不同。A，B和P类都有一个名为getMessage的方法。

class A {

String getMessage() => 'A';

}

class B {

String getMessage() => 'B';

}

class P {

String getMessage() => 'P';

}

class AB extends P with A, B {}

class BA extends P with B, A {}

void main() {

String result = '';

AB ab = AB();

result += ab.getMessage();

BA ba = BA();

result += ba.getMessage();

print(result);

}

运行结果： BA

为什么会产生这个结果？

Dart中的Mixins通过创建一个新类来实现，该类将mixin的实现层叠在一个超类之上以创建一个新类，它不是“在超类中”，而是在超类的“顶部”，因此如何解决查找问题不会产生歧义。

— Lasse R. H. Nielsen on StackOverflow.'

实际上，这段代码

class AB extends P with A, B {}

class BA extends P with B, A {}

在语义上等同于

class PA = P with A;

class PAB = PA with B;

class AB extends PAB {}

class PB = P with B;

class PBA = PB with A;

class BA extends PBA {}

最终的继承关系如下图所示

22d2d19c97d8

继承关系

很显然，最后被继承的类重写了上面所有的getMessage方法，可以理解为处于Mixin结尾的类将前面的getMessage方法都覆盖(override)掉了

mixin应用程序实例的类型是什么？

通常，它是其超类的子类型，也是mixin名称本身表示的类的子类型，即原始类的类型。

— dartlang.org

所以这意味着这个程序的运行结果全部为true

class A {

String getMessage() => 'A';

}

class B {

String getMessage() => 'B';

}

class P {

String getMessage() => 'P';

}

class AB extends P with A, B {}

class BA extends P with B, A {}

void main() {

AB ab = AB();

print(ab is P); //true

print(ab is A); //true

print(ab is B); //true

BA ba = BA();

print(ba is P); //true

print(ba is A); //true

print(ba is B); //true

}

最后

完整的实现示例

abstract class Animal {}

abstract class Mammal extends Animal {}

abstract class Bird extends Animal {}

abstract class Fish extends Animal {}

abstract class Walker {

factory Walker._() => null;

void walk() {

print("I'm walking");

}

abstract class Swimmer {

factory Swimmer._() => null;

void swim() {

print("I'm swimming");

}

abstract class Flyer {

factory Flyer._() => null;

void fly() {

print("I'm flying");

}

class Dolphin extends Mammal with Swimmer {}

class Bat extends Mammal with Walker, Flyer {}

class Cat extends Mammal with Walker {}

class Dove extends Bird with Walker, Flyer {}

class Duck extends Bird with Walker, Swimmer, Flyer {}

class Shark extends Fish with Swimmer {}

class FlyingFish extends Fish with Swimmer, Flyer {}

Mixin类图

22d2d19c97d8

Mixin类图

Aviationbamboo

关注

0
点赞
踩
0

收藏

觉得还不错? 一键收藏
0
评论
java 泛型四则_第8章 Dart面向对象 -- 类的继承与混入(Mixin)

继承(extends)是面向对象开发方法中非常重要的一个特征，继承体现着现实世界中“一般”与“特殊”的关系。对于拥有“一般”性质的类我们称之为“父类”或者“超类”，拥有“特殊”性质的类我们称之为“子类”。比如“动物”和“鸟”，动物是一般的概念，鸟是特殊的概念，可以通过“鸟是一种特殊的动物”这句话逻辑是否成立来判断继承关系是否成立。1. Dart中的继承与Java语言类似，Dart语言标榜自己为“单...
复制链接

扫一扫

java 泛型 四则_第8章 Dart面向对象 -- 类的继承与混入(Mixin)

“相关推荐”对你有帮助么？

java 泛型四则_第8章 Dart面向对象 -- 类的继承与混入(Mixin)