深入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


目录
相关文章
|
26天前
|
设计模式 消息中间件 搜索推荐
Java 设计模式——观察者模式:从优衣库不使用新疆棉事件看系统的动态响应
【11月更文挑战第17天】观察者模式是一种行为设计模式,定义了一对多的依赖关系,使多个观察者对象能直接监听并响应某一主题对象的状态变化。本文介绍了观察者模式的基本概念、商业系统中的应用实例,如优衣库事件中各相关方的动态响应,以及模式的优势和实际系统设计中的应用建议,包括事件驱动架构和消息队列的使用。
|
1月前
|
设计模式 Java 数据库连接
Java编程中的设计模式:单例模式的深度剖析
【10月更文挑战第41天】本文深入探讨了Java中广泛使用的单例设计模式,旨在通过简明扼要的语言和实际示例,帮助读者理解其核心原理和应用。文章将介绍单例模式的重要性、实现方式以及在实际应用中如何优雅地处理多线程问题。
38 4
|
2月前
|
设计模式 Java 程序员
[Java]23种设计模式
本文介绍了设计模式的概念及其七大原则,强调了设计模式在提高代码重用性、可读性、可扩展性和可靠性方面的作用。文章还简要概述了23种设计模式,并提供了进一步学习的资源链接。
54 0
[Java]23种设计模式
|
1月前
|
设计模式 JavaScript Java
Java设计模式:建造者模式详解
建造者模式是一种创建型设计模式,通过将复杂对象的构建过程与表示分离,使得相同的构建过程可以创建不同的表示。本文详细介绍了建造者模式的原理、背景、应用场景及实际Demo,帮助读者更好地理解和应用这一模式。
|
2月前
|
设计模式 监控 算法
Java设计模式梳理:行为型模式(策略,观察者等)
本文详细介绍了Java设计模式中的行为型模式,包括策略模式、观察者模式、责任链模式、模板方法模式和状态模式。通过具体示例代码,深入浅出地讲解了每种模式的应用场景与实现方式。例如,策略模式通过定义一系列算法让客户端在运行时选择所需算法;观察者模式则让多个观察者对象同时监听某一个主题对象,实现松耦合的消息传递机制。此外,还探讨了这些模式与实际开发中的联系,帮助读者更好地理解和应用设计模式,提升代码质量。
Java设计模式梳理:行为型模式(策略,观察者等)
|
3月前
|
存储 设计模式 安全
Java设计模式-备忘录模式(23)
Java设计模式-备忘录模式(23)
|
3月前
|
设计模式 存储 算法
Java设计模式-命令模式(16)
Java设计模式-命令模式(16)
|
3月前
|
设计模式 存储 缓存
Java设计模式 - 解释器模式(24)
Java设计模式 - 解释器模式(24)
|
3月前
|
设计模式 安全 Java
Java设计模式-迭代器模式(21)
Java设计模式-迭代器模式(21)
|
3月前
|
设计模式 缓存 监控
Java设计模式-责任链模式(17)
Java设计模式-责任链模式(17)