深入Java设计模式之组合模式

简介: 深入Java设计模式之组合模式

主要解决:它在我们树型结构的问题中,模糊了简单元素和复杂元素的概念,客户程序可以像处理简单元素一样来处理复杂元素,从而使得客户程序与复杂元素的内部结构解耦。

何时使用: 1、您想表示对象的部分-整体层次结构(树形结构)。 2、您希望用户忽略组合对象与单个对象的不同,用户将统一地使用组合结构中的所有对象。

如何解决:树枝和叶子实现统一接口,树枝内部组合该接口。

主要角色

(1)组合部件(Component):它是一个抽象接口。这里表示树根School

(2)叶子(Leaf):在组合中表示子节点对象,这里表示的是网络部InternetDepartment,其没有孩子了。

(3)合成部件(Composite):表示自己还有孩子,这里表示的是分校BranchSchool。

模式代码模板

package com.lzhsite.technology.designPattern.composite.GeneralImplement;
public interface Component
{
    public Component getComposite();
    public void sampleOperation();
}
package com.lzhsite.technology.designPattern.composite.GeneralImplement;
import java.util.Enumeration;
import java.util.Vector;
public class Composite implements Component
{
    private Vector componentVector = new Vector();
    public Component getComposite()
    {
        return this;
    }
    public void sampleOperation()
    {
        Enumeration enumeration = getChildren();
        while (enumeration.hasMoreElements())
        {
            ((Component) enumeration.nextElement()).sampleOperation();
        }
    }
    public void add(Component component)
    {
        componentVector.addElement(component);
    }
    public void remove(Component component)
    {
        componentVector.removeElement(component);
    }
    public Enumeration getChildren()
    {
        return componentVector.elements();
    }
}
package com.lzhsite.technology.designPattern.composite.GeneralImplement;
public class Leaf implements Component
{
    public Component getComposite()
    {
        return null;
    }
    public void sampleOperation()
    {
    }
}

应用举例

输入结果

package com.lzhsite.technology.designPattern.composite.FolderFileImplement;
public class ClientForFolderFileImplement
{
    public static void main(String[] args)
    {
        Root root1 = new Folder("C://");
        Root root2 = new Folder("D://");
        Root winDir = new Folder("Windows/");
        Root sysDir = new Folder("System/");
        Root userDir = new Folder("User/");
        Root defaultDir = new Folder("Default/");
        Root helloWorld = new File("HelloWorld.java");
        winDir.addfile(helloWorld);
        Root helloWorld1 = new File("HelloWorld1.java");
        Root helloWorld2 = new File("HelloWorld2.java");
        sysDir.addfile(helloWorld1);
        sysDir.addfile(helloWorld2);
        root1.addfile(winDir);
        root1.addfile(sysDir);
        Root HelloWorld3 = new File("HelloWorld3.java");
        Root HelloWorld4 = new File("HelloWorld4.java");
        Root HelloWorld5 = new File("HelloWorld5.java");
        userDir.addfile(defaultDir);
        userDir.addfile(HelloWorld4);
        userDir.addfile(HelloWorld5);
        defaultDir.addfile(HelloWorld3);
        root2.addfile(userDir);
        root1.display();
        root2.display();
    }
}
package com.lzhsite.technology.designPattern.composite.FolderFileImplement;
import java.util.List;
public interface Root
{
    public boolean addfile(Root file);
    public boolean removeFile(Root file);
    public List<Root> getFiles();
    public void display();
}
package com.lzhsite.technology.designPattern.composite.FolderFileImplement;
import java.util.ArrayList;
import java.util.List;
public class Folder implements Root {
  private String name;
  private List<Root> folders;
  public Folder(String name) {
    this.name = name;
    this.folders = new ArrayList<Root>();
  }
  public boolean addfile(Root file) {
    return folders.add(file);
  }
  public boolean removeFile(Root file) {
    return folders.remove(file);
  }
  public List<Root> getFiles() {
    return folders;
  }
  public String getName() {
    return name;
  }
  private static String getLevelStr(int level) {
    StringBuffer levelStr = new StringBuffer();
    for (int levelI = 0; levelI < level; levelI++) {
      levelStr.append("\t");
    }
    return levelStr.toString();
  }
    private int level = 0;
  public void printFileName(Root root) {
    if (root instanceof Folder) {
      System.out.print(getLevelStr(level));
      System.out.print("   |   ");
      System.out.println(((Folder) root).getName());
      for (Root sonRoot : root.getFiles()) {
        level++;
        printFileName(sonRoot);
        level--;
      }
    } else if (root instanceof File) {
      System.out.print(getLevelStr(level));
      root.display();
      return;
    }
  }
  public void display() {
    System.out.println(name);
    for (Root root : folders) {
      printFileName(root);
    }
  }
}
package com.lzhsite.technology.designPattern.composite.FolderFileImplement;
import java.util.List;
public class File implements Root
{
    private String name;
    public File(String name)
    {
        this.name = name;
    }
    public boolean addfile(Root file)
    {
        return false;
    }
    public boolean removeFile(Root file)
    {
        return false;
    }
    public List<Root> getFiles()
    {
        return null;
    }
    public void display()
    {
        System.out.println("   |   " + name);
    }
}

示例代码https://gitee.com/lzhcode/maven-parent/tree/master/lzh-technology/src/main/java/com/lzhsite/technology/designPattern/composite


目录
相关文章
|
5月前
|
设计模式 缓存 安全
【高薪程序员必看】万字长文拆解Java并发编程!(8):设计模式-享元模式设计指南
🌟 ​大家好,我是摘星!​ 🌟今天为大家带来的是并发编程中的经典对象复用设计模式-享元模式,废话不多说让我们直接开始。
119 0
|
5月前
|
设计模式 Java 定位技术
【设计模式】【结构型模式】组合模式(Composite)
一、入门 什么是组合模式 组合模式(Composite Pattern)是一种结构型设计模式,它允许你将对象组合成树形结构来表示“部分-整体”的层次关系。组合模式使得客户端可以统一处理单个对象和组合对
165 10
|
7月前
|
设计模式 Java 数据安全/隐私保护
Java 设计模式:装饰者模式(Decorator Pattern)
装饰者模式属于结构型设计模式,允许通过动态包装对象的方式为对象添加新功能,提供比继承更灵活的扩展方式。该模式通过组合替代继承,遵循开闭原则(对扩展开放,对修改关闭)。
|
8月前
|
设计模式 存储 安全
「全网最细 + 实战源码案例」设计模式——组合模式
组合模式(Composite Pattern)是一种结构型设计模式,用于将对象组合成树形结构以表示“部分-整体”的层次结构。它允许客户端以一致的方式对待单个对象和对象集合,简化了复杂结构的处理。组合模式包含三个主要组件:抽象组件(Component)、叶子节点(Leaf)和组合节点(Composite)。通过这种模式,客户端可以统一处理简单元素和复杂元素,而无需关心其内部结构。适用于需要实现树状对象结构或希望以相同方式处理简单和复杂元素的场景。优点包括支持树形结构、透明性和遵循开闭原则;缺点是可能引入不必要的复杂性和过度抽象。
218 22
|
11月前
|
设计模式 消息中间件 搜索推荐
Java 设计模式——观察者模式:从优衣库不使用新疆棉事件看系统的动态响应
【11月更文挑战第17天】观察者模式是一种行为设计模式,定义了一对多的依赖关系,使多个观察者对象能直接监听并响应某一主题对象的状态变化。本文介绍了观察者模式的基本概念、商业系统中的应用实例,如优衣库事件中各相关方的动态响应,以及模式的优势和实际系统设计中的应用建议,包括事件驱动架构和消息队列的使用。
180 6
|
11月前
|
设计模式 Java 数据库连接
Java编程中的设计模式:单例模式的深度剖析
【10月更文挑战第41天】本文深入探讨了Java中广泛使用的单例设计模式,旨在通过简明扼要的语言和实际示例,帮助读者理解其核心原理和应用。文章将介绍单例模式的重要性、实现方式以及在实际应用中如何优雅地处理多线程问题。
150 4
|
设计模式 监控 算法
Java设计模式梳理:行为型模式(策略,观察者等)
本文详细介绍了Java设计模式中的行为型模式,包括策略模式、观察者模式、责任链模式、模板方法模式和状态模式。通过具体示例代码,深入浅出地讲解了每种模式的应用场景与实现方式。例如,策略模式通过定义一系列算法让客户端在运行时选择所需算法;观察者模式则让多个观察者对象同时监听某一个主题对象,实现松耦合的消息传递机制。此外,还探讨了这些模式与实际开发中的联系,帮助读者更好地理解和应用设计模式,提升代码质量。
Java设计模式梳理:行为型模式(策略,观察者等)
|
11月前
|
设计模式 JavaScript Java
Java设计模式:建造者模式详解
建造者模式是一种创建型设计模式,通过将复杂对象的构建过程与表示分离,使得相同的构建过程可以创建不同的表示。本文详细介绍了建造者模式的原理、背景、应用场景及实际Demo,帮助读者更好地理解和应用这一模式。
531 0
|
存储 设计模式 安全
Java设计模式-备忘录模式(23)
Java设计模式-备忘录模式(23)
123 3
|
设计模式 存储 算法
Java设计模式-命令模式(16)
Java设计模式-命令模式(16)
165 2

热门文章

最新文章