合成模式属于对象的结构模式，有时又叫做“部分--整体”模式。合成模式将对象组织到树结构中国，可以用来描述整体与部分的关系，合成模式可以使客户端将单纯元素与复合元素同等看待；
涉及到三个角色；
抽象构件：这就相当于一个抽象角色，它给参加组合的对象定义出公共的接口及其默认行为，可以用来管理所有的子对象，
树叶构件角色：树叶对象是没有下级子对象的对象，定义出参加组合的原始对象的行为；
树枝构件角色：代表参加组合的有下级子对象的对象，树枝构件类给出了所有的管理子对象的方法；
对于安全模式和透明模式来说，来者之间的区别就在于你的树叶构件角色的方法了，如果是安全模式的话，抽象构件只会提供最基本的接口方法，不会提供增删改查，而透明模式里面的抽象构件则会不管是树枝还是树叶，都提供了增删改查的功能，对于安全模式来说，你在树叶对象中不会调用到不该有的方法，显然更安全，而对于透明模式来说，你在新建对线的时候就不必分树枝还是树叶了，直接就是抽象构件new一个对象，而对于调用了树叶没拥有的方法，则会抛出异常，捕获，另外，安全模式是用接口实现的方式，而透明模式是用继承的方式；安全模式的合成模式要求管理聚集的方法值出现在树枝构件类中，而不出现在树叶构件类中。
安全模式的代码：
抽象构件；
package compositeSafe;
public interface Component {
public void printStruct(String preStr);
}
树枝构件；
package compositeSafe;
import java.util.ArrayList;
import java.util.List;
public class Composite implements Component{
public Composite() {
// TODO Auto-generated constructor stub
}
private List<Component> childComponents = new ArrayList<Component>();
private String name;
public Composite(String name){
this.name = name;
}
public void addChild(Component child){
childComponents.add(child);
}
public void removeChild(int index){
childComponents.remove(index);
}
public List<Component> getChild(){
return childComponents;
}
public void printStruct(String preStr){
System.out.println(preStr + "+" + this.name);
if(this.childComponents != null){
preStr += " ";
for(Component c: childComponents){
c.printStruct(preStr);
}
}
}
}
树叶构件；
package compositeSafe;
public class Leaf implements Component{
public Leaf() {
// TODO Auto-generated constructor stub
}
private String name;
public Leaf(String name)
{
this.name = name;
}
public void printStruct(String preStr){
System.out.println(preStr + "-" + name);
}
}
客户端；
package compositeSafe;
public class Client {
public Client() {
// TODO Auto-generated constructor stub
}
public static void main(String[] args){
Composite root = new Composite("服装");
Composite c1 = new Composite("男装");
Composite c2 = new Composite("女装");
Leaf leaf1 = new Leaf("衬衫");
Leaf leaf2 = new Leaf("夹克");
Leaf leaf3 = new Leaf("裙子");
Leaf leaf4 = new Leaf("套装");
root.addChild(c1);
root.addChild(c2);
c1.addChild(leaf1);
c1.addChild(leaf2);
c2.addChild(leaf3);
c2.addChild(leaf4);
root.printStruct("");
}
}
而对于透明模式的话；树枝和树叶类基本不变，就是从接口实现变成了继承实现；
抽象构件;
package compositeClarity;
import java.util.List;
public abstract class Component {
public abstract void printStruct(String preStr);
public void addChild(Component child){
throw new UnsupportedOperationException("对象不支持功能");
}
public void removeChild(int index){
throw new UnsupportedOperationException("对象不支持功能");
}
public List<Component> getChild(){
throw new UnsupportedOperationException("对象不支持功能");
}
}
客户端；
package compositeClarity;
public class Client {
public static void main(String[]args){
Component root = new Composite("服装");
Component c1 = new Composite("男装");
Component c2 = new Composite("女装");
Component leaf1 = new Leaf("衬衫");
Component leaf2 = new Leaf("夹克");
Component leaf3 = new Leaf("裙子");
Component leaf4 = new Leaf("套装");
root.addChild(c1);
root.addChild(c2);
c1.addChild(leaf1);
c1.addChild(leaf2);
c2.addChild(leaf3);
c2.addChild(leaf4);
root.printStruct("");
}
}
对于合成模式而言，在安全性和透明性上，更看重透明性，毕竟合成模式的目的是：让客户端不再区分操作的是树枝对象还是树叶对象，而是以一个统一的方法来操作；
而且对于安全性的实现，需要区分的是树枝对象还是树叶对象，有时候，需要将对象进行类型转换，却发现类型信息丢失了，只好强行转换，这种类型转换必然是不够安全的。因此，我们建议多采用透明性的实现方式。