合成模式

合成模式

       合成模式又叫部分-整体模式。合成模式是将对象组织到树结构中，可以用来描述整体和部分的关系。合成模式分为安全式和透明式两种。

       合成模式由抽象构件、树叶构件、树枝构件组成。

       抽象构件（Conponent）角色：给参加组合的对象规定一个接口，给出共有的接口及其默认行为。

       树叶构件（Leaf）角色：代表参加组合的树叶对象，一个树叶没有下级的子对象，定义出参加组合的原始对象的行为。

       树枝构件（Composite）角色：代表参加组合的有子对象的对象，并给出树枝构件对象的行为。

 

1.1透明式

       透明式在Component里面声明所有的用来管理子类对象的方法，使得所有的构件类都具有相同的接口。在客户端看来，树叶类和树枝类时等同的，可以同等的对待所有的对象。

 抽象构件角色：

/**
 * 抽象构件角色
 */
public interface Component {

    /**
     * 返回自己的实例
     * @return
     */
    Composite getComposite();

    /**
     * 业务方法
     */
    void operate();

    void add(Component component);

    void remove(Component component);
}

 

树枝构件角色：

/**
 * 树枝构件角色
 */
public class Composite implements Component {

    private List<Component> composites = new ArrayList<>();
    @Override
    public Composite getComposite() {
        return this;
    }

    @Override
    public void operate() {
        for(Component item : composites){
            item.operate();
        }
    }

    @Override
    public void add(Component component){
        composites.add(component);
    }

    @Override
    public void remove(Component component){
        composites.remove(component);
    }
}

 

树叶构件角色：

/**
 * 树叶构件角色
 */
public class Leaf implements Component {
    @Override
    public Composite getComposite() {
        return null;
    }

    @Override
    public void operate() {
        System.out.println("leaf operate ...");
    }

    @Override
    public void add(Component component) {

    }

    @Override
    public void remove(Component component) {
    }
}

 

客户端：

 

/**
 * 客户端
 */
public class Client {
    public static void main(String[] args) {
        Component composite = new Composite("root");

        Component composite1 = new Composite("root left composite");
        Component leaf1 = new Leaf("left composite leaf");
        composite1.add(leaf1);
        composite.add(composite1);

        Component composite2 = new Composite("root right composite");
        Component leaf2 = new Leaf("right composite leaf1");
        composite2.add(leaf2);
        Component leaf3 = new Leaf("right composite leaf2");
        composite2.add(leaf3);
        composite.add(composite2);

        composite.operate();
    }
}

 

打印：

composite operate ...root
composite operate ...root left composite
leaf operate ...left composite leaf
composite operate ...root right composite
leaf operate ...right composite leaf1
leaf operate ...right composite leaf2

 

1.2安全式

       安全式在Composite类里面声明所有的用来管理子类对象的方法。树叶节点没有管理子类对象的方法。

抽象构件角色：

/**
 * 抽象构件角色
 */
public interface Component {

    /**
     * 返回自己的实例
     * @return
     */
    Composite getComposite();

    /**
     * 业务方法
     */
    void operate();
}

 

树枝构件角色：

/**
 * 树枝构件角色
 */
public class Composite implements Component {

    private String name;

    public Composite(String name) {
        this.name = name;
    }

    private List<Component> composites = new ArrayList<>();
    @Override
    public Composite getComposite() {
        return this;
    }

    @Override
    public void operate() {
        System.out.println("composite operate ..." + name);
        for(Component item : composites){
            item.operate();
        }
    }

    public void add(Component component){
        composites.add(component);
    }

    public void remove(Component component){
        composites.remove(component);
    }
}

 

树叶构件角色：

/**
 * 树叶构件角色
 */
public class Leaf implements Component{

    private String name;

    public Leaf(String name) {
        this.name = name;
    }

    @Override
    public Composite getComposite() {
        return null;
    }

    @Override
    public void operate() {
        System.out.println("leaf operate ..." + name);
    }
}

 

客户端：

/**
 * 客户端
 */
public class Client {
    public static void main(String[] args) {
        Composite composite = new Composite("root");

        Composite composite1 = new Composite("root left composite");
        Leaf leaf1 = new Leaf("left composite leaf");
        composite1.add(leaf1);
        composite.add(composite1);

        Composite composite2 = new Composite("root right composite");
        Component leaf2 = new Leaf("right composite leaf1");
        composite2.add(leaf2);
        Component leaf3 = new Leaf("right composite leaf2");
        composite2.add(leaf3);
        composite.add(composite2);

        composite.operate();
    }
}

 

输出：

composite operate ...root
composite operate ...root left composite
leaf operate ...left composite leaf
composite operate ...root right composite
leaf operate ...right composite leaf1
leaf operate ...right composite leaf2

 

1.3小结

　　合成模式是描述对象的部分和整体的等级结构，即树形结构，例如文件系统。合成模式分为安全式和透明式两种，透明式在抽象构件角色中定义了管理子对象的方法，使得树枝角色和树叶角色对客户端来说是透明的、安全式则在抽象构件角色中定义了树枝角色和树叶角色的公共方法，树枝对象的管理方法在树枝角色中定义。

 

 

 

 

参考：

　　《Java与模式》

转载于:https://www.cnblogs.com/simple-ly/p/9949913.html