组合模式

转载 2015年11月17日 23:23:53

转载地址:http://blog.csdn.net/phenixsoul/article/details/8480980


这个模式理解起来会有些歧义,特别是某些书上面那些难懂的阐述。先来说说组合模式的几个特点:

1、必须存在不可分割基本元素。

2、组合后的物体可以被组合。

举个通俗的例子,原子是化学反应的基本微粒,它在化学反应中不可分割。现在有 C(碳)、H(氢)、O(氧)、N(氮)4种原子,它们可以随机组合成无数种分子,可以是蛋白质,也可以是脂肪,蛋白质和脂肪就是组合。由蛋白质和脂肪又可以一起被组合成肉、大豆等等。

回到主题,现在有一个需求,客户需要创建一个叶子,可以设定叶子大小和颜色,而且可以为叶子起名。

abstract class tree{
    abstract function create();
}
class createLeaf extends tree{
    
    private $name;
    private $size;
    private $color;
    private $leaf=array();
    
    public function __construct($name,$size,$color){
        $this->name=$name;
        $this->size=$size;
        $this->color=$color;
    }
    
    public function create(){
        $this->leaf[$this->name]=array(
            'size'=>$this->size,
            'color'=>$this->color
        );
        return $this->leaf;
    }
    
}

$leaf=new createLeaf('大红树叶','大','红');

print_r($leaf->create());

运行以上代码将得到:


Array
(
    [大红树叶] => Array
        (
            [size] => 大
            [color] => 红
        )

)

我们的设计完美的实现了客户的需求,但是,现在客户的新要求来了,不仅要可以创建叶子,还要可以创建树枝,而且,可以把叶子安插在树枝上,也可以把安插好的叶子从树枝上拆下来。他们最终想要结果是,树枝上可以安插其他的树枝,从而构建出一颗枝繁叶茂的大树

分析:创建叶子和创建树枝都拥有创建操作,所以它们都可以对抽象tree类进行实现,但创建树枝的类还需要安插和拆除的操作,所以我们暂且在tree类中加上两个抽象方法combination() 和 separation()。

abstract class tree{
    abstract function create();//创建
    abstract function combination(tree $item);//组合
    abstract function separation(tree $item);//分离
}

class createLeaf extends tree{
    
    private $name;
    private $size;
    private $color;
    private $leaf=array();
    
    public function __construct($name,$size,$color){
        $this->name=$name;
        $this->size=$size;
        $this->color=$color;
    }
    
    public function create(){
        $this->leaf[$this->name]=array(
            'size'=>$this->size,
            'color'=>$this->color
        );
        return $this->leaf;
    }

    //由于创建叶子类不需要组合和分离的操作,我们将这两个方法投掷出错误警告。    
    public function combination(tree $item){
        throw new Exception("本类不支持组合操作");
    }
    
    public function separation(tree $item){
        throw new Exception("本类不支持分离操作");
    }
    
}

class createBranch extends tree{

    private $name;
    private $branch=array();
    private $items=array();//树枝可能被安插叶子,该变量用于存放叶子对象
    
    public function __construct($name){
        $this->name=$name;
    }
    
    //我们已经知道$items内的对象都包含创建操作,所以只要依次执行各对象的创建操作,收集结果便可
    public function create(){
        foreach($this->items as $item){
            $arr=$item->create();
            $this->branch[$this->name][]=$arr;
        }
        if(empty($this->branch)){
            $this->branch[$this->name]=array();
        }
        return $this->branch;
    }
    
    public function combination(tree $item){
        $this->items[]=$item;
    }
    
    public function separation(tree $item){
        $key=array_search($item,$this->items);
        if($key!==false){
            unset($this->items[$key]);
        }
    }

}

$leaf_1=new createLeaf('大红树叶','大','红');
$leaf_2=new createLeaf('大绿树叶','大','绿');
$leaf_3=new createLeaf('大黄树叶','大','黄');

$leaf_4=new createLeaf('小红树叶','小','红');
$leaf_5=new createLeaf('小绿树叶','小','绿');
$leaf_6=new createLeaf('小黄树叶','小','黄');

$branch_1=new createBranch('树枝1号');
$branch_1->combination($leaf_1);
$branch_1->combination($leaf_2);
$branch_1->combination($leaf_3);

$branch_2=new createBranch('树枝2号');
$branch_2->combination($leaf_4);
$branch_2->combination($leaf_5);
$branch_2->combination($leaf_6);

$branch=new createBranch('树干');
$branch->combination($branch_1);
$branch->combination($branch_2);

print_r($branch->create());

运行以上代码将得到:

Array
(
    [树干] => Array
        (
            [0] => Array
                (
                    [树枝1号] => Array
                        (
                            [0] => Array
                                (
                                    [大红树叶] => Array
                                        (
                                            [size] => 大
                                            [color] => 红
                                        )

                                )

                            [1] => Array
                                (
                                    [大绿树叶] => Array
                                        (
                                            [size] => 大
                                            [color] => 绿
                                        )

                                )

                            [2] => Array
                                (
                                    [大黄树叶] => Array
                                        (
                                            [size] => 大
                                            [color] => 黄
                                        )

                                )

                        )

                )

            [1] => Array
                (
                    [树枝2号] => Array
                        (
                            [0] => Array
                                (
                                    [小红树叶] => Array
                                        (
                                            [size] => 小
                                            [color] => 红
                                        )

                                )

                            [1] => Array
                                (
                                    [小绿树叶] => Array
                                        (
                                            [size] => 小
                                            [color] => 绿
                                        )

                                )

                            [2] => Array
                                (
                                    [小黄树叶] => Array
                                        (
                                            [size] => 小
                                            [color] => 黄
                                        )

                                )

                        )

                )

        )

)


我们漂亮的完成了这个需求,一颗苍天大树被我们创建大笑,但这里有一个问题,创建树叶操作只需要create() 操作,并不需要combination() 和 separation(),我们为何不把抽象类tree拆分为两个类呢?

abstract class tree{
    abstract function create();
}

//拆分出的树干抽象类,由于继承自tree,必须将create()实现,但实现create()又会造成代码重复,所以将此类也申明为抽象类
abstract class branch extends tree{
    abstract function combination(tree $item);
    abstract function separation(tree $item);
}

class createLeaf extends tree{
    
    private $name;
    private $size;
    private $color;
    private $leaf=array();
    
    public function __construct($name,$size,$color){
        $this->name=$name;
        $this->size=$size;
        $this->color=$color;
    }
    
    public function create(){
        $this->leaf[$this->name]=array(
            'size'=>$this->size,
            'color'=>$this->color
        );
        return $this->leaf;
    }
    
    public function combination(tree $item){
        throw new Exception("本类不支持组合操作");
    }
    
    public function separation(tree $item){
        throw new Exception("本类不支持分离操作");
    }
    
}

class createBranch extends branch{

    private $name;
    private $branch=array();
    private $items=array();
    
    public function __construct($name){
        $this->name=$name;
    }
    
    public function create(){
        foreach($this->items as $item){
            $arr=$item->create();
            $this->branch[$this->name][]=$arr;
        }
        if(empty($this->branch)){
            $this->branch[$this->name]=array();
        }
        return $this->branch;
    }
    
    public function combination(tree $item){
        $this->items[]=$item;
    }
    
    public function separation(tree $item){
        $key=array_search($item,$this->items);
        if($key!==false){
            unset($this->items[$key]);
        }
    }

}

$leaf_1=new createLeaf('大红树叶','大','红');
$leaf_2=new createLeaf('大绿树叶','大','绿');
$leaf_3=new createLeaf('大黄树叶','大','黄');

$leaf_4=new createLeaf('小红树叶','小','红');
$leaf_5=new createLeaf('小绿树叶','小','绿');
$leaf_6=new createLeaf('小黄树叶','小','黄');

$branch_1=new createBranch('树枝1号');
$branch_1->combination($leaf_1);
$branch_1->combination($leaf_2);
$branch_1->combination($leaf_3);

$branch_2=new createBranch('树枝2号');
$branch_2->combination($leaf_4);
$branch_2->combination($leaf_5);
$branch_2->combination($leaf_6);

$branch=new createBranch('树干');
$branch->combination($branch_1);
$branch->combination($branch_2);

print_r($branch->create());

这样,我们总算是漂亮的完成了这个需求。但必须注意的是,由于组合模式的灵活性,很多人喜欢不假思索的使用组合类。事实上,组合类存在着“过于灵活”、“开销大”的缺陷。我们试想一下,一个元素或组合在整个系统中可能被调用非常多次,但一旦某个元素或组合在系统中的一个节点出现问题,我们将很难排查到那个节点。

再试想一下,若是系统中的某个元素是一条查询数据库的sql语句,而且这条sql语句的开销有些大,一旦它被组合到整个系统的每一个角落,运行系统造成的结果将是灾难性的。


Java设计模式透析之 —— 组合(Composite)

听说你们公司最近新推出了一款电子书阅读应用,市场反应很不错,应用里还有图书商城,用户可以在其中随意选购自己喜欢的书籍。你们公司也是对此项目高度重视,加大了投入力度,决定给此应用再增加点功能。 好吧,你...
  • sinyu890807
  • sinyu890807
  • 2013年06月27日 08:37
  • 21801

设计模式--组合模式--商品排序案例

所有的例子均来源与实际开发项目 本节介绍组合模式的使用–商品结果排序评分系统...
  • yangxy81118
  • yangxy81118
  • 2014年08月20日 19:48
  • 2901

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

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

对于组合模式的理解

今天看了组合模式 ,多用于树形结构 定义:  组合模式(Composite Pattern):组合多个对象形成树形结构以表示具有“整体—部分”关系的层次结构。组合模式对单个对象(即叶子对象)和组合对象...
  • AlbertFly
  • AlbertFly
  • 2016年06月16日 12:14
  • 3230

设计模式:组合模式(Composite)

将对象组合成属性结构以表示“部分-整体”的层次结构。组合使得用户和单个对象和组合对象的使用具有一致性。  组合模式设计的角色:  1. Component:是组合中的对象声明接口,在适当的...
  • wangtaomtk
  • wangtaomtk
  • 2016年08月19日 22:03
  • 512

java设计模式之组合模式

将对象组合成树形结构以表示“部分-整体”的层次结构。 组合模式使得用户对单个对象和组合对象的使用具有唯一性 涉及角色: 1.Component 是组合中的对象声明接口,在适当的情况下,实现所...
  • u011659172
  • u011659172
  • 2016年05月26日 11:02
  • 6103

组合模式实例之文件浏览

代码: package MyElement; public abstract class AbstractFile { public abstract void add(AbstractFile ...
  • wangiijing
  • wangiijing
  • 2016年05月31日 10:36
  • 640

c++设计模式之组合模式

组合模式(Composite Pattern)-结构型 意图:组合模式,将对象组合成树形结构以表示“部分-整体”的层次结构,组合模式使得用户对单个对象和组合对象的使用具有一致性。 举例:组合模式让...
  • bbs375
  • bbs375
  • 2016年07月25日 19:09
  • 503

设计模式之组合模式

一、引子 在大学的数据结构这门课上,树是最重要的章节之一。还记得树是怎么定义的吗?树(Tree)是n(n≥0)个结点的有限集T,T为空时称为空树,否则它满足如下两个条件: (1)    有且仅有一...
  • yeshiwu
  • yeshiwu
  • 2016年06月28日 21:09
  • 469

Java 设计模式——组合模式

有时我们可能会被要求处理一个层级结构明显的对象,比如上下级的公司员工、比如层级嵌套的文件夹,还有丰富多彩的美食菜单。可是,我们可能要屡试不爽地编写深度搜索代码、要小心翼翼地编写递归逻辑。现在你可以忘掉...
  • u013761665
  • u013761665
  • 2016年05月17日 17:39
  • 7699
内容举报
返回顶部
收藏助手
不良信息举报
您举报文章:组合模式
举报原因:
原因补充:

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