Composite(组合)模式----容器和内容的一致性

》》能够使容器与内容具有一致性,创造出递归结构的模式就是Composite 模式。

-----------以下示例程序的功能是列出文件和文件夹的一览。

》》示例程序的类图:

       

------------------------

         《Entry 类》

           package composite;
/*
 * 抽象类,用来实现  File 类和 Directory 类的一致性
 */
public abstract class Entry {
public abstract String getName();              //获取名字
public abstract int getSize();                 //获取大小
//加入目录条目,并且抛出了FileTreatmentException异常
public Entry add(Entry entry) throws FileTreatmentException{
throw new FileTreatmentException();
}
//显示目录条目一览
public void printList(){
printList("");
}
//为一览加上前缀并显示目录条目一览
protected abstract void printList(String prefix);
//显示代表类的文字
public String toString(){
return getName() + "("+getSize()+")";
}



}

-------------------------------------

    《File 类》

       package composite;


public class File extends Entry{
private String name;                     //文件的名字
private int size;                        //文件的大小
public File(String name ,int size){      //构造器
this.name = name;
this.size = size;
}

public String getName(){                 //获取文件的名字
return name;
}
public int getSize(){                    //获取文件的大小
return size;
}
protected void printList(String prefix){  //输出有关文件的信息
System.out.println(prefix+"/"+this);
}
}

----------------------------

         《Directory 类》

             package composite;
import java.util.ArrayList;
import java.util.Iterator;


public class Directory extends Entry{
private String name;                              //文件夹的名字
private ArrayList directory = new ArrayList();    //文件夹中目录条目的集合
public Directory(String name){                    //构造器
this.name = name;
}
public String getName(){                          //获取文件夹的名字
return name;
}

public Entry add(Entry entry){                    //增加目录条目
directory.add(entry);
return this;
}
public int getSize(){                             //获取大小
int size = 0;
//遍历集合
Iterator it = directory.iterator();
while(it.hasNext()){
Entry entry = (Entry)it.next();
size += entry.getSize();
}
return size;


protected void printList(String prefix){
System.out.println(prefix + "/"+this);       //显示文件夹的内容
//遍历文件夹里面的内容,并且显示在该文件夹的里面
Iterator it = directory.iterator();
while(it.hasNext()){
Entry entry = (Entry)it.next();
entry.printList(prefix+"/"+name);
}

}


}

------------------------------

       《FileTreatmentException类》------》自定义处理异常

       package composite;


public class FileTreatmentException extends RuntimeException{
public FileTreatmentException(){

}

    public FileTreatmentException(String msg){
    super(msg);

}


}

-------------------------------

      《Main 类》-----测试程序

       package composite;


public class Main {
public static void main(String[] args){
try{
System.out.println("Making root entries...");
Directory rootdir = new Directory("root");
Directory bindir = new Directory("bin");
Directory tmpdir = new Directory("tmp");
Directory usrdir = new Directory("usr");

rootdir.add(bindir);
rootdir.add(tmpdir);
rootdir.add(usrdir);
bindir.add(new File("vi",10000));
bindir.add(new File("latex",20000));
rootdir.printList();

System.out.println("");
System.out.println("Making user entries...");
Directory yuki = new Directory("yuki");
Directory hanako = new Directory("hanakpo");
Directory tomura = new Directory("tomura");
usrdir.add(yuki);
usrdir.add(hanako);
usrdir.add(tomura);
yuki.add(new File("diary.html",100));
yuki.add(new File("Composite.java",200));
hanako.add(new File("memo.tex",300));
tomura.add(new File("game.doc",400));
tomura.add(new File("junk.mail",500));
rootdir.printList();


}catch(FileTreatmentException e){
e.printStackTrace();
}
}


}

-----------------------------------------------------------

        《以上示例的文件结构》

         -----root

              ------bin

                      ----vi

                      ----latex

              ------tmp

              ------usr

                      ----yuki

                           ----diary.html

                           ----Composite.java

                      ----hanako

                           ----memo.tex

                      ----tomura

                           ----game.doc

                           ----junk.mail

--------------------------------------------------------

         《运行结果》

          Making root entries...
/root(30000)
/root/bin(30000)
/root/bin/vi(10000)
/root/bin/latex(20000)
/root/tmp(0)
/root/usr(0)


Making user entries...
/root(31500)
/root/bin(30000)
/root/bin/vi(10000)
/root/bin/latex(20000)
/root/tmp(0)
/root/usr(1500)
/root/usr/yuki(300)
/root/usr/yuki/diary.html(100)
/root/usr/yuki/Composite.java(200)
/root/usr/hanakpo(300)
/root/usr/hanakpo/memo.tex(300)
/root/usr/tomura(900)
/root/usr/tomura/game.doc(400)
/root/usr/tomura/junk.mail(500)

----------------------------------------------

           《Composite模式中的登场角色》

        *****Leaf(树叶)

                 表示“内容”的角色。在该角色中不能放入其他对象。在示例程序中,由 File 扮演此角色。

        *****Composite(复合物)

                 表示容器的角色。可以在其中放入 Leaf 角色 和 Composite 角色。在示例程序中,

             Directory 类扮演此角色。

        *****Component

                使 Leaf 角色和 Composite 角色具有 一致性的角色。Component 角色是 Leaf 角色和

              Composite 角色的父类。在示例程序中,由 Entry 类扮演此角色。

        ***** Client 

             使用 Composite 模式的角色。在示例程序中,Main 类扮演此角色。      

--------------------------------------------------

             《扩展思路的要点》

             1.多个和单个的一致性

                    使用Composite 模式可以使容器与内容具有一致性,也可以称其为多个和单个的一致性

              即将多个对象结合在一起,当作一个对象进行处理。

             2.Add  方法应该放在哪里

                     (1)、定义在 Entry 类中,报错

                     (2)、定义在  Entry 类中,但什么都不做

                     (3)、声明在Entry 类中,但不实现(该add 方法为抽象方法)

                     (4)、只定义在 Directory 类中

              3.到处都是递归结构

                      例如:在视窗系统中,一个窗口可以含有一个子窗口,这就是 Composite  模式的典型应用。

                                  在文章的列表中,各列表之间可以相互嵌套,这也是一种递归。

                      通常来说,树结构的数据结构都适用  Composite 模式。


--------------------------------------------------

           相关的设计模式

           1.Command 模式

           2.Visitor模式

           3.Decorator 模式 

  • 0
    点赞
  • 0
    收藏
    觉得还不错? 一键收藏
  • 打赏
    打赏
  • 0
    评论
Java设计模式是一组经过实践验证的面向对象设计原则和模式,可以帮助开发人员解决常见的软件设计问题。下面是常见的23种设计模式: 1. 创建型模式(Creational Patterns): - 工厂方法模式(Factory Method Pattern) - 抽象工厂模式(Abstract Factory Pattern) - 单例模式(Singleton Pattern) - 原型模式(Prototype Pattern) - 建造者模式(Builder Pattern) 2. 结构型模式(Structural Patterns): - 适配器模式(Adapter Pattern) - 桥接模式(Bridge Pattern) - 组合模式Composite Pattern) - 装饰器模式(Decorator Pattern) - 外观模式(Facade Pattern) - 享元模式(Flyweight Pattern) - 代理模式(Proxy Pattern) 3. 行为型模式(Behavioral Patterns): - 责任链模式(Chain of Responsibility Pattern) - 命令模式(Command Pattern) - 解释器模式(Interpreter Pattern) - 迭代器模式(Iterator Pattern) - 中介者模式(Mediator Pattern) - 备忘录模式(Memento Pattern) - 观察者模式(Observer Pattern) - 状态模式(State Pattern) - 策略模式(Strategy Pattern) - 模板方法模式(Template Method Pattern) - 访问者模式(Visitor Pattern) 4. 并发型模式(Concurrency Patterns): - 保护性暂停模式(Guarded Suspension Pattern) - 生产者-消费者模式(Producer-Consumer Pattern) - 读写锁模式(Read-Write Lock Pattern) - 信号量模式(Semaphore Pattern) - 线程池模式(Thread Pool Pattern) 这些设计模式可以根据问题的特点和需求来选择使用,它们提供了一些可复用的解决方案,有助于开发高质量、可维护且易于扩展的软件系统。

“相关推荐”对你有帮助么?

  • 非常没帮助
  • 没帮助
  • 一般
  • 有帮助
  • 非常有帮助
提交
评论
添加红包

请填写红包祝福语或标题

红包个数最小为10个

红包金额最低5元

当前余额3.43前往充值 >
需支付:10.00
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包

打赏作者

小达人Fighting

你的鼓励将是我创作的最大动力

¥1 ¥2 ¥4 ¥6 ¥10 ¥20
扫码支付:¥1
获取中
扫码支付

您的余额不足,请更换扫码支付或充值

打赏作者

实付
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明:

1.余额是钱包充值的虚拟货币,按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载,可以购买VIP、付费专栏及课程。

余额充值