组合(合成)模式

原创 2013年12月04日 10:18:56

文章摘抄至http://www.cnblogs.com/java-my-life/archive/2012/04/17/2453861.html

 

合成模式属于对象的结构模式,有时又叫做“部分——整体”模式。合成模式将对象组织到树结构中,可以用来描述整体与部分的关系。合成模式可以使客户端将单纯元素与复合元素同等看待

 

合成模式

合成模式把部分和整体的关系用树结构表示出来。合成模式使得客户端把一个个单独的成分对象和由它们复合而成的合成对象同等看待。

比如,一个文件系统就是一个典型的合成模式系统。下图是常见的计算机XP文件系统的一部分。

 

 

上图可以看出,文件系统是一个树结构,树上长有节点。树的节点有两种,一种是树枝节点,即目录,有内部树结构,在图中涂有颜色;另一种是文件,即树叶节点,没有内部树结构。

  显然,可以把目录和文件当做同一种对象同等对待和处理,这也就是合成模式的应用。

  合成模式可以不提供父对象的管理方法,但是合成模式必须在合适的地方提供子对象的管理方法,诸如:add()、remove()、以及getChild()等。

  合成模式的实现根据所实现接口的区别分为两种形式,分别称为安全式透明式

 

安全式合成模式的结构
  安全模式的合成模式要求管理聚集的方法只出现在树枝构件类中,而不出现在树叶构件类中。

 

这种形式涉及到三个角色:
抽象构件(Component)角色:这是一个抽象角色,它给参加组合的对象定义出公共的接口及其默认行为,可以用来管理所有的子对象。合成对象通常把它所包含的子对象当做类型为Component的对象。在安全式的合成模式里,构件角色并不定义出管理子对象的方法,这一定义由树枝构件对象给出。
树叶构件(Leaf)角色:树叶对象是没有下级子对象的对象,定义出参加组合的原始对象的行为。
树枝构件(Composite)角色:代表参加组合的有下级子对象的对象。树枝构件类给出所有的管理子对象的方法,如add()、remove()以及getChild()。

 

抽象构件角色类

public interface Component {
    /**
     * 输出组建自身的名称
     */
    public void printStruct(String preStr);
}

 

树枝构件角色类

public class Composite implements Component {
    /**
     * 用来存储组合对象中包含的子组件对象
     */
    private List<Component> childComponents = new ArrayList<Component>();
    /**
     * 组合对象的名字
     */
    private String name;
    /**
     * 构造方法,传入组合对象的名字
     * @param name    组合对象的名字
     */
    public Composite(String name){
        this.name = name;
    }
    /**
     * 聚集管理方法,增加一个子构件对象
     * @param child 子构件对象
     */
    public void addChild(Component child){
        childComponents.add(child);
    }
    /**
     * 聚集管理方法,删除一个子构件对象
     * @param index 子构件对象的下标
     */
    public void removeChild(int index){
        childComponents.remove(index);
    }
    /**
     * 聚集管理方法,返回所有子构件对象
     */
    public List<Component> getChild(){
        return childComponents;
    }
    /**
     * 输出对象的自身结构
     * @param preStr 前缀,主要是按照层级拼接空格,实现向后缩进
     */
    @Override
    public void printStruct(String preStr) {
        // 先把自己输出
        System.out.println(preStr + "+" + this.name);
        //如果还包含有子组件,那么就输出这些子组件对象
        if(this.childComponents != null){
            //添加两个空格,表示向后缩进两个空格
            preStr += "  ";
            //输出当前对象的子对象
            for(Component c : childComponents){
                //递归输出每个子对象
                c.printStruct(preStr);
            }
        }
        
    }

}

 

树叶构件角色类

public class Leaf implements Component {
    /**
     * 叶子对象的名字
     */
    private String name;
    /**
     * 构造方法,传入叶子对象的名称
     * @param name 叶子对象的名字
     */
    public Leaf(String name){
        this.name = name;
    }
    /**
     * 输出叶子对象的结构,叶子对象没有子对象,也就是输出叶子对象的名字
     * @param preStr 前缀,主要是按照层级拼接的空格,实现向后缩进
     */
    @Override
    public void printStruct(String preStr) {
        // TODO Auto-generated method stub
        System.out.println(preStr + "-" + name);
    }

}

 

客户端类

public class Client {
    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("");
    }
}

 

可以看出,树枝构件类(Composite)给出了addChild()、removeChild()以及getChild()等方法的声明和实现,而树叶构件类则没有给出这些方法的声明或实现。这样的做法是安全的做法,由于这个特点,客户端应用程序不可能错误地调用树叶构件的聚集方法,因为树叶构件没有这些方法,调用会导致编译错误。

  安全式合成模式的缺点是不够透明,因为树叶类和树枝类将具有不同的接口。

透明式合成模式的结构
  与安全式的合成模式不同的是,透明式的合成模式要求所有的具体构件类,不论树枝构件还是树叶构件,均符合一个固定接口

 

 透明式合成模式的结构
  与安全式的合成模式不同的是,透明式的合成模式要求所有的具体构件类,不论树枝构件还是树叶构件,均符合一个固定接口

 

 

抽象构件角色类

public abstract class Component {
    /**
     * 输出组建自身的名称
     */
    public abstract void printStruct(String preStr);
    /**
     * 聚集管理方法,增加一个子构件对象
     * @param child 子构件对象
     */
    public void addChild(Component child){
        /**
         * 缺省实现,抛出异常,因为叶子对象没有此功能
         * 或者子组件没有实现这个功能
         */
        throw new UnsupportedOperationException("对象不支持此功能");
    }
    /**
     * 聚集管理方法,删除一个子构件对象
     * @param index 子构件对象的下标
     */
    public void removeChild(int index){
        /**
         * 缺省实现,抛出异常,因为叶子对象没有此功能
         * 或者子组件没有实现这个功能
         */
        throw new UnsupportedOperationException("对象不支持此功能");
    }
    
    /**
     * 聚集管理方法,返回所有子构件对象
     */
    public List<Component> getChild(){
        /**
         * 缺省实现,抛出异常,因为叶子对象没有此功能
         * 或者子组件没有实现这个功能
         */
        throw new UnsupportedOperationException("对象不支持此功能");
    }
}

 

树枝构件角色类,此类将implements Conponent改为extends Conponent,其他地方无变化。

 

public class Composite extends Component {
    /**
     * 用来存储组合对象中包含的子组件对象
     */
    private List<Component> childComponents = new ArrayList<Component>();
    /**
     * 组合对象的名字
     */
    private String name;
    /**
     * 构造方法,传入组合对象的名字
     * @param name    组合对象的名字
     */
    public Composite(String name){
        this.name = name;
    }
    /**
     * 聚集管理方法,增加一个子构件对象
     * @param child 子构件对象
     */
    public void addChild(Component child){
        childComponents.add(child);
    }
    /**
     * 聚集管理方法,删除一个子构件对象
     * @param index 子构件对象的下标
     */
    public void removeChild(int index){
        childComponents.remove(index);
    }
    /**
     * 聚集管理方法,返回所有子构件对象
     */
    public List<Component> getChild(){
        return childComponents;
    }
    /**
     * 输出对象的自身结构
     * @param preStr 前缀,主要是按照层级拼接空格,实现向后缩进
     */
    @Override
    public void printStruct(String preStr) {
        // 先把自己输出
        System.out.println(preStr + "+" + this.name);
        //如果还包含有子组件,那么就输出这些子组件对象
        if(this.childComponents != null){
            //添加两个空格,表示向后缩进两个空格
            preStr += "  ";
            //输出当前对象的子对象
            for(Component c : childComponents){
                //递归输出每个子对象
                c.printStruct(preStr);
            }
        }
        
    }

}

 

树叶构件角色类,此类将implements Conponent改为extends Conponent,其他地方无变化

public class Leaf extends Component {
    /**
     * 叶子对象的名字
     */
    private String name;
    /**
     * 构造方法,传入叶子对象的名称
     * @param name 叶子对象的名字
     */
    public Leaf(String name){
        this.name = name;
    }
    /**
     * 输出叶子对象的结构,叶子对象没有子对象,也就是输出叶子对象的名字
     * @param preStr 前缀,主要是按照层级拼接的空格,实现向后缩进
     */
    @Override
    public void printStruct(String preStr) {
        // TODO Auto-generated method stub
        System.out.println(preStr + "-" + name);
    }

}

 

客户端类的主要变化是不再区分Composite对象和Leaf对象。 

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("");
    }
}

 

可以看出,客户端无需再区分操作的是树枝对象(Composite)还是树叶对象(Leaf)了;对于客户端而言,操作的都是Component对象。

 

两种实现方法的选择
  这里所说的安全性合成模式是指:从客户端使用合成模式上看是否更安全,如果是安全的,那么就不会有发生误操作的可能,能访问的方法都是被支持的。

  这里所说的透明性合成模式是指:从客户端使用合成模式上,是否需要区分到底是“树枝对象”还是“树叶对象”。如果是透明的,那就不用区分,对于客户而言,都是Compoent对象,具体的类型对于客户端而言是透明的,是无须关心的。

  对于合成模式而言,在安全性和透明性上,会更看重透明性,毕竟合成模式的目的是:让客户端不再区分操作的是树枝对象还是树叶对象,而是以一个统一的方式来操作。

  而且对于安全性的实现,需要区分是树枝对象还是树叶对象。有时候,需要将对象进行类型转换,却发现类型信息丢失了,只好强行转换,这种类型转换必然是不够安全的。

  因此在使用合成模式的时候,建议多采用透明性的实现方式。 

 

  • 263d5c87-c724-3f6d-9667-9a0dcb91f6d1-thumb.jpg
  • 大小: 22.2 KB
  • 10bb5785-e7aa-388c-8de9-6b43f87110bc-thumb.jpg
  • 大小: 21.7 KB
  • 856856c5-a1a8-3d8a-90ce-35b1b7982eca-thumb.jpg
  • 大小: 26.5 KB

JAVA设计模式初探之组合模式

先看看组合模式的定义吧:“将对象组合成树形结构以表示‘部分-整体’的层次结构。组合模式使得用户对单个对象和组合对象的使用具有一致性。”    就拿剪发办卡的事情来分析一下吧。    首先,一张卡可...
  • jason0539
  • jason0539
  • 2014年03月31日 08:40
  • 22125

组合模式(Composite Pattern)(一):组合模式介绍

一、意图 将对象组合成树形结构以表示“部分-整体”的层次结构。Composite模式使得用户对单个对象和组合对象的使用具有一致性。 二、适用性 • 你想表示对象的...
  • jialinqiang
  • jialinqiang
  • 2013年05月20日 22:30
  • 3475

设计模式中组合(Compose)和聚合(Aggregate)的关系

(Composite/Aggregate ReusePrinciple ,CARP)要尽量使用对象组合,而不是继承关系达到软件复用的目的 定义:经常又叫做合成复用原则(Composite...
  • davidsu33
  • davidsu33
  • 2014年07月24日 17:34
  • 2552

设计模式之组合(合成)模式

1. 概述   将对象组合成树形结构以表示“部分-整体”的层次结构。组合模式使得用户对单个对象和组合对象的使用具有一致性。 2. 解决的问题   当希望忽略单个对象和组合对象的区别,...
  • niuyisheng
  • niuyisheng
  • 2013年08月30日 10:55
  • 1524

java 合成模式(组合模式)

转自:http://www.cnblogs.com/java-my-life/archive/2012/04/17/2453861.html 在阎宏博士的《JAVA与模式》一书中开头...
  • ltx06
  • ltx06
  • 2015年10月11日 15:04
  • 975

UML中定义的关系主要有6种: 依赖、关联、聚合、组合/合成、泛化、实现; 以及对应的C++体现

http://www.cnblogs.com/aicro/archive/2010/08/23/1806584.html UML中定义的关系主要有6种: 依赖、关联、聚合、组合/合成、泛化、实现...
  • bai_lu_sz
  • bai_lu_sz
  • 2013年02月18日 11:05
  • 561

设计模式六大原则——合成/聚合复用原则(CARP)

1、定义    简而言之,对于合成/聚合复用原则的定义就是:要尽量使用合成和聚合,尽量不要使用继承。           2、释义     为什么“要尽量使用合成和聚合,尽量不要使用继承”呢?   ...
  • u010853701
  • u010853701
  • 2014年05月31日 15:35
  • 3162

设计模式六大原则(6):合成/聚合原则

来自:点击打开链接 一:合成/聚合复用原则   尽量使用合成/聚合,尽量不要使用类继承   二:什么是合成?   . 合成表示一种强的拥有关系,体现了严格的部分和整体的关系,部分和整体的生命周...
  • qq289523052
  • qq289523052
  • 2014年06月09日 11:22
  • 619

设计模式六大原则--合成/聚合复用原则

定义 尽量使用合成/聚合,尽量不要使用类继承。(Design to interfaces;Favor composition over inheritance;Find what var...
  • Senior_lee
  • Senior_lee
  • 2014年02月17日 13:58
  • 2379

【设计模式】六大原则之三(迪米特法则与合成/聚合复用原则)

引言         前面两篇博客介绍了设计模式中六大原则其中之四,下面这篇博客中将会再给大家介绍六大原则最后两个原则 【迪米特法则】 1、问题由来         类与类之间的关系越密切,耦合度越大...
  • liuziteng0228
  • liuziteng0228
  • 2017年02月03日 14:46
  • 872
内容举报
返回顶部
收藏助手
不良信息举报
您举报文章:组合(合成)模式
举报原因:
原因补充:

(最多只允许输入30个字)