继承虽然组成？

Question

我做了一些阅读成分通过的Java世界的文章：http://www.javaworld.com/javaworld/jw-11-1998/jw-11-techniques.html?page=1

在这篇文章中，它指导如何做到继承，而不使用extends关键字。我正在那样做。这可以吗？它似乎为我工作。

下面是代码：

的遗传代码的例子：第2页的文章\ 根据这篇文章，它工作正常：

class Fruit { 
    public int peel() { 

      System.out.println("Peeling is appealing."); 
      return 1; 
     } 
    } 

class Apple extends Fruit { 
} 

class Example1 { 

    public static void main(String[] args) { 

     Apple apple = new Apple(); 
     int pieces = apple.peel(); 
    } 
} 

修改后，它不再OK：

class Peel { 

    private int peelCount; 

    public Peel(int peelCount) { 
     this.peelCount = peelCount; 
    } 

    public int getPeelCount() { 

     return peelCount; 
    } 
} 

class Fruit { 

// Return a Peel object that 
// results from the peeling activity. 
    public Peel peel() { 

     System.out.println("Peeling is appealing."); 
     return new Peel(1); 
    } 
} 

// Apple still compiles and works fine 
class Apple extends Fruit { 
} 

// This old implementation of Example1 
// is broken and won't compile. 
class Example1 { 

    public static void main(String[] args) { 

     Apple apple = new Apple(); 
     int pieces = apple.peel(); 
    } 
} 

现在通过组合物重用：

class Fruit { 

// Return int number of pieces of peel that 
// resulted from the peeling activity. 
public int peel() { 

System.out.println("Peeling is appealing."); 
     return 1; 
    } 
} 

class Apple { 

    private Fruit fruit = new Fruit(); 

    public int peel() { 
     return fruit.peel(); 
    } 
} 

class Example2 { 

    public static void main(String[] args) { 

     Apple apple = new Apple(); 
     int pieces = apple.peel(); 
    } 
} 

后来的变化：

class Peel { 

    private int peelCount; 

    public Peel(int peelCount) { 
     this.peelCount = peelCount; 
    } 

    public int getPeelCount() { 

     return peelCount; 
    } 
} 


class Fruit { 

// Return int number of pieces of peel that 
// resulted from the peeling activity. 
public Peel peel() { 

System.out.println("Peeling is appealing."); 
     return new Peel(1); 
    } 
} 

// Apple must be changed to accomodate 
// the change to Fruit 
class Apple { 

    private Fruit fruit = new Fruit(); 

    public int peel() { 

     Peel peel = fruit.peel(); 
     return peel.getPeelCount(); 
    } 
} 

// This old implementation of Example2 
// still works fine. 
class Example1 { 

    public static void main(String[] args) { 

     Apple apple = new Apple(); 
     int pieces = apple.peel(); 
    } 
} 

后来它可以通过界面做的多晶型：见和javaworld 4页的“使用接口设计：”我不能在这里发布另一个链接。

interface Peelable { 

int peel(); 
} 

class Fruit { 

// Return int number of pieces of peel that 
// resulted from the peeling activity. 
public int peel() { 

System.out.println("Peeling is appealing."); 
      return 1; 
     } 
    } 

    class Apple implements Peelable { 

     private Fruit fruit = new Fruit(); 

     public int peel() { 
      return fruit.peel(); 
     } 
    } 

    class FoodProcessor { 

     static void peelAnItem(Peelable item) { 
      item.peel(); 
     } 
    } 

    class Example5 { 

     public static void main(String[] args) { 

      Apple apple = new Apple(); 
      FoodProcessor.peelAnItem(apple); 
     } 
    } 

关键是代替继承，我们创建了一个新的超类实例。而不是传统的多态。据说使用这种方法比继承更好，因为继承被打破了。

编辑：以后，如果我们想的水果晶型成不同的类型，而不是苹果公司，我们可以这样做：

class Banana implements Peelable { 

    private Fruit fruit = new Fruit(); 

    public int peel() { 
     return fruit.peel(); 
    } 
} 

这是怎么多态性是由组成完成。所以，如果一个方法需要一个可剥离的水果，我们只需要将Peelable对象传递给它而不是水果。

请阅读第3个答案。我为此主题添加了更多信息。

Answer 1

如果你要求的意见，这是我不得不说：

继承通过成分不一定更好，不一定比通过extends严格继承恶化。他们完全是为了不同的目的。组成

一个好处是它允许一组更有限的API中潜在的操作 - 例如，一个可以定义一个类Stack从LinkedList继承，但增加一个push()和pop()方法。但是，无法通过调用类似add(elem, 4)或get(5)的方法来阻止客户端代码滥用您的堆栈，这会绕过堆栈。成分解决了这个问题。

但是，扩展类也有其好处。例如，假设你想制作一个Stack<Integer>，但你不想要任何整数< 0.如果你在GreaterThanZeroStack中包含Stack，那么你必须包括方法push(),pop(),peek()和其他任何其他是正确操作所必需的。这会产生大量不必要的，样板化的重复代码。如果你像punch()那样向你的堆栈中添加另一种方法，它也会造成不必要的维护。如果您改为Stack，那么您只需重写一个方法 - add(Integer i)。另外，您现在可以将其声明为Stack<Integer> s = new GreaterThanZeroStack()，或将其传递到接受参数Stack s的方法中。你可以用组合做这个吗？没有机会。

构图和扩展有两个完全分开的目的，并且通过构图的继承不一定是遵循的模式。

---

在您情况下，继承推而广之是正确的。一个苹果是一种水果。一个苹果不包含水果。如果您要添加另一种方法来水果，如weight()，那么苹果将获得的是免费的，而与组成，苹果不得不重新实现说类似的方法：

 
public int weight() { 
    return fruit.weight(); 
} 

，然后更改每时间改变了体重，就像它的返回类型或名字一样。

Answer 2

一个重要的考虑因素是，用组合物可以减少“是 - 一个”关系。复合水果的苹果不是水果，不能传递给需要水果的方法。

这不是遗传被破坏，只是它被过度使用和滥用。

有关使用接口进行多态性的注释中的观点很有用。如果您完全控制，则可以使用界面和组合构建整个系统。你大概应该 - “更喜欢构图而不是继承”。

但是，它“比...更喜欢......”，而不是“替换......”。在某些情况下，某些东西的合理公共接口太大，无法为所有东西编写传递包装方法。我可以考虑一个我编写的GUI工具包，它有6个顶级抽象类，它们代表了GUI系统的核心部分 - 它们绝对正确地使用继承来设计，而不是接口。基本组件具有大约120多种方法的大型公共接口。我肯定不会想要一个接口，然后在每个具体组件中实现120个包装器方法。

Answer 3

请看看这篇文章：http://www.javaworld.com/javaworld/jw-12-1998/jw-12-techniques.html

在第2页，有一个例子说明该钻石的问题，你不能从多个家长在Java中继承。

在文章中，作者通过接口来介绍Java中的多重继承。

此基础上，这里是我想出如何在Java多重继承会是什么样子：

interface Animal{ 
    public void getLegs(); 
} 

class Dinosour implements Animal{ 
    int legs=4; 
    public int getLegs(){ 
     return this.legs; 
    } 
} 

class Frogs implements Animal{ 
    int legs=2; 
    public int getLegs(){ 
     return this.legs; 
    } 
} 

class Frogosour implements Animal { 
    Dinosour father = new Dinosour(); 
    Frog mother = new Frog(); 
    int legs; 
    public int getLegs(){ 
     return (father.getLegs()+mother.getLegs())/2; 
    } 
} 

这是多重继承的理念贯穿文章看完之后我可以想出。你怎么看？

我在问，因为当我第一次学习编程时，它总是通过继承而被教导的。现在，正如我听到我的同学说，即使在继承的情况下，青睐组合也比使用扩展的继承概念更好。因此，组合应该比继承更受欢迎，另一个原因是它接近于函数式编程。我只想听到不同的意见。