组合设计模式

一、组合设计模式

1、介绍

  • 组合模式（Composite Pattern），又叫部分整体模式，它创建了对象组的树形结构。将对象组合成树状结构以表示“整体-部分”的层次关系
  • 组合模式依据树形结构来组合对象，用来表示部分以及整体层次
  • 组合模式属于结构型模式
  • 组合模式使得用户对单个对象和组合对象的访问具有一致性。即：组合能让客户以一致的方式处理个别对象以及组合对象

2、原理UML类图

  • Component：这是组合中对象声明接口，定义或实现公共有的接口默认行为，用于访问和管理Component子部件，Component可以是抽象类或接口
  • Composite：非叶子节点，用于存储子部件，在Component接口中实现子部件的相关操作，比如增加、删除、操作
  • Leaf：在组合中表示叶子节点，叶子节点没有子节点

3、组合模式优点和使用

  • 简化客户端操作。客户端只需面对一致的对象而不用考虑整体部分或者节点的问题
  • 具有较强扩展性。当我们要更改组合对象时，我们只需要调整内部的层次关系。客户端不用做出任何改动
  • 方便创建出复杂的层次结构。客户端不用理会组合里面的组成细节，容易添加节点或者叶子，从而创建出复杂的树形结构
  • 需要遍历组织机构，或者处理的对象具有树形结构时，非常适合使用组合模式
  • 要求较高的抽象性，如果节点和叶子有很多差异性的话。比如很多方法和树形不一样，那么不适合使用组合模式

二、普通设计编程

1、介绍

公司、部门、组构成三个层次。

公司包含部门，部门包含组。

如果没有学过组合设计模式，我们一开始的解决方法会如下方所示。Company类聚合Department类，Department类聚合Group类。

此种方法的优势在于简单、容易理解。

但是对于客户端来说，操作复杂，无论我们是增加还是删除一个公司下的部门（或部门下的组），涉及的代码较多。同时这种设计也不利于管理。

2、UML

3、代码

  1. import java.util.List;
  3. /**
  4.  * @description: 公司
  5.  * @author: dashu
  6.  * @create: 10:43
  7.  */
  8. public class Company {
  10.     /**
  11.      * 名称
  12.      */
  13.     private String name;
  15.     /**
  16.      * 部门
  17.      */
  18.     private List<Department> departments;
  20.     public String getName() {
  21.         return name;
  22.     }
  24.     public void setName(String name) {
  25.         this.name = name;
  26.     }
  28.     public List<Department> getDepartments() {
  29.         return departments;
  30.     }
  32.     public void setDepartments(List<Department> departments) {
  33.         this.departments = departments;
  34.     }
  36.     public void print(){
  37.         System.out.println("-----"+name+"-----");
  38.         for (Department department : departments){
  39.             System.out.println("---"+department.getName()+"---");
  40.             for (Group group : department.getGroups()){
  41.                 System.out.println(group.getName());
  42.             }
  43.         }
  44.     }
  47. }
  1. import java.util.List;
  3. /**
  4.  * @description: 部门
  5.  * @author: dashu
  6.  * @create: 10:55
  7.  */
  8. public class Department {
  10.     /**
  11.      * 名称
  12.      */
  13.     private String name;
  15.     /**
  16.      * 组
  17.      */
  18.     private List<Group> groups;
  21.     public String getName() {
  22.         return name;
  23.     }
  26.     public void setName(String name) {
  27.         this.name = name;
  28.     }
  31.     public List<Group> getGroups() {
  32.         return groups;
  33.     }
  36.     public void setGroups(List<Group> groups) {
  37.         this.groups = groups;
  38.     }
  41.     public void print() {
  42.         System.out.println("---" + name + "---");
  43.         for (Group group : groups) {
  44.             System.out.println(group.getName());
  45.         }
  46.     }
  48. }
  1. /**
  2.  * @description: 组
  3.  * @author: dashu
  4.  * @create: 10:58
  5.  */
  6. public class Group {
  8.     /**
  9.      * 名称
  10.      */
  11.     private String name;
  14.     public String getName() {
  15.         return name;
  16.     }
  18.     public void setName(String name) {
  19.         this.name = name;
  20.     }
  23.     public void print() {
  24.         System.out.println(name);
  25.     }
  27. }
  1. import java.util.ArrayList;
  2. import java.util.List;
  4. /**
  5.  * @description: 客户端
  6.  * @author: dashu
  7.  * @create: 10:40
  8.  */
  9. public class Client {
  11.     public static void main(String[] args) {
  14.         Company company = new Company();
  15.         company.setName("软件开发公司");
  16.         List<Department> departments = new ArrayList<Department>();
  17.         company.setDepartments(departments);
  20.         Department department1 = new Department();
  21.         department1.setName("研发部");
  22.         List<Group> groups = new ArrayList<Group>();
  23.         department1.setGroups(groups);
  24.         Group groupA = new Group();
  25.         groupA.setName("A组");
  26.         groups.add(groupA);
  27.         Group groupB = new Group();
  28.         groupB.setName("B组");
  29.         groups.add(groupB);
  30.         departments.add(department1);
  33.         Department department2 = new Department();
  34.         department2.setName("财务部");
  35.         List<Group> groups2 = new ArrayList<Group>();
  36.         department2.setGroups(groups2);
  37.         Group groupC = new Group();
  38.         groupC.setName("C组");
  39.         groups2.add(groupC);
  40.         Group groupD = new Group();
  41.         groupD.setName("D组");
  42.         groups2.add(groupD);
  43.         departments.add(department2);
  46.         company.print();
  49.     }
  51. }

二、组合设计模式编程

1、介绍

组合模式使得用户对单个对象和组合对象的访问具有一致性。即：组合能让客户以一致的方式处理个别对象以及组合对象

2、UML

3、代码

  1. /**
  2.  * @description: 组织组件
  3.  * @author: dashu
  4.  * @create: 11:28
  5.  */
  6. public abstract class OrganizationComponent {
  8.     private String name;
  10.     public OrganizationComponent(String name){
  11.         this.name = name;
  12.     }
  14.     /**
  15.      * 添加组织
  16.      * @param organizationComponent
  17.      */
  18.     protected void add(OrganizationComponent organizationComponent){
  19.         throw new UnsupportedOperationException();
  20.     }
  22.     /**
  23.      * 删除组织
  24.      * @param organizationComponent
  25.      */
  26.     protected void remove(OrganizationComponent organizationComponent){
  27.         throw new UnsupportedOperationException();
  28.     }
  30.     public String getName() {
  31.         return name;
  32.     }
  34.     public void setName(String name) {
  35.         this.name = name;
  36.     }
  38.     /**
  39.      * 抽象打印方法
  40.      */
  41.     protected abstract void print();
  42. }
  1. /**
  2.  * @description: 公司
  3.  * @author: dashu
  4.  * @create: 10:43
  5.  */
  6. public class Company extends OrganizationComponent{
  8.     /**
  9.      * 名称
  10.      */
  11.     private String name;
  13.     public Company(String name) {
  14.         super(name);
  15.     }
  17.     private List<OrganizationComponent> organizationComponents = new ArrayList<OrganizationComponent>();
  20.     @Override
  21.     protected void add(OrganizationComponent organizationComponent) {
  22.         organizationComponents.add(organizationComponent);
  23.     }
  25.     @Override
  26.     protected void remove(OrganizationComponent organizationComponent) {
  27.         organizationComponents.remove(organizationComponent);
  28.     }
  31.     @Override
  32.     public void print(){
  33.         System.out.println("-----"+getName()+"-----");
  34.         for (OrganizationComponent organizationComponent : organizationComponents) {
  35.             organizationComponent.print();
  36.         }
  37.     }
  40. }
  1. import java.util.ArrayList;
  2. import java.util.List;
  4. /**
  5.  * @description: 部门
  6.  * @author: dashu
  7.  * @create: 10:55
  8.  */
  9. public class Department extends OrganizationComponent{
  11.     /**
  12.      * 名称
  13.      */
  14.     private String name;
  16.     public Department(String name) {
  17.         super(name);
  18.     }
  20.     private List<OrganizationComponent> organizationComponents = new ArrayList<OrganizationComponent>();
  22.     @Override
  23.     protected void add(OrganizationComponent organizationComponent) {
  24.         organizationComponents.add(organizationComponent);
  25.     }
  27.     @Override
  28.     protected void remove(OrganizationComponent organizationComponent) {
  29.         organizationComponents.remove(organizationComponent);
  30.     }
  33.     @Override
  34.     public void print() {
  35.         System.out.println("---"+getName()+"---");
  36.         for (OrganizationComponent organizationComponent : organizationComponents) {
  37.             organizationComponent.print();
  38.         }
  39.     }
  41. }
  1. /**
  2.  * @description: 组
  3.  * @author: dashu
  4.  * @create: 10:58
  5.  */
  6. public class Group extends OrganizationComponent{
  8.     /**
  9.      * 名称
  10.      */
  11.     private String name;
  14.     public Group(String name) {
  15.         super(name);
  16.     }
  18.     @Override
  19.     public void print() {
  20.         System.out.println(getName());
  21.     }
  23. }
  1. /**
  2.  * @description: 客户端
  3.  * @author: dashu
  4.  * @create: 11:41
  5.  */
  6. public class Client {
  8.     public static void main(String[] args) {
  10.         OrganizationComponent component = new Company("软件开发公司");
  13.         OrganizationComponent department1 = new Department("研发部");
  15.         OrganizationComponent department2 = new Department("财务部");
  17.         OrganizationComponent a = new Group("A组");
  18.         OrganizationComponent b = new Group("B组");
  19.         OrganizationComponent c = new Group("C组");
  20.         OrganizationComponent d = new Group("D组");
  23.         department1.add(a);
  24.         department1.add(b);
  25.         department2.add(c);
  26.         department2.add(d);
  28.         component.add(department1);
  29.         component.add(department2);
  31.         component.print();
  32.         System.out.println("------------------------");
  33.         department1.print();
  34.         System.out.println("------------------------");
  35.         department2.print();
  39.     }
  41. }