2014/7/20 组合模式

最新推荐文章于 2024-09-15 22:03:14 发布
最新推荐文章于 2024-09-15 22:03:14 发布
阅读量412 收藏
点赞数
分类专栏： 设计模式 文章标签： 设计模式
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/u010953536/article/details/37991153
版权

一：组合模式例子：

附上源码：

类图参见书p241

IRoot.java

package combinePattern;

import java.util.ArrayList;

//根节点接口
public interface IRoot
{
	public String getInfo();
	public void add(IBranch branch);
	public void add(ILeaf leaf);
	public ArrayList getSubordinateInfo();
}

Root.java 

package combinePattern;

import java.util.ArrayList;

//根节点实现
public class Root implements IRoot {

	//下级的树枝节点和树叶节点
	private ArrayList subordinateList = new ArrayList();
	//根节点名称
	private String name = "";
	//根节点职位
	private String position = "";
	//根节点薪水
	private int salary = 0;
	
	public Root(String name,String positon,int salary)
	{
		this.name = name;
		this.position = position;
		this.salary = salary;
	}
	
	public void add(IBranch branch) 
	{
		this.subordinateList.add(branch);
	}

	public void add(ILeaf leaf)
	{
		this.subordinateList.add(leaf);
	}

	public String getInfo() 
	{
		String info = "";
		info = "名称:"+this.name;
		info += "\t职位:"+this.position;
		info += "\t薪水:"+this.salary;
		return info;
	}

	public ArrayList getSubordinateInfo()
	{
		return this.subordinateList;
	}

}

IBranch.java 

package combinePattern;

import java.util.ArrayList;

//有分支节点接口
public interface IBranch 
{
	public String getInfo();
	public void add(IBranch branch);
	public void add(ILeaf leaf);
	public ArrayList getSubordinateInfo();
}

Branch.java 

package combinePattern;

import java.util.ArrayList;

//分支节点实现类
public class Branch implements IBranch {

	private ArrayList subordinateList = new ArrayList();
	private String name = "";
	private String position = "";
	private int salary = 0;
	
	public Branch(String name,String position,int salary)
	{
		this.name = name;
		this.position = position;
		this.salary = salary;
	}
	
	public void add(IBranch branch)
	{
		this.subordinateList.add(branch);
	}

	public void add(ILeaf leaf) 
	{
		this.subordinateList.add(leaf);
	}

	public String getInfo() 
	{
		String info = "";
		info = "名称:"+this.name;
		info += "\t职位:"+this.position;
		info += "\t薪水:"+this.salary;
		return info;
	}

	public ArrayList getSubordinateInfo()
	{
		return this.subordinateList;
	}

}

ILeaf.java 

package combinePattern;

//叶子节点的接口
public interface ILeaf 
{
	public String getInfo();
}

Leaf.java 

package combinePattern;

public class Leaf implements ILeaf 
{
    private String name = "";
    private String position = "";
    private int salary = 0;
    
    public Leaf(String name,String position,int salary)
    {
    	this.name = name;
    	this.position = position;
    	this.salary = salary;
    }
	
	public String getInfo() 
	{
		String info = "";
		info = "名称:"+this.name;
		info += "\t职位:"+this.position;
		info += "\t薪水:"+this.salary;
		return info;
	}

}

Client.java 

package combinePattern;

import java.util.ArrayList;

public class Client 
{
	public static void main(String[] args)
	{
		//根节点
		IRoot ceo = new Root("王大麻子","总经理",100000);
		//树枝节点
		IBranch developDep = new Branch("刘大瘸子","研发部门经理",30000);
		IBranch salesDep = new Branch("马二拐子","销售部门经理",20000);
		IBranch financeDep = new Branch("赵三驼子","财务部门经理",10000);
		//小组长
		IBranch firstDevGroup = new Branch("杨三乜斜","开发一组组长",5000);
		IBranch secondDevGroup = new Branch("吴大棒槌","开发二组组长",6000);
		//叶子节点
		ILeaf a = new Leaf("a","开发人员",4000);
		ILeaf b = new Leaf("b","开发人员",4000);
		ILeaf c = new Leaf("c","开发人员",4000);
		ILeaf d = new Leaf("d","开发人员",4000);
		ILeaf e = new Leaf("e","开发人员",4000);
		ILeaf f = new Leaf("f","开发人员",4000);
		ILeaf g = new Leaf("g","开发人员",4000);
		ILeaf h = new Leaf("h","销售人员",2000);
		ILeaf i = new Leaf("i","销售人员",2000);
		ILeaf j = new Leaf("j","财务人员",2000);
		ILeaf k = new Leaf("k","CEO秘书",8000);
		ILeaf zhengLaoLiu = new Leaf("郑老六","研发部副总",20000);
		
		//组装树
		ceo.add(developDep);
		ceo.add(salesDep);
		ceo.add(financeDep);
		ceo.add(k);
		developDep.add(firstDevGroup);
		developDep.add(secondDevGroup);
		developDep.add(zhengLaoLiu);
		firstDevGroup.add(a);
		firstDevGroup.add(b);
		firstDevGroup.add(c);
		secondDevGroup.add(d);
		secondDevGroup.add(e);
		secondDevGroup.add(f);
		salesDep.add(h);
		salesDep.add(i);
		financeDep.add(j);
		//打印
		System.out.println(ceo.getInfo());
		//遍历
		getAllSubordinateInfo(ceo.getSubordinateInfo());
	}
	
	private static void getAllSubordinateInfo(ArrayList subordinateList)
	{
		int length = subordinateList.size();
		for(int m=0;m<length;m++)
		{
			Object s = subordinateList.get(m);
			if(s instanceof Leaf)
			{
				ILeaf employee = (ILeaf)s;
				System.out.println(((Leaf)s).getInfo());
			}
			else
			{
				IBranch branch = (IBranch)s;
				System.out.println(branch.getInfo());
				getAllSubordinateInfo(branch.getSubordinateInfo());
			}
		}
	}
}

评价：每个接口都有getInfo()方法，所以应该抽象出来

           Root类和Branch类差别不大，合并成一个类

           修改后的类图参见书p247:

附上源码：

ICorp.java

package combinePattern2;

public interface ICorp 
{
	public String getInfo();
}

IBranch.java

package combinePattern2;

import java.util.ArrayList;

public interface IBranch extends ICorp
{
	public void addSubordinate(ICorp corp);
	public ArrayList<ICorp> getSubordinate();
}

Branch.java 

package combinePattern2;

import java.util.ArrayList;

public class Branch implements IBranch {

	private String name = "";
	private String position = "";
	private int salary = 0;
	ArrayList<ICorp> subordinateList = new ArrayList<ICorp>();
	
	public Branch(String name,String position,int salary)
	{
		this.name = name;
		this.position = position;
		this.salary = salary;
	}
	
	public void addSubordinate(ICorp corp) 
	{
		this.subordinateList.add(corp);
	}

	public ArrayList<ICorp> getSubordinate() 
	{
		return this.subordinateList;
	}

	public String getInfo() 
	{
		String info = "";
		info = "名称:"+this.name;
		info += "\t职位:"+this.position;
		info += "\t薪水:"+this.salary;
		return info;
	}

}

ILeaf.java 

package combinePattern2;

public interface ILeaf extends ICorp
{

}

Leaf.java 

package combinePattern2;

public class Leaf implements ILeaf 
{
	private String name = "";
	private String position = "";
	private int salary = 0;
	
	public Leaf(String name,String position,int salary)
	{
		this.name = name;
		this.position = position;
		this.salary = salary;
	}
	
	public String getInfo() 
	{
		String info = "";
		info = "名称:"+this.name;
		info += "\t职位:"+this.position;
		info += "\t薪水:"+this.salary;
		return info;
	}

}

Client.java 

package combinePattern2;

import java.util.ArrayList;


public class Client
{
	public static void main(String[] args)
	{
		//调用组装函数：先组装一棵树
		Branch ceo = compositeCorpTree();
		//打印ceo节点
		System.out.println(ceo.getInfo());
		//调用遍历函数
		System.out.println(getTreeInfo(ceo));
	}
	
	public static Branch compositeCorpTree()
	{
		Branch root = new Branch("王大麻子","总经理",100000);
		Branch developDep = new Branch("刘大瘸子","研发部门经理",30000);
		Branch salesDep = new Branch("马二拐子","销售部门经理",20000);
		Branch financeDep = new Branch("赵三驼子","财务部门经理",10000);
		Branch firstDevGroup = new Branch("杨三乜斜","开发一组组长",5000);
		Branch secondDevGroup = new Branch("吴大棒槌","开发二组组长",6000);
		Leaf a = new Leaf("a","开发人员",4000);
		Leaf b = new Leaf("b","开发人员",4000);
		Leaf c = new Leaf("c","开发人员",4000);
		Leaf d = new Leaf("d","开发人员",4000);
		Leaf e = new Leaf("e","开发人员",4000);
		Leaf f = new Leaf("f","开发人员",4000);
		Leaf g = new Leaf("g","开发人员",4000);
		Leaf h = new Leaf("h","销售人员",2000);
		Leaf i = new Leaf("i","销售人员",2000);
		Leaf j = new Leaf("j","财务人员",2000);
		Leaf k = new Leaf("k","CEO秘书",8000);
		Leaf zhengLaoLiu = new Leaf("郑老六","研发部副总",20000);
		
		//组装
		root.addSubordinate(k);
		root.addSubordinate(developDep);
		root.addSubordinate(salesDep);
		root.addSubordinate(financeDep);
		developDep.addSubordinate(zhengLaoLiu);
		developDep.addSubordinate(firstDevGroup);
		developDep.addSubordinate(secondDevGroup);
		firstDevGroup.addSubordinate(a);
		firstDevGroup.addSubordinate(b);
		firstDevGroup.addSubordinate(c);
		secondDevGroup.addSubordinate(d);
		secondDevGroup.addSubordinate(e);
		secondDevGroup.addSubordinate(f);
		salesDep.addSubordinate(h);
		salesDep.addSubordinate(i);
		financeDep.addSubordinate(j);
		return root;
	}
	
	public static String getTreeInfo(Branch root)
	{
		ArrayList<ICorp> subordinateList = root.getSubordinate();
		String info = "";
		for(ICorp s : subordinateList)
		{
			//是叶子节点就直接输出信息
			if(s instanceof Leaf)
			{
				info += s.getInfo()+"\n";
			}
			else
			{
				info += s.getInfo()+"\n"+getTreeInfo((Branch)s);
			}
		}
		return info;
	}
}

继续改进：将接口改成抽象类，把方法放到具体实现类中，场景类只和抽象类进行交互

类图参见书p251

附上改进后的源码：

Corp.java

package combinePattern3;

public abstract class Corp 
{
	private String name = "";
	private String position = "";
	private int salary = 0;
	
	public Corp(String _name,String _position,int _salary)
	{
		this.name = _name;
		this.position = _position;
		this.salary = _salary;
	}
	
	public String getInfo()
	{
		String info = "";
		info = "名称:"+this.name;
		info += "\t职位:"+this.position;
		info += "\t薪水:"+this.salary;
		return info;
	}
}

Leaf.java 

package combinePattern3;

public class Leaf extends Corp
{
	public Leaf(String name, String position, int salary) {
		super(name, position, salary);
		// TODO Auto-generated constructor stub
	}
}

Branch.java 

package combinePattern3;

import java.util.ArrayList;

public class Branch extends Corp
{
	ArrayList<Corp> subordinateList = new ArrayList<Corp>();
	
	public Branch(String name, String position, int salary) {
		super(name, position, salary);
		// TODO Auto-generated constructor stub
	}

	public void addSubordinate(Corp corp)
	{
		this.subordinateList.add(corp);
	}
	
	public ArrayList<Corp> getSubordinate()
	{
		return this.subordinateList;
	}
}

二：组合模式的定义：

组合模式的几个角色：

1.Component抽象构建角色：定义参加组合对象的共有方法和属性

2.Leaf叶子构件：叶子对象，遍历的最小单位

3.Composite树枝构件：树枝对象，组合树枝节点和叶子节点形成一个树形结构

通用源码如下：

Component.java

package compositePattern;

//抽象构件
public abstract class Component 
{
	public void doSomething()
	{
		//编写业务逻辑
	}
}

Composite.java 

package compositePattern;

import java.util.ArrayList;

//树枝构件
public class Composite extends Component
{
	private ArrayList<Component> componentArrayList = new ArrayList<Component>();
	
	//增加一个叶子构件或树枝构件
	public void add(Component component)
	{
		this.componentArrayList.add(component);
	}
	
	//删除一个叶子构件或树枝构件
	public void remove(Component component)
	{
		this.componentArrayList.remove(component);
	}
	
	public ArrayList<Component> getChildren()
	{
		return this.componentArrayList;
	}
}

Leaf.java 

package compositePattern;

public class Leaf extends Component
{
	/*可以覆写该方法doSomething()*/
}

Client.java 

package compositePattern;

public class Client 
{
	public static void main(String[] args)
	{
		//创建一个根节点
		Composite root = new Composite();
		root.doSomething();
		//创建一个树枝构件
		Composite branch = new Composite();
		//创建一个叶子节点
		Leaf leaf = new Leaf();
		//构件树
		root.add(branch);
		branch.add(leaf);
	}
	
	//递归遍历树
	public static void display(Composite root)
	{
		for(Component c : root.getChildren())
		{
			if(c instanceof Leaf)//叶子节点
				c.doSomething();
			else //树枝节点
				display((Composite)c);
		}
	}
}


zackok
关注
专栏目录
ClickHouse 创建数据库/建表/视图/字典 SQL
程序员光剑
04-02 3万+
1.1. ClickHouseSQL之数据定义语言 DDL本节介绍 ClickHouse 中进行数据库、表结构的定义和管理。1.1.1.概述在SQL中，数据定义语言( DDL ) 用来创建和修改数据库Schema，例如表、索引和用户等。其中数据库的Schema描述了用户数据模型、字段和数据类型。DDL 语句类似于用于定义数据结构的计算机编程语言。常见DDL 语句包括...
TLS/SSL基础介绍
哎呦喂的博客
11-03 1489
Transport Layer Security（TLS）和它早期版本Secure Sockets Layer（SSL）为网络加密协议，TLS协议是在SSL协议的基础上进行改进升级，他们主要用于在计算机网络上提供通信安全。其早期一些版本被广泛使用于web浏览器、email、即时通信、VoIP等。web网站通过该协议能够保证浏览器于服务器之间的安全通信。 SSL/TLS协议主要提供通信过程数据的保...
语音识别/合成开源项目
Manketon的专栏
04-10 6440
转自：https://blog.csdn.net/github_19776427/article/details/52530066语音识别项目：http://www.oschina.net/project/tag/203/tts-speech sf.net http://www.codesoso.net/Search?q=%D3%EF%D2%F4%CA%B6%B1%F0&amp;l=chttp:/...
Spring Cloud 学习笔记（1 / 3）
KISS
03-03 21万+
Spring Cloud 学习笔记（2 / 3） Spring Cloud 学习笔记（3 / 3） - - - 01_前言闲聊和课程说明 02_零基础微服务架构理论入门 03_第二季Boot和Cloud版本选型 04_Cloud组件停更说明 05_父工程Project空间新建 06_父工程pom文件 07_复习DependencyManagement和Dependencies 08_支付模块构建(上) 09_支付模块构建(中) 10_支付模块构建(下) 11_热部署Devtool
23种设计模式
DylanWu123的博客
07-17 1450
创建型模式 创建型模式(Creational Pattern)对类的实例化过程进行了抽象，能够将软件模块中对象的创建和对象的使用分离。为了使软件的结构更加清晰，外界对于这些对象只需要知道它们共同的接口，而不清楚其具体的实现细节，使整个系统的设计更加符合单一职责原则。 创建型模式在创建什么(What)，由谁创建(Who)，何时创建(When)等方面都为软件设计者提供了尽可能大的灵活性。创建型模式...
需求与商业模式分析-2-商业模式类型
SpriCoder的博客
02-28 1万+
需求与商业模式分析-2-商业模式类型
CentOS7 (精简操作指令)
e891377的专栏
05-04 1976
CentOS7 检查查看精简指令： //////////////////////////检查查看精简指令：///////////////////////////////  /////////////////////////////////////////////////////////////////  //////////////////////////////////////////
ISO/IEC 27002:2022中文版
single_element的博客
04-30 1万+
ISO/IEC 27002:2022 信息安全，网络安全与隐私保护 ——信息安全控制 *试译交流版 *
通俗理解LDA主题模型(2014年版)
热门推荐
结构之法 算法之道
11-17 32万+
印象中，最开始听说“LDA”这个名词，是缘于rickjin在2013年3月写的一个LDA科普系列，叫LDA数学八卦，我当时一直想看来着，记得还打印过一次，但不知是因为这篇文档的前序铺垫太长（现在才意识到这些“铺垫”都是深刻理解LDA 的基础，但如果没有人帮助初学者提纲挈领、把握主次、理清思路，则很容易陷入LDA的细枝末节之中），还是因为其中的数学推导细节太多，导致一直没有完整看完过。2013年12月，在我组织的Machine Learning读书会第8期。
C/C++超级大火锅
This is bill的专属博客
03-15 9288
写在前面最近接触到一些基础知识，平时遇到的编程困惑也加入其中。准确说是写给自己看的，但是如果大家可以借鉴就更好。多数是c/c++，也有少量java基础和其他知识，貌似应该叫《计算机基础问题汇总》比较好。不断更新~~一、new 跟 malloc 的区别是什么？1.malloc/free是C/C++语言的标准库函数，new/delete是C++的运算符2.new能够自动分配空间大小3.对于用户自定义的对
C++设计模式7：桥接模式
琅嬛福地
04-25 365
桥接模式（Bridge Pattern）是一种结构型设计模式，它将抽象部分和实现部分分离，使它们可以独立地变化。这种模式通过将继承关系转化为组合关系来解决类间的耦合问题。在桥接模式中，抽象部分由一个抽象类或接口来定义，它包含了一些抽象方法和属性，这些方法和属性需要由具体的实现类来实现。而实现部分则由一个实现类或接口来定义，它也包含了一些实现方法和属性，这些方法和属性需要被抽象部分调用。桥接模式的核心思想就是将抽象部分和实现部分分离，使它们可以独立地变化。
C++设计模式11：享元模式
琅嬛福地
04-26 531
享元模式（Flyweight Pattern）是一种结构型设计模式，它通过共享对象来减少内存使用和提高性能。在该模式中，我们将需要共享的对象（如字母、数字、图形等）抽象成一个对象接口，然后通过工厂类来维护这些对象的唯一实例，并在需要的时候进行共享，避免了重复创建大量的对象。享元模式的核心思想是将一个对象的状态分成内部状态和外部状态。内部状态是可以共享的，而外部状态则需要通过参数传递进来。对于相同的内部状态，享元模式只会创建一次实例，并在需要的时候进行共享，从而节约了内存空间。
【 Qt 的“前世”与“今生”】Qt 的起源 | Qt 的发展历程 | 为什么选择 Qt | Qt 的授权模式 | Qt 版本选择 | Qt Widgets和QML | Qt 程序发布
dvlinker的技术专栏
12-03 2万+
【 Qt 的“前世”与“今生”】Qt 的起源 | Qt 的发展历程 | 为什么选择 Qt | Qt 的授权模式 | Qt 版本选择 | Qt Widgets和QML | Qt 程序发布
golang设计模式——结构模式
qq_39280718的博客
09-03 698
结构模式主要关注类和对象的组合
24下半年学习计划
2301_80336512的博客
09-08 2064
上课的时候认真听，不要以为提前了解一些知识就认为不重要，不听也要坚持看书，不要被外界吸引。我以后大概率走后端方向，对于后端的一些技术栈目前只是跟着网上的教程学，网上的教程大部分。只适合入门，对其原理背后的实行的机制还是需要看一些经典书籍，因此在这一学期除了完成实验。《设计模式之美》，提高自己编写代码的规范性，了解设计原理，养成良好的写代码习惯。，数据库对于后端开发者来说十分重要，这一部分知识要熟悉掌握。早睡早起，少熬夜，最好是每天早晨记10个单词，晚上睡前复习。
结构者设计模式
m0_68570169的博客
09-10 1305
结构者模式帮助我们以不同的方式组织和构建系统中的类和对象，从而提高系统的灵活性和可维护性。通过合理选择和应用这些模式，可以有效地管理和扩展系统的复杂性。
C++设计模式
最新发布
叫好与叫座虽然不是对立面，但想在同一个作品中达到双重效果很难。
09-15 1403
Abstract Factory 抽象工厂模式：提供一个创建一系列相关或相互依赖对象的接口，而无需指定它们具体的类。Adapter适配器模式：将一个类的接口转换成客户希望的另外一个接口。Adapter模式使得原本由于接口不兼容而不能一起工作的那些类可以一起工 作。Bridge桥接模式：将抽象部分与它的实现部分分离，使它们都可以独立地变 化。Builder建造者模式：将一个复杂对象的构建与它的表示分离，使得同样的构建 过程可以创建不同的表示。
常用设计模式的通俗解释和c语言实现
markey1的博客
09-10 618
【代码】常用设计模式的通俗解释和c语言实现。
《程序猿之设计模式实战 · 策略模式》
山人行
09-12 1193
近期，无论是编码还是休闲阶段，偶尔都会刷到关于设计模式的相关内容，发掘可以整理的内容还不少，就想着归纳高低给它整一个专栏。网上介绍23种设计模式的内容也不少，大多枯燥而冗长，这边不会重复搬砖，也不会按顺序介绍所有设计模式，只会从实战层面去分享几个实用的。好了，废话不多说，先开始最常用的策略模式吧。题外话有的人认为设计模式很有用，遵循了面向对象等开发原则，可以提升代码复用，提高可维护性，便于后期的功能扩展。
电大2014数据库应用技术试题解析
"电大2014数据库应用技术复习题" 这部分内容主要涵盖了数据库应用技术的基础知识，包括数据模型、数据库管理系统（DBMS）的功能、数据库设计与规范化的概念，以及SQL语言的基本操作。让我们逐一深入探讨这些知识点...
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

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

余额充值