组合和继承是一样的吗?

它们不一样。

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

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

如果我想实现组合模式，我如何在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中 汽车价格=(各部件价格)之和

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

喜欢组合而不是继承?

继承意味着重用一个类的完整功能，在这里，我的类必须使用超类的所有方法，我的类将与超类titely耦合，在继承的情况下，代码将在两个类中重复。

但是当我们用作文与其他班级进行交流时，我们可以克服这些问题。复合是将另一个类的属性声明到我们想要与之对话的类中。我们想从那个类中得到什么功能可以通过使用那个属性来实现。

@Michael Rodrigues给出的答案不正确(我道歉;我不能直接评论)，这可能会导致一些混乱。

接口实现是一种继承形式…当你实现一个接口时，你不仅继承了所有的常量，你还将你的对象提交为接口指定的类型;这仍然是一种“是”的关系。如果汽车实现了Fillable，那么汽车“是-a”Fillable，并且可以在任何需要使用Fillable的代码中使用。

组合从根本上不同于继承。当您使用组合时，您(如其他回答所示)在两个对象之间建立了“has-a”关系，而不是使用继承时所建立的“is-a”关系。

所以，从其他问题中关于汽车的例子来看，如果我想说一辆汽车“有一个”油箱，我会使用如下的组合:

public class Car {

private GasTank myCarsGasTank;

}

希望这能消除任何误解。

另一个例子，考虑一个汽车类，这将是一个很好的组合使用，一个汽车将“有”一个发动机，一个变速器，轮胎，座位，等等。它不会扩展任何这些类。

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

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

继承带来IS-A关系。复合引出HAS-A关系。 策略模式解释了组合应该用于定义特定行为的算法族的情况。典型的例子是实现飞行行为的鸭子类。

public interface Flyable{
 public void fly();
}

public class Duck {
 Flyable fly;

 public Duck(){
  fly = new BackwardFlying();
 }
}

因此，我们可以有多个实现飞行的类 例如:

public class BackwardFlying implements Flyable{
  public void fly(){
    Systemout.println("Flies backward ");
  }
}
public class FastFlying implements Flyable{
  public void fly(){
    Systemout.println("Flies 100 miles/sec");
  }
}

如果是继承的话，我们就会有两个不同的鸟类，它们会反复实现fly函数。所以继承和组合是完全不同的。