结构模式--之--合成模型模式

合成（Composite）模型模式属于对象的结构模式，有时又叫部分-整体（Part-Whole）模式。合成模式将对象组织到树结构中，可以用来描述整体与部分的关系。合成模式可以使用客户端将单纯元素与复合元素同等看待。

抽象构件（Component）角色：抽象角色，它给参加组合的对象规定一个接口。这个角色给出共有的接口及其默认行为。
树叶构件（Leaf）角色：代表参加组合的树叶对象。一个树叶没有下级的子对象。定义出参加组合的原始对象的行为。
树枝构件（Composite）角色：代表参加组合的有子对象的对象，并给出树枝构件对象的行为。

可以看出，Composite类型的对象含有其他的Component类型的对象。换言之，Composite类型的对象可以含有其他的树枝（Composite）类型或树叶（Leaf）类型的对象。

合成模式的实现根据实现接口的区别分为两种形式，分别称为安全式和透明式。合成模式可以不提供父对象的管理方法，但是合成模式必须在合适的地方提供子对象的管理方法。在什么地方声明子对象的管理方法，如add（）,remove().以及getChild()等就变成了一个值得仔细思考的问题。可以讨论的选择有如下几个：

透明方式：在Component里面声明所有的用来管理子类对象的方法，包括add(),remove(),及getChild()方法。这样做的好处是所有构件类都有相同的接口。在客户端看来，树叶类对象与合成类对象的区别在接口层次消失了，客户端可以同等地对待所有的对象。这种方式缺点是不够安全，因为树叶类对象和合成类对象在本质上是有区别的。树叶类对象不可能有下一个层次的对象，因此add()，remove()以及getChild()方法没有意义，但是在编译时不会出错，而只会在运行时出错

透明式的合成模式的结构：
与安全模式的合成模式不同的是：透明式的合成模式要求所有的具体构件类，不论树枝构件还是树叶构件，均符合一个固定的接口。
3个角色：
抽象构件（Component）角色：它给参加组合的对象规定一个接口，规范共有的接口及默认行为。这个接口可以用来管理所有的子对象，要提供一个接口以规范取得和管理下层组件的接口，包括add(),remove(),及getChild()之类的方法。
树叶构件（Leaf）角色：代表参加组合的树叶对象，定义出参加组合的原始对象的行为。树叶会给出add(),remove(),及getChild()之类的用来管理子类对象的方法的平庸实现
树枝构件（Composite）角色：代表参加组合的有子对象的对象，定义出这样的对象的行为。





就以画图为例，画一个基本图形可以认为是一个叶子结点，而复杂图画则是由基本图形组成的，以合成模式示例代码如下：

public class NotSafeComposite {

public static void main(String[] args) {
Graph pic = new Picture();
pic.add(new Line());
pic.add(new RectAngle());

pic.draw();
}
}

//抽象构件
interface Graph{
public void draw();
public void add(Graph g);
public void remove(Graph G);
public Graph getChild(int i);
}
//树枝构件
class Picture implements Graph{
private List<Graph> list = new ArrayList<Graph>();
@Override
public void draw() {
for(int i=0;i<list.size();i++){
Graph g = list.get(i);
g.draw();
}
}

@Override
public void add(Graph g) {
list.add(g);
}

@Override
public void remove(Graph g) {
list.remove(g);
}

@Override
public Graph getChild(int i) {
return list.get(i);
}

}

//树叶构件
class Line implements Graph{

@Override
public void draw() {
System.out.println("Draw a line --------------");
}

@Override
public void add(Graph g) {

}

@Override
public void remove(Graph G) {

}

@Override
public Graph getChild(int i) {
return null;
}

}

//树叶构件
class RectAngle implements Graph{

@Override
public void draw() {
System.out.println("Draw a RectAngle   --||");
}

@Override
public void add(Graph g) {

}

@Override
public void remove(Graph G) {

}

@Override
public Graph getChild(int i) {
return null;
}

}

安全方式：在Composite类里声明所有的用来管理子类对象的方法。这样的做法是安全的做法，因为树叶类型的对象根本就没有管理子类对象的方法，因此，如果客户端对树叶类对象使用这些方法时，程序会在编译时期出错。编译通不过，就不会出现运行时错误。这个缺点是中够透明，因为树叶类和合成类将具有不同的接口。

安全式的合成模式要求管理聚集的方法只出现在树枝构件类中，而不出现在树叶构件类中。
这种形式有3 个角色：
1.抽象构件（Component）角色：抽象角色，它给参加组合的对象定义出公共的接口及其默认行为，可以用来管理所有的子对象。合成对象通常把所包含的子对象当作类型为（Component）的对象。在安全式的合成模式里，构件角色并不定义出管理子对象的方法，这一定义由树枝构件对象给出。
2.树叶构件（Leaf）角色：树叶对象是没有下级子对象的对象，定义出参加组合的原始对象的行为。
3.树枝构件（Composite）角色：代表参加组合的有下级子对象的对象。树枝构件类给出所有的管理子对象的方法，如add(),remove()及components()的声明。

public class SafeComposite {

public static void main(String[] args) {
Picture picture = new Picture();
picture.add(new Line());
picture.add(new RectAngle());
picture.draw();
}
}
//抽象构件
interface Graph{
public void draw();
}

//树枝构件
class Picture implements Graph{
private List<Graph> list = new ArrayList<Graph>();
@Override
public void draw() {
for(int i=0;i<list.size();i++){
Graph g = list.get(i);
g.draw();
}
}

public void add(Graph g){
list.add(g);
}

public void remove(Graph g){
list.remove(g);
}
//返回一个子构件对象
public Graph getChild(int i){
return list.get(i);
}
}

//树叶构件
class Line implements Graph{

@Override
public void draw() {
System.out.println("Draw a line-----------------------");
}

}

//树叶构件
class RectAngle implements Graph{

@Override
public void draw() {
System.out.println("Draw a Rect --|||");
}

}

-----
什么情况下使用合成模式？
1.需要描述对象的部分和整体的等级结构
2.需要客户端忽略掉个体构件和组合构件的区别。客户端必须平等对待所有的构件，包括个体构件和组合构件。
它的优点是：
1.合成模式可以很容易地增加新种类的构件
2.使用合成模式可以使客户端变得很容易设计，因为客户端不需要知道构件是树叶构件还是树枝构件
合成模式的缺点是：
1.使用合成模式后，控制树枝构件的类型就不太容易
2.用继承的方法来增加新的行为很困难。