桌面上太多东西，会显得杂乱，于是人们使用各种容器将东西加以整理。将一系列基本对象(叶子对象)组合到一个容器中，容器又可以进一步放到另一个容器中。
组合模式（Composite Pattern）通过组合将构件最终构成一个树形结构。在计算机领域，树形结构广泛存在，如文件系统、菜单系统、GUI、Java(数据结构)容器、XML文件等等。组合模式的要点是：叶子对象和各种容器能够统一地处理。封装容器和叶子对象的通用操作的概念，通常称为构件/组件/Component。
程序员通常喜欢用树形结构的词汇介绍组合模式，如Component的通用替代词是Node，composite/合成物称为中间结点或branch，基本对象称为树叶等。
容器等同叶子
假设Client复制/ copy()文件系统的元素，此时不论是文件夹还是文件，可以使用抽象类型Node封装对容器Folder和叶子File的通用操作copy()，Node是Folder和File父类型。容器Folder需要存储和管理它所保存的Node(可以是文件夹或文件)。组合模式下，Client完全不用关心将要处理的文件系统元素是否叶子，“对组合对象的操作与对单一对象的操作具有一致性”。
例程 6 2容器
package structure.composite;
public interface Node{
public void copy(); //定义统一的接口
}
package structure.composite;
import java.util.ArrayList;
public class Folder implements Node{
private String folderName;
//用于存储本Folder下的文件夹或文件
private ArrayList<Node> nodeList = new ArrayList<>();
public Folder(String folderName){
this.folderName = folderName;
}
public void add(Node node){ //增加文件或文件夹
nodeList.add(node);
}
/**
* 递归的复制自己和所有子元素
*/
@Override public void copy(){
System.out.println("复制文件夹：" + folderName);
for(Node x : nodeList){
x.copy();
}
}
}
标准的组合模式结构图如图所示。包括3个角色：构件Component如Node、叶子结点Leaf和中间结点Composite。通常使用ArrayList容纳其他构件，管理子结点需要增加(add)和删除等操作。
再看一个例子。在日常的组织结构中，员工/Employee组成部门，部门组成公司。假设需要统计公司的全部薪水，此时，并不需要位置等同Node的公司类、等同Folder的部门类。所有元素都是Employee对象，而公司CEO、部门经理的属性ArrayList<Employee>容纳其下属/subordinates。在此结构中，Employee可以有一个指向父结点的引用，以便于操作。
例程 6-4容器
package structure.composite;
import java.util.ArrayList;
public class Employee {
String name;
int salary;
ArrayList<Employee> subordinates;
boolean isLeaf;
private Employee parent = null;
public Employee(String name, int salary) {
this(null,name,salary);
}
public Employee(Employee parent, String name, int salary) {
this.parent = parent;
this.name = name;
this.salary = salary;
subordinates = new ArrayList<>();
}
public void setLeaf(boolean b) {
isLeaf = b; //if true, do not allow children
}
public int getSalary() { return salary; }
public String getName() { return name; }
/************************************************/
public boolean add(Employee e) {
if (!isLeaf) subordinates.add(e);
return isLeaf;
}
public void remove(Employee e) {
if (!isLeaf) subordinates.remove(e);
}
//树的查找
public Employee getChild(String name) {
Employee newEmp = null;
if (this.getName().equals(name)){
return this;
}
for(Employee x :subordinates){
newEmp = x.getChild(name);
if(newEmp!=null)break;
}
return newEmp;
}
public int getSalaries() {
int sum = salary;
for(Employee x :subordinates){
sum += x.getSalaries();
}
return sum;
}
}
使用组合模式时，一个费事的工作是将各种组件构成一个树形结构。正如GUI编程(一个组合模式的众所周知的应用)时所做的，大量的编写parent.add(child)。构建数据树的代码可以放在客户代码中，也可以封装到一个单独的类如Model中。客户代码中通常保存一个数据树的根元素。
构件Component的接口
一个较为理论性的话题，[GoF]在介绍组合模式时将它凸显出来：退化继承。
构件/Component是仅包含容器/Composite和叶子共同的操作——基本操作，还是包含容器用于管理其子元素的各种操作如add()，getChildren()？
如果构件仅包含基本操作，容器需要对Component扩展继承，当客户以Component声明元素时，容器扩展的方法不能够直接使用，必须将Component向下造型为Composite。换言之，客户将所有构件对象视为叶子。
另一方面，如果构件包含了容器所需的管理方法如add()，则叶子对象此的继承成为了限制继承/退化继承。客户以Component声明元素时，客户将所有构件对象视为容器。而叶子对象替代到应用环境中后，可能出现异常。这一种实现方式在[GoF]中称为透明性——“你可以一致地使用所有的组件”。事实上，它和前者在“透明性”上没有本质区别，前者将所有构件对象视为叶子，后者将所有构件对象视为容器。前者避免了退化继承从而使整个系统符合LSP。后者避免了向下造型或强制类型转换。这一方式，我们称之为大接口组合模式。
大接口组合模式以容器看待所有构件，在实际编程中提供了更多的方便，例程6-4较为典型。其适用场合是程序员有合理的理由将所有构件视为容器，并在Component中为叶子定义合理的add()、getChild()的默认代码以避免退化继承。叶子改写Component的方法，不管是空实现还是抛出异常，通常是不可取的。而且Java中子类的override方法不能够抛出比父类型更大的异常。换言之，如果父类型的getChild()没有抛出异常，子类的代码也不得抛出检查性异常。