前言:
而今大家对“java多继承”大约比较关注,我们都想要学习一些“java多继承”的相关资讯。那么小编也在网络上收集了一些对于“java多继承””的相关内容,希望小伙伴们能喜欢,小伙伴们一起来学习一下吧!这篇文章阐明了Java中继承和组合的概念。首先展示了继承的例子,接着显示如何通过组合来改进继承。最后总结如何在它们之间做选择。
1. 继承
想下,我们有个叫 insert的类,这个类包含两个方法:1) move() 和2)attack().
class Insect { private int size; private String color; public Insect(int size, String color) { this.size = size; this.color = color; } public int getSize() { return size; } public void setSize(int size) { this.size = size; } public String getColor() { return color; } public void setColor(String color) { this.color = color; } public void move() { System.out.println("Move"); } public void attack() { move(); //assuming an insect needs to move before attacking System.out.println("Attack"); }}
现在你需要定义一个Bee类,它是Insert类子类,但是有attack()和move()不同实现。它可以按照继承如下设计:
class Bee extends Insect { public Bee(int size, String color) { super(size, color); } public void move() { System.out.println("Fly"); } public void attack() { move(); super.attack(); }}
public class InheritanceVSComposition { public static void main(String[] args) { Insect i = new Bee(1, "red"); i.attack(); }}
类型继承关系图简单如下:
输出:
FlyFlyAttack
"Fly" 被打印两次,它显示了move()被调用了两次。但是它应该只被调用一次。
问题是由super.attack()方法导致。Insert的attack()方法调用了move()方法。当子类调用super.attack(),它也调用了被覆盖的move()方法。
为了解决这个问题,我们可以: 1、除去子类的attack方法。它将会使子类完全依赖父类实现的attack()方法。如果父类的attack方法在后面被改变了(这不是你所控制的),例如,父类的attack()方法调用另外的方法去移动,子类也需要改变。这是个失败的封装。
2.如下重写attack()方法。
public void attack() { move(); System.out.println("Attack");}
因为子类不再依赖父类信息,所以可以保证结果的正确性。但是,父类的代码是重复的。(想下 attack()方法调用了更复杂的方法二不是仅仅打印一个字符串)它对于软件工程师重用规则来说的时候是不被准许的。
继承设计是不好的,因为子类依赖了父类的实现细节。如果父类改变了,子类也需要改变。
2.组合
在这个例子中,可以用组合而不是继承。让我们先看看组合的解决方案。
attack函数被抽象作为一个接口。
interface Attack { public void move(); public void attack();}
Attack接口可以被定义为多个不同种类的attack实现。
class AttackImpl implements Attack { private String move; private String attack; public AttackImpl(String move, String attack) { this.move = move; this.attack = attack; } @Override public void move() { System.out.println(move); } @Override public void attack() { move(); System.out.println(attack); }}
因为attack函数被抽象了,Insert类将不再与attack有任何关系。
class Insect { private int size; private String color; public Insect(int size, String color) { this.size = size; this.color = color; } public int getSize() { return size; } public void setSize(int size) { this.size = size; } public String getColor() { return color; } public void setColor(String color) { this.color = color; }}
Bee是一个Insert类型,它可以attack。
// This wrapper class wrap an Attack objectclass Bee extends Insect implements Attack { private Attack attack; public Bee(int size, String color, Attack attack) { super(size, color); this.attack = attack; } public void move() { attack.move(); } public void attack() { attack.attack(); }}
类结构图如下:
public class InheritanceVSComposition2 { public static void main(String[] args) { Bee a = new Bee(1, "black", new AttackImpl("fly", "move")); a.attack(); // if you need another implementation of move() // there is no need to change Insect, we can quickly use new method to attack Bee b = new Bee(1, "black", new AttackImpl("fly", "sting")); b.attack(); }}
输出:
flymoveflysting3. 什么使用用它们
下面两点可以指导继承和组合之间的选择:
如果是IS-A关系,一个类想要对另外一个类暴露所有接口,继承看起来是更好的选择。 2.如果是HAS-A关系,组合是更好的选择。
总之,继承和组合都有它们的应用场景,理解它们的关系是值得的。
标签: #java多继承