Java二十三设计模式之------组合模式

一、组合模式（Composite）

组合模式有时又叫部分-整体模式在处理类似树形结构的问题时比较方便，看看关系图：

直接来看代码：

 

1. public class TreeNode {  
2.       
3.     private String name;  
4.     private TreeNode parent;  
5.     private Vector<TreeNode> children = new Vector<TreeNode>();  
6.       
7.     public TreeNode(String name){  
8.         this.name = name;  
9.     }  
10.   
11.     public String getName() {  
12.         return name;  
13.     }  
14.   
15.     public void setName(String name) {  
16.         this.name = name;  
17.     }  
18.   
19.     public TreeNode getParent() {  
20.         return parent;  
21.     }  
22.   
23.     public void setParent(TreeNode parent) {  
24.         this.parent = parent;  
25.     }  
26.       
27.     //添加孩子节点  
28.     public void add(TreeNode node){  
29.         children.add(node);  
30.     }  
31.       
32.     //删除孩子节点  
33.     public void remove(TreeNode node){  
34.         children.remove(node);  
35.     }  
36.       
37.     //取得孩子节点  
38.     public Enumeration<TreeNode> getChildren(){  
39.         return children.elements();  
40.     }  
41. }  

 

1. public class Tree {  
2.   
3.     TreeNode root = null;  
4.   
5.     public Tree(String name) {  
6.         root = new TreeNode(name);  
7.     }  
8.   
9.     public static void main(String[] args) {  
10.         Tree tree = new Tree("A");  
11.         TreeNode nodeB = new TreeNode("B");  
12.         TreeNode nodeC = new TreeNode("C");  
13.           
14.         nodeB.add(nodeC);  
15.         tree.root.add(nodeB);  
16.         System.out.println("build the tree finished!");  
17.     }  
18. }  

使用场景：将多个对象组合在一起进行操作，常用于表示树形结构中，例如二叉树，数等。

来源   https://www.cnblogs.com/maowang1991/archive/2013/04/15/3023236.html

二、来个更详细的例子

假设你在公司上班，因为你的公司是大公司，所以旗下有很多子公司，到年终了，公司希望在年会上汇总各个子公司的销售情况，好根据利润在年会上奖励给优秀的子公司，派发给各个员工。好的，现在老板让你计算出这些利润，把数值汇总给他，一再叮嘱你不能出错。老板交给你的事，肯定不能马虎，所以你小心翼翼的写起了代码….

公司的结构图如下:

看到这个结构图，你就在想，该怎么组织代码呢，如果每个公司写一个类，那么一个类中有一个方法，如果公司需要汇总分公司一和旗下子公司的钱，你又要在分公司一和二类里面分别写一个方法，这样算下来，方法就爆炸了,扩展性也不好，如果公司的子公司远不止这么点的话，那就有的你写了…各位码农兄弟们

好的，常规方法介绍完毕，开始我们的设计模式吧!有木有激动啊，(激动个锤子，写代码还激动…)好吧，当我没说.所谓组合模式，一般用来描述部分和整体的关系，类似于数据结构中的树，有根节点，叶子节点。这里的总公司就相当于根节点，两个分公司相当于子节点，子节点下面分别有两个叶子节点。

所以呢，我们具体可以分为以下的几个类:

1.Company抽象类

2.headCompany类(代表总公司)

3.branch_Company1类(代表子公司一)

4.branch_Company2类(代表子公司二)

5.bj_branch类(代表子公司一下的北京公司)

6.sh_branch(代表子公司一下的上海公司)

7.bj_branch类(代表子公司二下的广州公司)

8.sh_branch(代表子公司二下的深圳公司)

9. Client类(主函数，用来调用函数)

(有的网友可能开始喷我了，尼玛，你这样类不一样爆炸了嘛…举得例子不是很适当，主要是理解这种思想!!!其他的忽略一下下)

 

package com.example.tianhaobing;
 
/**
 * @author tianhao
 *公司的抽象类，这里为什么公司使用抽象呢，有的朋友会说，接口也一样啊，如果你也这么认为，那我只能告诉你，
 *朋友，你没搞清楚抽象和接口的区别呀，简单来说吧，抽象类只要是描述什么是什么的关系，而接口表达的是什么像什么
 *的关系。很明显，这里的子公司，分公司，都是公司，所以用抽象来定义，而不用接口
 */
public abstract class Company {
    abstract int make_Money();
    abstract void money_Info();
 
}

package com.example.tianhaobing;
 
import java.util.ArrayList;
import java.util.List;
 
/**
 * @author tianhao 总公司的类
 */
public class headCompany extends Company {
    List<company> Total_Info = new ArrayList<company>(); // 用来打印总公司下面所有公司的信息
    private int money = 1000;// 这里只是举个例子，真正公司赚这么点，早就垮了...
 
    public headCompany(Company company1,Company company2) {
        Total_Info.add(company1);
        Total_Info.add(company2);
    }
 
    @Override
    int make_Money() {
        // TODO Auto-generated method stub
        for (Company company : Total_Info) {
            money += company.make_Money();
        }
        return money;
    } // 公司全年的总支出
 
    @Override
    void money_Info() {
        // TODO Auto-generated method stub
        System.out.println("总公司的收入金额为:" + money);
        for (Company company : Total_Info) {
            company.money_Info();
 
        }
    } // 各个公司的支出信息
 
}

package com.example.tianhaobing;
 
import java.util.ArrayList;
import java.util.List;
 
/**
 * @author tianhao 分公司一的类
 */
public class branch_Company1 extends Company {
    List<company> companys = new ArrayList<company>();// 因为分公司一下面有北京和上海两个子公司，所以可以组合在一起
    private int my_money = 300;
    private int branch1_money=300;
 
    public branch_Company1(Company c1, Company c2) {
        // TODO Auto-generated constructor stub
        companys.add(c1);
        companys.add(c2);
    } // 将两个子公司合并组合起来
 
    @Override
    int make_Money() {
        // TODO Auto-generated method stub
        for (Company company : companys) {
            branch1_money += company.make_Money();
        }
        System.out.println("分公司一和旗下公司收入为:"+branch1_money);
        return branch1_money;
    }
 
    @Override
    void money_Info() {
        // TODO Auto-generated method stub
        System.out.println("分公司一的收入金额为:" + my_money);
        for (Company company : companys) {
            company.money_Info();
        }
 
    }
 
}

package com.example.tianhaobing;
 
import java.util.ArrayList;
import java.util.List;
 
/**
 * @author tianhao 分公司二的类
 */
public class branch_Company2 extends Company {
    List<company> companys = new ArrayList<company>();// 因为分公司二下面有广州和深圳两个子公司，所以可以组合在一起
    private int money = 400;
    private int branch2_money=400;
 
    public branch_Company2(Company c1, Company c2) {
        // TODO Auto-generated constructor stub
        companys.add(c1);
        companys.add(c2);
    } // 将两个子公司合并组合起来
 
    @Override
    int make_Money() {
        // TODO Auto-generated method stub
        for (Company company : companys) {
            branch2_money += company.make_Money();
        }
        System.out.println("分公司二和旗下公司收入为:"+branch2_money);
        return branch2_money;
    }
 
    @Override
    void money_Info() {
        // TODO Auto-generated method stub
        System.out.println("分公司二的收入金额为:" + money);
        for (Company company : companys) {
            company.money_Info();
        }
    }
 
}

package com.example.tianhaobing;
 
/**
 * @author tianhao
 * 
 *         北京公司
 */
public class bj_branch extends Company {
    private int money = 1000;
 
    @Override
    int make_Money() {
        // TODO Auto-generated method stub
        return money;
    }
 
    @Override
    void money_Info() {
        // TODO Auto-generated method stub
        System.out.println("北京公司收入为:" + money);
    }
 
}

package com.example.tianhaobing;
 
public class sh_branch extends Company {
    private int money = 1000;
 
    @Override
    int make_Money() {
        // TODO Auto-generated method stub
        return money;
    }
 
    @Override
    void money_Info() {
        // TODO Auto-generated method stub
        System.out.println("上海公司收入为:" + money);
    }
 
}

package com.example.tianhaobing;
 
public class gz_branch extends Company {
 
    private int money = 1000;
 
    @Override
    int make_Money() {
        // TODO Auto-generated method stub
        return money;
    }
 
    @Override
    void money_Info() {
        // TODO Auto-generated method stub
        System.out.println("广州公司收入为:" + money);
    }
 
}

package com.example.tianhaobing;
 
public class sz_branch extends Company {
    private int money = 1000;
 
    @Override
    int make_Money() {
        // TODO Auto-generated method stub
        return money;
    }
 
    @Override
    void money_Info() {
        // TODO Auto-generated method stub
        System.out.println("深圳公司收入为:" + money);
    }
}

package com.example.tianhaobing;
 
public class Client {
    public static void main(String[] args) {
        bj_branch bj = new bj_branch(); // 北京公司
        sh_branch sh = new sh_branch();// 上海公司
        branch_Company1 branch1 = new branch_Company1(bj, sh);// 将北京和上海两个公司组合到子公司一
 
        sz_branch sz = new sz_branch();// 深圳公司
        gz_branch gz = new gz_branch();// 广州公司
        branch_Company2 branch2 = new branch_Company2(sz, gz);// 将深圳和广州两个公司组合到子公司二
 
 
        headCompany head_Company=new headCompany(branch1,branch2);
        head_Company.money_Info();
        int total_money=head_Company.make_Money();
        System.out.println("公司全部的收入是:"+total_money);
 
 
    }
}

*运行结果如下所示:*

每个类的功能在类中都有详细的解释，其实组合模式在获取公司的利润的时候实质是采用的递归。

来源   https://www.2cto.com/kf/201701/592187.html