介绍

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

个人总结
对象与对象间的关系是一种树状结构就可以使用组合模式,如一个学校有很多学院,一个学院有很多专业
image-20201007164534732.png

  1. //抽象组织,把学校,学院,专业都看成一个组件,其地位平等，即树的一个节点
  2. public abstract class OrganizationComponent {
  3.     private String name;
  4.     private String desr;
  6.     public OrganizationComponent(String name, String desr) {
  7.         this.name = name;
  8.         this.desr = desr;
  9.     }
  11.     protected void  add(OrganizationComponent organizationComponent){
  12.         //默认实现(可重写也可不重写)
  13.         throw new UnsupportedOperationException(); //抛出这个异常可禁止不重写此方法的继承类不能使用
  14.     }
  16.     protected void  remove(OrganizationComponent organizationComponent){
  17.         //默认实现(可重写也可不重写)
  18.         throw new UnsupportedOperationException();
  19.     }
  21.     protected abstract void print();
  23.     public String getName() {
  24.         return name;
  25.     }
  27.     public void setName(String name) {
  28.         this.name = name;
  29.     }
  31.     public String getDesr() {
  32.         return desr;
  33.     }
  35.     public void setDesr(String desr) {
  36.         this.desr = desr;
  37.     }
  38. }
  1. //学校
  2. public class University extends OrganizationComponent{
  3.     private List<OrganizationComponent> orgs = new ArrayList<>();
  5.     public University(String name, String desr) {
  6.         super(name, desr);
  7.     }
  9.     @Override
  10.     protected void add(OrganizationComponent organizationComponent) {
  11.         orgs.add(organizationComponent);
  12.     }
  14.     @Override
  15.     protected void remove(OrganizationComponent organizationComponent) {
  16.         orgs.remove(organizationComponent);
  17.     }
  19.     @Override
  20.     protected void print() {
  21.         System.out.println("-------------"+getName()+"-------------");
  22.         for (OrganizationComponent org : orgs) {
  23.             org.print();
  24.         }
  25.     }
  26. }
  28. //学院
  29. public class College extends OrganizationComponent{
  30.     private List<OrganizationComponent> orgs = new ArrayList<>();
  32.     public College(String name, String desr) {
  33.         super(name, desr);
  34.     }
  36.     @Override
  37.     protected void add(OrganizationComponent organizationComponent) {
  38.         orgs.add(organizationComponent);
  39.     }
  41.     @Override
  42.     protected void remove(OrganizationComponent organizationComponent) {
  43.         orgs.remove(organizationComponent);
  44.     }
  46.     @Override
  47.     protected void print() {
  48.         System.out.println("-------------"+getName()+"-------------");
  49.         for (OrganizationComponent org : orgs) {
  50.             org.print();
  51.         }
  52.     }
  53. }
  55. //专业
  56. public class Department extends OrganizationComponent{
  58.     public Department(String name, String desr) {
  59.         super(name, desr);
  60.     }
  62.     @Override
  63.     protected void print() {
  64.         System.out.println(getName());
  65.     }
  66. }
  1. //测试
  2. public class testPrint {
  3.     public static void main(String[] args) {
  4.         //学校
  5.         OrganizationComponent university = new University("清华大学", "中国第一学府");
  7.         //学院
  8.        OrganizationComponent xintong = new College("信通学院", "信息通信工程学院");
  9.        OrganizationComponent yishu =new College("艺术学院","艺术学院");
  10.        OrganizationComponent jinmao =new College("经贸学院","经贸学院");
  12.         //专业
  13.         OrganizationComponent xintong1 = new Department("计算机科学与技术", "掉头发专业");
  14.         OrganizationComponent xintong2 = new Department("通信工程","拉网线专业");
  15.         OrganizationComponent xintong3= new Department("电子商务","淘宝");
  17.         university.add(xintong);
  18.         university.add(yishu);
  19.         university.add(jinmao);
  21.         xintong.add(xintong1);
  22.         xintong.add(xintong2);
  23.         xintong.add(xintong3);
  24.         System.out.println("                                     ");
  25.         university.print();
  27.         xintong.print();
  28.     }
  29. }

image-20201007165833664.png

组合模式的注意事项和细节

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