3.4 Java中继承和组合

码农世界 06-24 153

前言：

而今大家对“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(); }}

输出：