大话设计模式_组合模式(Java代码)

组合模式:将对象组合成树形结构以表示“部分-整体”的层次结构。组合模式使得用户对单个对象和组合对象的使用具有一致性。

简单描述:1个Composite类,里面持有一个容器成员,容器可以存入自身

大话设计模式中的截图:

代码例子:

AbstractComponent类:


 1 package com.longsheng.composite;
2
3 public abstract class AbstractComponent {
4
5 public abstract void addComp(AbstractComponent mAbstractComponent);
6
7 public abstract void removeComp(AbstractComponent mAbstractComponent);
8
9 public abstract void display(int depth);
10
11 }

Component类:


 1 package com.longsheng.composite;
2
3 import java.util.ArrayList;
4 import java.util.List;
5
6 public class Component extends AbstractComponent {
7
8 private List<AbstractComponent> container = new ArrayList<AbstractComponent>();
9 private String name;
10
11 public Component(String name) {
12 this.name = name;
13 }
14
15 @Override
16 public void addComp(AbstractComponent mAbstractComponent) {
17 if(mAbstractComponent != null && mAbstractComponent == this) {
18 return;//不能添加自己否则会形成死循环
19 }
20 container.add(mAbstractComponent);
21 }
22
23 @Override
24 public void removeComp(AbstractComponent mAbstractComponent) {
25 if( mAbstractComponent != null && mAbstractComponent == this ) {
26 return;
27 }
28 container.remove(mAbstractComponent);
29 }
30
31 @Override
32 public void display(int depth) {
33 String temp = "";
34 for (int i = 0; i < depth; i++) {
35 temp += "-";
36 }
37 System.out.println(temp + name);
38 for (AbstractComponent mComponent : container) {
39 mComponent.display(depth + 2);
40 }
41 }
42
43 }

Leaf类:


 1 package com.longsheng.composite;
2
3 public class Leaf extends AbstractComponent {
4
5 private String name;
6
7 public Leaf( String name ) {
8 this.name = name;
9 }
10
11 @Override
12 public void addComp(AbstractComponent mAbstractComponent) {
13 }
14
15 @Override
16 public void removeComp(AbstractComponent mAbstractComponent) {
17 }
18
19 @Override
20 public void display(int depth) {
21 String temp = "";
22 for (int i = 0; i < depth; i++) {
23 temp += "-";
24 }
25 System.out.println(temp + name);
26 }
27
28 }

客户端:


 1 package com.longsheng.composite;
2
3 public class Client {
4
5 public static void main(String args[]) {
6 Component mRoot = new Component("总公司");
7 Leaf mRootHR = new Leaf("总公司人力资源部");
8 Leaf mRootFinance = new Leaf("总公司财务部");
9 mRoot.addComp(mRootHR);
10 mRoot.addComp(mRootFinance);
11
12 Component mSub = new Component("华东分公司");
13 Leaf mSubHR = new Leaf("华东分公司人力资源部");
14 Leaf mSubFinance = new Leaf("华东分公司财务部");
15 mSub.addComp(mSubHR);
16 mSub.addComp(mSubFinance);
17
18 Component mNanjing = new Component("南京分公司");
19 Leaf mNanjingHR = new Leaf("南京分公司人力资源部");
20 Leaf mNanjingFinance = new Leaf("南京分公司财务部");
21 mNanjing.addComp(mNanjingHR);
22 mNanjing.addComp(mNanjingFinance);
23
24 Component mHangzhou = new Component("杭州分公司");
25 Leaf mHangzhouHR = new Leaf("杭州分公司人力资源部");
26 Leaf mHangzhouFinance = new Leaf("杭州分公司财务部");
27 mHangzhou.addComp(mHangzhouHR);
28 mHangzhou.addComp(mHangzhouFinance);
29
30 mRoot.addComp(mSub);
31 mSub.addComp(mNanjing);
32 mSub.addComp(mHangzhou);
33
34 mRoot.display(0);
35 }
36
37 }

运行结果:


 1 总公司
2 --总公司人力资源部
3 --总公司财务部
4 --华东分公司
5 ----华东分公司人力资源部
6 ----华东分公司财务部
7 ----南京分公司
8 ------南京分公司人力资源部
9 ------南京分公司财务部
10 ----杭州分公司
11 ------杭州分公司人力资源部
12 ------杭州分公司财务部

Leaf类可以不必继承AbstractComponent类,以和树枝节点区分开,这需要在具体业务中进行选择。

这个模式在图形控件中经常使用,如在Android中,ViewGroup是View的子类,ViewGroup可以装入View;在Java—AWT中,JPanel是一个Component,同时有个add方法可以装入Component

时间: 2024-12-15 06:43:52

大话设计模式_组合模式(Java代码)的相关文章

大话设计模式_备忘录模式(Java代码)

备忘录模式:在不破坏封装性的前提下,捕获一个对象的内部状态,并在该对象之外保存这个状态.这样以后就可将该对象恢复到原先保存的状态. 简单描述:一个Memento类,代表Originator中要备份的属性.Originator负责生成备份和还原备份,CareTaker负责存储备份 大话设计模式中的截图: 例子代码: Memento类: 1 package com.longsheng.memento; 2 3 public class Memento { 4 5 private String sta

大话设计模式_解释器模式(Java代码)

解释器模式:给定一个语言,定义它的文法的一种表示,并定义一个解释器,这个解释器使用该表示来解释语言中的句子. 简单描述:一个AbstractExpression类,多个子类,存在一个Interpret方法,转义Context对象的信息.客户端根据信息实例化不同的Expression类,并调用其转义方法(这个过程可以使用简单工厂+反射进行) 大话设计模式中的截图: 代码例子: 假设HTML代码解释器: (1)第一类标签<HTML>(开始)/<HEAD>(头信息)/<BODY&g

大话设计模式_原型模式(Java代码)

原型模式:用原型实例指定创建对象的种类,并且通过拷贝这些原型创建新的对象 简单描述:即通过实现接口Cloneable重写方法clone(),使得创建新的拷贝对象不需要一个成员一个成员的重新复制,而且可以提高创建对象的效率 Java中要想实现拷贝使用clone()方法,类必须实现Cloneable接口,并且重写Object类中的clone()方法,调用父类的clone()方法即可实现浅复制 代码如下: WorkExperience类: 1 package com.longsheng.prototy

大话设计模式_模板方法模式(Java代码)

模板方法模式:定义一个操作中的算法的骨架,而将一些步骤延迟到子类中.模板方法使得子类可以不改变一个算法的结构即可重定义该算法的某些特定步骤 简单描述:多个类的行为是差不多的,只是某些局部不一样,则交由父类中抽象出这些子类中相同的部分,父类中定义出不同的部分的接口(方法),这些不同部分的方法则由子类去实现,通过多态,实现代码的重用 大话设计模式中的截图: 例子代码: AbstractClass类: 1 package com.longsheng.templatemethod; 2 3 public

大话设计模式_状态模式(Java代码)

状态模式:当一个对象的内在状态改变时允许改变其行为,这个对象看起来像是改变了其类. 简单描述:一个Context类(存有一个抽象状态State引用),调用状态类的方法.State的具体类方法中会判断Context类的状态(如时间),满足一个状态则执行相应动作,否则把Context的State引用指向下一个状态类,由下一个状态类决定相应行为 大话设计模式中的截图: 例子代码: Work类(Context): 1 package com.longsheng.state; 2 3 public cla

大话设计模式_建造者模式(Java代码)

建造者模式:将一个复杂对象的构建与它的表示分离,使得同样的构建过程可以创建不同的表示 简单描述:1个产品类(可有可无,关键是建造流程),1个抽象建造步骤类,多个具体建造子类(不同的类建造不同的产品),1个指挥者(用于规定建造流程),客户端指定需要建造的具体类型,由指挥者建造好之后,建造者子类返回对应产品给客户 大话设计模式中的截图: 例子代码: Product类: 1 package com.longsheng.builder; 2 3 public class Product { 4 5 pr

大话设计模式_策略模式(Java代码)

策略模式:定义算法家族,分别封装,让它们之间可以互相替换,此模式让算法的变化不会影响到使用算法的客户 简单描述:一个父类,多个子类实现具体方法.一个Context类持有父类的引用(使用子类实例化此引用),客户端代码只需要与此Context类交互即可 大话设计模式中的截图: 例子代码: 策略类: 1 package com.longsheng.strategy; 2 3 public abstract class Strategy { 4 5 public abstract double getR

大话设计模式_命令模式(Java代码)

命令模式:将一个请求封装成一个对象,从而使你可用不同的请求对客户进行参数化:对请求排队或记录请求日记,以及支持可撤销的操作. 简单描述:1个Receiver,知道如何执行命令.1个抽象命令,持有一个Receiver的引用,命令的执行则调用Receiver的对应方法(具体命令具体调用相应的方法).1个Invoker,只有命令的引用(可以是一个或多个),接收命令,并且执行命令的执行方法.客户端知道Receiver.生成命令给Invoker,由Invoker去调用命令自己的执行方法 大话设计模式中的截

大话设计模式_桥接模式(Java代码)

合成/聚合复用原则:尽量使用合成/聚合,尽量不要使用类继承. 桥接模式:将抽象部分与它的实现部分分离,使它们都可以独立变化. 解释:即一个系统可以有多种分类实现,把没种分类独立出来,让他们可以独自变化,减少他们之间的耦合. 简单描述:1个Abstraction类,持有一个Implementor的引用,其方法中调用此Implementor引用的对应方法 大话设计模式中的截图: 代码例子: Abstraction类: 1 package com.longsheng.bridge; 2 3 publi