设计模式--组合模式

简介: 叶子对象和组合对象实现相同的接口。这就是组合模式能够将叶子节点和对象节点进行一致处理的原因。 基本概念: 组合模式[构造性设计模式]定义了如何将容器对象和叶子对象进行递归组合,使得客户在使用的过程中无须进行区分,可以对他们进行一致的处理。

叶子对象和组合对象实现相同的接口。这就是组合模式能够将叶子节点和对象节点进行一致处理的原因。

基本概念:

组合模式[构造性设计模式]定义了如何将容器对象和叶子对象进行递归组合,使得客户在使用的过程中无须进行区分,可以对他们进行一致的处理。

组合模式的角色:

  1. Component :组合中的对象声明接口,在适当的情况下,实现所有类共有接口的默认行为。声明一个接口用于访问和管理Component子部件。
  2. Leaf:叶子对象。叶子结点没有子结点。
  3. Composite:容器对象,定义有枝节点行为,用来存储子部件,在Component接口中实现与子部件有关操作,如增加(add)和删除(remove)等。

组合模式优点和缺点:

1.使客户端调用简单,客户端可以一致的使用组合结构或其中单个对象,用户就不必关系自己处理的是单个对象还是整个组合结构,这就简化了客户端代码。
2.更容易在组合体内加入对象部件. 客户端不必因为加入了新的对象部件而更改代码。
 

缺点:

使设计变得更加抽象,对象的业务规则如果很复杂,则实现组合模式具有很大挑战性,而且不是所有的方法都与叶子对象子类都有关联
 
首先定义个接口,包含叶子和容器的特性的抽象方法:文件夹为容器,为 Composite,容器对象;文件为 Leaf,叶子节点;IFile, Component ,组合中的对象声明接口,在适当的情况下,实现所有类共有接口的默认行为.
  1. /*
     * 文件节点抽象(是文件和目录的父类)
     */
    public interface IFile {
        
        //显示文件或者文件夹的名称
        public void display();
        
        //添加
        public boolean add(IFile file);
        
        //移除
        public boolean remove(IFile file);
        
        //获得子节点
        public List<IFile> getChild();
    }

    IFile实现类:文件夹类Folder.java,容器对象,里面可添加文件,删除文件;

  1. import java.util.ArrayList;
    import java.util.List;
    /**
     * 文件夹类
     * @author soyoungboy
     *
     */
    public class Folder implements IFile{
        private String name;
        private List<IFile> children;
        
        public Folder(String name) {
            this.name = name;
            children = new ArrayList<IFile>();
        }
        
        /**
         * 显示文件夹名称
         */
        public void display() {
            System.out.println(name);
        }
        /**
         * 文件夹下可能有文件,故显示
         */
        public List<IFile> getChild() {
            return children;
        }
        /**
         * 文件夹下面添加文件
         */
        public boolean add(IFile file) {
            return children.add(file);
        }
        /**
         * 文件夹下面删除文件
         */
        public boolean remove(IFile file) {
            return children.remove(file);
        }
    }

     

  2. IFile实现类:子节点,File.java
  1. import java.util.List;
    /**
     * 文件类,无子节点,故无getChild返回内容,文件下不可条件文件,不可删除文件,故add,remove为false
     * @author soyoungboy
     *
     */
    public class File implements IFile {
        private String name;
        public File(String name) {
            this.name = name;
        }
        /**
         * 文件显示
         */
        public void display() {
            System.out.println(name);
        }
        /**
         * 文件下面没有文件
         */
        public List<IFile> getChild() {
            return null;
        }
        /**
         * 添加文件
         */
        public boolean add(IFile file) {
            return false;
        }
        /**
         * 删除文件
         */
        public boolean remove(IFile file) {
            return false;
        }
    }

     


测试类:
import java.util.List;
public class MainClass {
    public static void main(String[] args) {
        //C盘
        Folder rootFolder = new Folder("C:");
        //first目录
        Folder firstFolder = new Folder("first");
        //first.txt文件
        File firstFile = new File("first.txt");
        
        rootFolder.add(firstFolder);
        rootFolder.add(firstFile);
        
        //second目录
        Folder secondFolder = new Folder("second");
        File secondFile = new File("second.txt");
        //添加二级目录
        firstFolder.add(secondFolder);
        //二级目录中添加文件second.txt
        firstFolder.add(secondFile);
        
        Folder thirdFolder = new Folder("third");
        File thirdFile = new File("third.txt");
        //添加三级目录
        secondFolder.add(thirdFolder);
        //添加三级文件third.txt
        secondFolder.add(thirdFile);
        
        displayTree(rootFolder,0);
        
    }
    
    public static void displayTree(IFile rootFolder, int deep) {
        for(int i = 0; i < deep; i++) {
            System.out.print("--");
        }
        //显示自身的名称
        rootFolder.display();
        //获得子树
        List<IFile> children = rootFolder.getChild();
        //遍历子树
        for(IFile file : children) {
            //如果是文件的话
            if(file instanceof File) {
                for(int i = 0; i <= deep; i++) {
                    System.out.print("--");
                }
                //直接调用display操作
                file.display();
            } else {
            //如果是目录的话,递归操作  
                displayTree(file,deep + 1);
            }
        }
    }
}

 

C:
--first
----second
------third
------third.txt
----second.txt
--first.txt

android中的使用场景:

一般处理树形结构的内容。
ViewGroup和View的结构就是一个组合模式:
 
相关文章
|
5月前
|
设计模式 JavaScript 前端开发
js设计模式【详解】—— 组合模式
js设计模式【详解】—— 组合模式
58 7
|
3月前
|
设计模式 Java
Java设计模式:组合模式的介绍及代码演示
组合模式是一种结构型设计模式,用于将多个对象组织成树形结构,并统一处理所有对象。例如,统计公司总人数时,可先统计各部门人数再求和。该模式包括一个通用接口、表示节点的类及其实现类。通过树形结构和节点的通用方法,组合模式使程序更易扩展和维护。
Java设计模式:组合模式的介绍及代码演示
|
3月前
|
设计模式 存储 安全
Java设计模式-组合模式(13)
Java设计模式-组合模式(13)
|
6月前
|
设计模式 存储 安全
Java设计模式:组合模式之透明与安全的两种实现(七)
Java设计模式:组合模式之透明与安全的两种实现(七)
|
6月前
|
设计模式 Java
Java设计模式之组合模式详解
Java设计模式之组合模式详解
|
6月前
|
设计模式
组合模式-大话设计模式
组合模式-大话设计模式
|
7月前
|
设计模式 Java 容器
【设计模式系列笔记】组合模式
组合模式(Composite Pattern)是一种结构型设计模式,它允许将对象组合成树状结构以表示部分-整体的层次结构。组合模式使得客户端可以统一处理单个对象和对象组合,而无需区分它们的类型。
92 12
|
7月前
|
设计模式 Go
[设计模式 Go实现] 结构型~组合模式
[设计模式 Go实现] 结构型~组合模式
|
7月前
|
设计模式 安全 Java
[设计模式Java实现附plantuml源码~结构型]树形结构的处理——组合模式
[设计模式Java实现附plantuml源码~结构型]树形结构的处理——组合模式
|
7月前
|
设计模式 Java
【设计模式】文件目录管理是组合模式吗?
【设计模式】文件目录管理是组合模式吗?
44 0