我认为这个例子清楚地解释了继承和组合之间的区别。

在本例中，使用继承和组合解决了这个问题。作者注意到;在继承中，父类的更改可能会导致继承它的派生类出现问题。

在这里，您还可以看到使用UML进行继承或组合时在表示上的区别。

http://www.javaworld.com/article/2076814/core-java/inheritance-versus-composition--which-one-should-you-choose-.html

两个类之间的继承，其中一个类扩展了另一个类，建立了“IS A”关系。

另一端的组合包含类中另一个类的实例，建立了“Has A”关系。组合在java中是很有用的，因为它在技术上便于多重继承。

合成就像它听起来一样-你通过插入部分来创建一个对象。

这个答案的其余部分错误地基于以下前提。 这是通过接口完成的。 例如，使用上面的Car例子，

Car implements iDrivable, iUsesFuel, iProtectsOccupants
Motorbike implements iDrivable, iUsesFuel, iShortcutThroughTraffic
House implements iProtectsOccupants
Generator implements iUsesFuel

用一些标准的理论组件，你就可以构建你的对象。然后，你的工作就是填写房子如何保护它的居住者，以及汽车如何保护它的居住者。

继承则正好相反。您从一个完整(或半完整)对象开始，然后替换或覆盖您想要更改的各种位。

例如，机动车辆可能带有可燃料方法和驱动方法。您可以保留Fuel方法，因为给摩托车和汽车加油是一样的，但您可以重写Drive方法，因为摩托车的运行方式与汽车非常不同。

通过继承，一些类已经完全实现，而其他类的方法必须重写。在合成中什么都没有给你。(但是你可以通过调用其他类中的方法来实现接口，如果你碰巧有一些东西的话)。

组合被认为是更灵活的，因为如果你有一个像iUsesFuel这样的方法，你可以在其他地方有一个方法(另一个类，另一个项目)，它只关心处理可以被燃料的对象，不管它是汽车、船、炉子、烧烤等等。接口要求那些声称实现了该接口的类实际上拥有该接口的全部方法。例如,

iFuelable Interface:
   void AddSomeFuel()
   void UseSomeFuel()
   int  percentageFull()

然后你可以在其他地方有一个方法

private void FillHerUp(iFuelable : objectToFill) {

   Do while (objectToFill.percentageFull() <= 100)  {

        objectToFill.AddSomeFuel();
   }

奇怪的例子，但它表明这个方法并不关心它在填充什么，因为对象实现了iUsesFuel，它可以被填充。故事结束了。

如果你使用继承，你将需要不同的FillHerUp方法来处理机动车辆和烧烤，除非你有一些相当奇怪的“ObjectThatUsesFuel”基础对象来继承。

组合和继承是一样的吗?

它们不一样。

组合:它允许以对象的单个实例的方式处理一组对象。组合的目的是将对象“组合”成树状结构，以表示部分-整体层次结构

继承:类从其所有超类继承字段和方法，无论是直接的还是间接的。子类可以覆盖它继承的方法，也可以隐藏它继承的字段或方法。

如果我想实现组合模式，我如何在Java中做到这一点?

维基百科的文章足以在java中实现复合模式。

主要参与者:

组件:

是所有组件的抽象，包括复合组件吗 声明组合中对象的接口

叶:

表示组合中的叶对象 实现所有组件方法

复合材料:

表示一个复合组件(有子组件) 实现操作子节点的方法 实现所有Component方法，通常是将它们委托给其子方法

理解Composite模式的代码示例:

import java.util.List;
import java.util.ArrayList;

interface Part{
    public double getPrice();
    public String getName();
}
class Engine implements Part{
    String name;
    double price;
    public Engine(String name,double price){
        this.name = name;
        this.price = price;
    }
    public double getPrice(){
        return price;
    }
    public String getName(){
        return name;
    }
}
class Trunk implements Part{
    String name;
    double price;
    public Trunk(String name,double price){
        this.name = name;
        this.price = price;
    }
    public double getPrice(){
        return price;
    }
    public String getName(){
        return name;
    }
}
class Body implements Part{
    String name;
    double price;
    public Body(String name,double price){
        this.name = name;
        this.price = price;
    }
    public double getPrice(){
        return price;
    }
    public String getName(){
        return name;
    }
}
class Car implements Part{
    List<Part> parts;
    String name;

    public Car(String name){
        this.name = name;
        parts = new ArrayList<Part>();
    }
    public void addPart(Part part){
        parts.add(part);
    }
    public String getName(){
        return name;
    }
    public String getPartNames(){
        StringBuilder sb = new StringBuilder();
        for ( Part part: parts){
            sb.append(part.getName()).append(" ");
        }
        return sb.toString();
    }
    public double getPrice(){
        double price = 0;
        for ( Part part: parts){
            price += part.getPrice();
        }
        return price;
    }   
}

public class CompositeDemo{
    public static void main(String args[]){
        Part engine = new Engine("DiselEngine",15000);
        Part trunk = new Trunk("Trunk",10000);
        Part body = new Body("Body",12000);

        Car car = new Car("Innova");
        car.addPart(engine);
        car.addPart(trunk);
        car.addPart(body);

        double price = car.getPrice();

        System.out.println("Car name:"+car.getName());
        System.out.println("Car parts:"+car.getPartNames());
        System.out.println("Car price:"+car.getPrice());
    }

}

输出:

Car name:Innova
Car parts:DiselEngine Trunk Body
Car price:37000.0

解释:

Part是一片叶子 汽车包含许多部件 汽车的不同部分已经添加到car中 汽车价格=(各部件价格)之和

关于组合和继承的利弊，请参考下面的问题。

喜欢组合而不是继承?

复合意味着创建一个与特定类有关系的类的对象。 假设学生与会计有关系;

继承是，这是带有扩展特性的前一个类。这意味着这个新类是具有一些扩展特性的旧类。 假设学生是学生，但所有的学生都是人。所以这是学生和人类之间的关系。这就是继承。

组合意味着有A 继承意味着IS A

例子:Car有引擎，Car是一辆汽车

在编程中，这被表示为:

class Engine {} // The Engine class.

class Automobile {} // Automobile class which is parent to Car class.

class Car extends Automobile { // Car is an Automobile, so Car class extends Automobile class.
  private Engine engine; // Car has an Engine so, Car class has an instance of Engine class as its member.
}