组合模式是一种设计模式，允许将对象组合成树形结构并像单个对象一样使用它们，这种模式在处理类似公司组织结构这样的树形数据时非常有用，通过组合模式，我们可以将公司和部门视为同一类型的对象，从而以统一的方式处理发送给不同层级的请求或任务，叶节点是没有子节点的对象，而复合节点则包含子节点，客户端可以与这些节点进行交互，无需知道它们的具体类型。组合模式提供了表示层次结构的灵活方式，并统一了客户端的交互方式。

定义

组合模式（Composite Pattern）是一种结构型设计模式，它允许你将对象组合成树形结构以表示“部分-整体”的层次结构，组合模式使得客户端对单个对象和复合对象的使用具有一致性。

举个业务中形象的例子，比如，我们有一个餐饮公司，其中提供了各种食品，如汉堡、薯条、饮料等，同时，公司也提供套餐服务，比如“汉堡套餐”包括汉堡、薯条和饮料，“全餐套餐”包括汉堡、薯条、饮料和沙拉。在这个例子中，每一个食品，如汉堡、薯条、饮料和沙拉，都可以被视为一个单独的组件，而套餐，比如“汉堡套餐”和“全餐套餐”，则是由这些组件组合而成的复合组件。

使用组合模式，我们可以设计一个统一的接口，比如“Orderable”，所有食品和套餐都实现这个接口，这个接口可以包含方法如“getPrice()”和“serve()”，单个食品如汉堡、薯条等实现这些方法以返回自己的价格和提供自己的服务，而套餐则在其实现中递归地调用其子组件的相应方法，从而计算出总价并提供整套服务。

这样，无论是单个食品还是套餐，对于客户来说，都可以通过相同的接口进行点单和获取价格等操作，而无需关心它们内部的具体构成。

代码案例

就拿上面餐饮公司的业务案例，下面分别是针对该业务实现的未使用组合模式的反例和使用了组合模式的正例。

1、反例，未使用组合模式

没有使用组合模式，可能会采用一种比较简单直接的方法来实现，如下代码：

// 食品接口  
public interface Food {  
    double getPrice();  
}  
  
// 汉堡类  
public class Burger implements Food {  
    @Override  
    public double getPrice() {  
        return 10.0;  
    }  
}  
  
// 薯条类  
public class Fries implements Food {  
    @Override  
    public double getPrice() {  
        return 5.0;  
    }  
}  
  
// 饮料类  
public class Drink implements Food {  
    @Override  
    public double getPrice() {  
        return 3.0;  
    }  
}  
  
// 沙拉类  
public class Salad implements Food {  
    @Override  
    public double getPrice() {  
        return 7.0;  
    }  
}  
  
// 汉堡套餐类  
public class BurgerCombo {  
    private Burger burger = new Burger();  
    private Fries fries = new Fries();  
    private Drink drink = new Drink();  
      
    public double getPrice() {  
        return burger.getPrice() + fries.getPrice() + drink.getPrice();  
    }  
}  
  
// 全餐套餐类  
public class FullMealCombo {  
    private Burger burger = new Burger();  
    private Fries fries = new Fries();  
    private Drink drink = new Drink();  
    private Salad salad = new Salad();  
      
    public double getPrice() {  
        return burger.getPrice() + fries.getPrice() + drink.getPrice() + salad.getPrice();  
    }  
}  
  
// 客户端调用案例  
public class Client {  
    public static void main(String[] args) {  
        // 创建汉堡套餐对象并获取价格  
        BurgerCombo burgerCombo = new BurgerCombo();  
        System.out.println("汉堡套餐价格: " + burgerCombo.getPrice()); // 输出: 18.0  
          
        // 创建全餐套餐对象并获取价格  
        FullMealCombo fullMealCombo = new FullMealCombo();  
        System.out.println("全餐套餐价格: " + fullMealCombo.getPrice()); // 输出: 28.0  
    }  
}

在上述代码中，我们定义了Food接口和四个实现类Burger、Fries、Drink和Salad，然后，我们为每种套餐创建了一个单独的类（BurgerCombo和FullMealCombo），并在这些类中组合了不同的食品对象。

这种方式的问题在于，每当我们需要添加新的套餐或者修改现有套餐的组合时，都需要创建或修改相应的类，这会导致代码的维护成本增加，并且不利于代码的复用和扩展。

2、正例，使用组合模式

使用组合模式，如下代码：

// 菜单项接口，定义了计算价格的方法  
interface MenuItem {  
    double getPrice();  
}  
  
// 具体菜单项类，实现了菜单项接口  
class Burger implements MenuItem {  
    @Override  
    public double getPrice() {  
        return 5.0; // 汉堡的价格  
    }  
}  
  
class Fries implements MenuItem {  
    @Override  
    public double getPrice() {  
        return 3.0; // 薯条的价格  
    }  
}  
  
class Drink implements MenuItem {  
    @Override  
    public double getPrice() {  
        return 2.0; // 饮料的价格  
    }  
}  
  
class Salad implements MenuItem {  
    @Override  
    public double getPrice() {  
        return 4.0; // 沙拉的价格  
    }  
}  
  
// 套餐类，实现了菜单项接口，并包含一个菜单项列表  
class Meal extends ArrayList<MenuItem> implements MenuItem {  
    @Override  
    public double getPrice() {  
        double sum = 0.0;  
        for (MenuItem item : this) {  
            sum += item.getPrice(); // 计算套餐的总价格  
        }  
        return sum;  
    }  
}  
  
// 客户端调用案例  
public class Main {  
    public static void main(String[] args) {  
        // 创建具体的菜单项对象  
        MenuItem burger = new Burger();  
        MenuItem fries = new Fries();  
        MenuItem drink = new Drink();  
        MenuItem salad = new Salad();  
          
        // 创建套餐对象，并将具体的菜单项添加到套餐中  
        Meal burgerMeal = new Meal();  
        burgerMeal.add(burger);  
        burgerMeal.add(fries);  
        burgerMeal.add(drink);  
        System.out.println("汉堡套餐的价格: $" + burgerMeal.getPrice()); // 输出: 汉堡套餐的价格: $10.0  
          
        Meal fullMeal = new Meal();  
        fullMeal.add(burger);  
        fullMeal.add(fries);  
        fullMeal.add(drink);  
        fullMeal.add(salad);  
        System.out.println("全餐套餐的价格: $" + fullMeal.getPrice()); // 输出: 全餐套餐的价格: $14.0  
    }  
}

在上述代码中，我们定义了一个MenuItem接口，它有一个getPrice方法用于计算价格，具体的菜单项（如Burger、Fries、Drink和Salad）实现了这个接口，套餐类（Meal）也实现了这个接口，并且包含一个菜单项列表，在套餐类的getPrice方法中，我们遍历这个列表并计算总价格，客户端代码中，我们创建了具体的菜单项对象和套餐对象，并将菜单项添加到套餐中，然后输出套餐的价格。

核心总结

组合模式，就是把一些对象组合起来，形成一个树状的结构，这种结构特别像我们平常生活中遇到的那种“部分与整体”的关系。比如说，一个公司由不同的部门组成，每个部门又有自己的员工，这样一层一层组合起来，就形成了一个完整的公司结构。

使用组合模式，可以简化客户端的代码，客户端在处理单个对象和一堆对象组合起来的大对象时，不需要知道它们之间的区别，可以用同样的方式处理，这就好像我们在处理一个单独的员工和一个整个部门时，可以用同样的方法来下达指令，而不需要去了解他们内部的具体细节。

组合模式还能提高系统的可扩展性，如果我们想添加新的组件类型，只需要在现有的基础上稍作修改，就可以轻松实现，这就像一个搭积木的过程，我们可以随时添加新的积木类型，搭建出更丰富的造型。

它的缺点就是结构的复杂性，如果组件和叶子有很多共同行为，但又存在一些微小的差异，那么在组合模式中处理它们可能会变得很复杂。这就好像我们在处理一堆形状、颜色都差不多的积木时，要找出其中那一块与众不同的积木一样困难。另外，由于组合模式使用了递归，如果组合的结构太深或者太大，可能会导致大量的内存消耗。这就像我们不断地往积木塔上添加积木，最终导致塔太高而倒塌一样。