系列文章目录
分公司不就是一种部门吗
现在有这样一个项目，是为一家在全国许多城市都有分销机构的大公司做办公管理系统，总部有人力资源、财务、运营灯部门。这是一个常见的OA系统，如果需求分析好了的话，开发相对较容易，但是这家公司用了软件之后感觉不错，现在他们希望可以在他们的全部分公司推广，他们在北京有总部，在全国几大城市设有分公司，比如在上海设有分部，然后在一些省会城市还设有办事处，像南京办事处、杭州办事处，现在面对的问题是，总公司的人力资源部、财务部等办公管理功能在所有的分公司或者办事处都有。
总部、分布和办事处是成树状结构的，也就是有组织结构的，不可以简单的平型管理，实际开发时就得一个一个的判断他是总部还是分公司的财务，然后在执行其相应的方法。
这种部分与整体的情况很多见，比如卖电脑的商家，可以卖单独配件，也可以卖组装整机，又比如说复制文件，可以一个一个的复制粘贴，也可以整个文件夹复制。其本质都是一样的问题。分公司或办事处和总公司的关系，也就是部分和整体的关系。这其实就是整体与部分可以被一致对待的问题。
在这个项目中，如果把北京总公司当做一个大树的根部的话，他的下属分公司其实就是这棵树的分支，至于办事处就是更小的分支，而他们相关的职能部门由于设有分支了，所以可以理解为树叶。也就是说我们所希望的总部的财务部管理功能也最好是能复用到子公司，那么最好的方法就是，我们在处理总公司的财务管理功能和处理子公司的财务管理功能方法是一样的。
组合模式
组合模式结构图：
Component为组合中的对象声明结口，在适当情况下，实现所有类共有接口的默认行为。声明一个接口用于访问和管理Component的子部件。
abstract class Component{
protected String name;
public Component(String name){
this.name = name;
}
public abstract void add(Component component);
public abstract void remove(Component component);
public abstract void display(int depth);
}
Leaf在组合中表示叶节点对象，叶节点没有子节点。
class Leaf extends Component{
public Leaf(String name){
super(name);
}
//由于叶子没有再增加分支和树叶，所以Add和Remove方法实现它没有意义，但这样做可以消除叶节点和支节点对象在抽象层次的区别，他们具备完全一致的接口
@Override
public void add(Component component) {
System.out.println("can not add a leaf");
}
@Override
public void remove(Component component) {
System.out.println("can not remove from a leaf");
}
@Override
public void display(int depth) {
for(int i = 0;i<depth;i++){
System.out.println("-");
}
System.out.println(name);
}
}
Composite定义有枝节点行为，用来存储子部件，在Component接口中实现与子部件有关的操作，比如增加add和删除remove
class Composite extends Component{
private ArrayList<Component> children = new ArrayList<Component>();
public Composite(String name){
super(name);
}
@Override
public void add(Component component) {
children.add(component);
}
@Override
public void remove(Component component) {
children.remove(component);
}
@Override
public void display(int depth) {
//显示其支节点名称
for(int i = 0;i<depth;i++){
System.out.println("-");
}
System.out.println(name);
//对其下级进行遍历
for(Component item : children){
item.display(depth + 2);
}
}
}
客户端代码，能通过Component接口操作组合部件的对象
public static void main(String[] args) {
Component root = new Composite("root");
root.add(new leaf("leafA"));
root.add(new leaf("leafB"));
Composite comp = new Composite("composite X");
comp.add(new leaf("leafXA"));
comp.add(new leaf("leafXB"));
root.add(comp);
Composite comps =new Composite("Composite XY");
comps.add(new leaf("Leafxya"));
comps.add(new leaf("Leafxyb"));
leaf leaf = new leaf("Leaf C");
leaf leaf2 = new leaf("Leaf D");
root.add(leaf2);
root.remove(leaf2);
root.display(1);
}
结果显示：
透明方式与安全方式
树可能有无数的分支，但只需要反复用Composite就可以实现树桩结构了。这里为什么Leaf当中也有add和remove,树叶不可以再长分支，其实这种方式叫透明方式，也就是说，在Component中声明的所有用来管理子对象的方法，其中包括add和remove等，这样实现Component接口的所有子类都具备了add和remove。这样做的好处就是叶节点和枝节点对于外界没有区别，他们具备完全一致的行为接口，但问题也明显，因为Leaf类本身不具备add()、remove()方法的功能，所以实现它是没有意义的。
如果我不希望做这样的无用功，Leaf类中不用add和remove方法呢？这里就需要用到安全方式，也就是在Component接口中不去声明add和remove方法，那么子类的Leaf也就不需要去实现它，而是在Composite中声明所有用来管理子类对象的方法 这样做就不会出现刚才的问题，不过由于不够透明，所以树叶和树枝类将不具有相同的接口，客户端的调用需要做相应的判断，带来了不便。
何时使用组合模式
当你发现需求中是体现部分与整体层次结构时，以及你希望用户可以忽略组合对象与单个对象的不同，统一的使用组合结构中的所有对象时，就应该考虑用组合模式了。
’
公司管理系统代码
公司类：抽象类或接口
//公司抽象类
abstract class Company{
protected String name;
public Company(String name){
this.name = name;
}
public abstract void add(Company company);
public abstract void remove(Company company);
public abstract void display(int depth);
public abstract void lineOfDuty(); //履行职责，不同部门需要履行不同职责
}
具体公司类：实现接口，树枝节点
//具体分公司类，树枝节点
class ConcreteCompany extends Company{
private ArrayList<Company> children = new ArrayList<Company>();
public ConcreteCompany(String name){
super(name);
}
@Override
public void add(Company company) {
children.add(company);
}
@Override
public void remove(Company company) {
children.remove(company);
}
@Override
public void display(int depth) {
for(int i = 0;i<depth;i++){
System.out.println("-");
}
System.out.println(name);
for(Company item : children){
item.display(depth + 2);
}
}
//履行职责
@Override
public void lineOfDuty() {
for(Company item : children){
item.lineOfDuty();
}
}
}
人力资源部与财务类：
//人力资源部与财务类
class HRDepartment extends Company{
public HRDepartment(String name){
super(name);
}
@Override
public void add(Company company) {
}
@Override
public void remove(Company company) {
}
@Override
public void display(int depth) {
for(int i =0;i<depth;i++){
System.out.println("-");
}
System.out.println(name);
}
@Override
public void lineOfDuty() {
System.out.println(name + "员工招聘培训管理");
}
}
财务部，树叶节点
class FinanceDepartment extends Company{
public FinanceDepartment(String name){
super(name);
}
@Override
public void add(Company company) {
}
@Override
public void remove(Company company) {
}
@Override
public void display(int depth) {
for(int i =0;i<depth;i++){
System.out.print("-");
}
System.out.println(name);
}
//履行职责
@Override
public void lineOfDuty() {
System.out.println(name + ",公司财务收支管理");
}
}
客户端代码：
public static void main(String[] args) {
ConcreteCompany root = new ConcreteCompany("北京总公司");
root.add(new HRDepartment("总公司人力资源部"));
root.add(new FinanceDepartment("总公司财务部"));
ConcreteCompany comp = new ConcreteCompany("上海华东分公司");
comp.add(new HRDepartment("华东分公司人力资源部"));
comp.add(new FinanceDepartment("华东分公司财务部"));
root.add(comp);
ConcreteCompany comp2 = new ConcreteCompany("南京办事处");
comp2.add(new HRDepartment("南京办事处人力资源部"));
comp2.add(new FinanceDepartment("南京办事处财务部"));
comp.add(comp2);
ConcreteCompany comp3 = new ConcreteCompany("杭州办事处");
comp3.add(new HRDepartment("杭州办事处人力资源部"));
comp3.add(new FinanceDepartment("杭州办事处财务部"));
comp.add(comp3);
System.out.println("结构图 : ");
root.display(1);
System.out.println("职责");
root.lineOfDuty();
}
结果显示：
组合模式好处
组合模式 这样就定义了包含人力资源部和财务部这些基本对象的分公司、办事处等组合对象的类层次结构。基本对象可以被组合成更复杂的组合对象，而这个组合对象又可以被组合，这样不断的递归下去，客户代码中，任何用到基本对象的地方都可以使用组合对象了 。另外，用户是不用关心到底是处理一个叶节点还是处理一个组合组件，也就用不着为定义组合而写一些判断语句了。 就是组合模式可以让客户一致的使用组合结构和单个对象。
总结
以上就是本文全部内容，本文主要向大家介绍了设计模式中的组合模式，通过对一个项目的需求来引出组合模式的基本代码，之后基于项目需求，得出组合模式在该项目上的应用。感谢各位能够看到最后，如有问题，欢迎各位大佬在评论区指正，希望大家可以有所收获！创作不易，希望大家多多支持！