设计模式-结构型模式总结实例（一）

组合模式

将对象以树形结构组织起来,以达成“部分－整体”的层次结构，使得客户端对单个对象和组合对象的使用具有一致性.

有时候又叫做部分-整体模式，它使我们树型结构的问题中，模糊了简单元素和复杂元素的概念，客户程序可以像处理简单元素一样来处理复杂元素,从而使得客户程序与复杂元素的内部结构解耦

组合模式让你可以优化处理递归或分级数据结构 .

package com.ruishenh.designPatter.structure.composite;
 
import java.util.ArrayList;
import java.util.List;
 
 
public class CompositeClient {
   public static void main(String[] args) {
      AbstractCompany department =new ConcreteDepartment("研发部");
      ConcreteDepartment d1 =new ConcreteDepartment("研发部一级");
      d1.addPos(new Position("总监", 1));
      d1.addPos(new Position("高级经理", 2));
      d1.addPos(new Position("经理", 3));
      d1.addPos(new Position("主管", 4));
      department.add(d1);
      EndDepartment ed1=new EndDepartment("集成组");
      ed1.addPos(new Position("组长", 5));
      ed1.addPos(new Position("副组长", 6));
      department.add(ed1);
      d1.add(ed1);
      department.operate(1);
   }
}
 
//公司机构
abstract class AbstractCompany{
   abstract int add(AbstractCompany company);
   abstract int remove(AbstractCompany company);
   abstract Object operate(int depth);
   abstract AbstractCompany getChild(int index);
}
//具体机构部门
class ConcreteDepartment extends AbstractCompany{
   String name;
   public ConcreteDepartment(String name) {
      super();
      this.name = name;
   }
   List<Position> pos=new ArrayList<Position>();
   protected List<AbstractCompany> departments=new ArrayList<AbstractCompany>();
   @Override
   int add(AbstractCompany company) {
      departments.add(company);
      return 0;
   }
   @Override
   int remove(AbstractCompany company) {
      departments.remove(company);
      return 0;
   }
   @Override
   AbstractCompany getChild(int index) {
      return departments.get(index);
   }
   void addPos(Position e){
      this.pos.add(e);
   }
   void removePos(Position e){
      this.pos.remove(e);
   }
   void displayPosition(int depth){
      for (Position p : pos) {
        for (int i = 0; i < depth; i++) {
           System.out.print("-");
        }
        System.out.println("职位名称:"+p.getName()+",职位级别："+p.getGrade());
      }
   };
   @Override
   Object operate(int depth) {
      System.out.println(depth+"级部门："+this.name);
      displayPosition(depth);
      for (AbstractCompany depart : departments) {
        for (int i = 0; i < depth; i++) {
           System.out.print("-");
        }
        depart.operate(depth+1);
      }
      return null;
   }
  
}
//末端部门
class EndDepartment extends AbstractCompany{
  
  
   public EndDepartment(String name) {
      this.name = name;
   }
 
   String name;
  
   List<Position> pos=new ArrayList<Position>();
  
   @Override
   int add(AbstractCompany company) {
      System.out.println("已经是最后子级部门,不能添加子部门");
      return -1;
   }
 
   @Override
   int remove(AbstractCompany company) {
      System.out.println("已经是最后子级部门,没有子部门了");
      return -1;
   }
   @Override
   Object operate(int depth) {
      System.out.println(depth+"级部门："+this.name);
      displayPosition(depth);
      return null;
   }
 
   @Override
   AbstractCompany getChild(int index) {
      return null;
   }
  
   void addPos(Position e){
      this.pos.add(e);
   }
   void removePos(Position e){
      this.pos.remove(e);
   }
  
   void displayPosition(int depth){
      for (Position p : pos) {
        for (int i = 0; i < depth; i++) {
           System.out.print("-");
        }
        System.out.println("职位名称:"+p.getName()+",职位级别："+p.getGrade());
      }
   };
}
//公司职位
class Position{
   public Position(String name, int grade) {
      super();
      this.name = name;
      this.grade = grade;
   }
   String name;
   int grade;
   public String getName() {
      return name;
   }
   public void setName(String name) {
      this.name = name;
   }
   public int getGrade() {
      return grade;
   }
   public void setGrade(int grade) {
      this.grade = grade;
   }
}

组合模式核心任务是将客户端操作复杂的容器和简单的容器操作能力一样，造成层级化的操作，显得单一简单。

一般使用在一些需要层级化的操作实例中，比如文件夹和子文件系列等。

外观模式

又叫门面模式，为子系统中的一组接口提供一致的界面，提供了一高层接口，这个接口使得子系统更容易使用。

package com.ruishenh.designPatter.structure.facode;
 
import java.util.ArrayList;
import java.util.List;
 
public class FacodeClient {
   public static void main(String[] args) {
      CTO cto =new CTO();//总监来了
      Manager m =new Manager();//问经理要最近工作情况
      //总监看经理提供的报表
      cto.lookReport(m.getReport());
     
   }
}
class CTO{
   void lookReport(List<String> msg){
      for (String string : msg) {
        System.out.println(string);
      }
   }
}
class Manager{
   List<String> getReport(){
      List<String> list=new ArrayList<String>();
      Staff1 s1=new Staff1();
      Staff2 s2=new Staff2();
      Staff3 s3=new Staff3();
      list.add(s1.worked());
      list.add(s2.worked());
      list.add(s3.worked());
      return list;
   }
}
 
//员工一
class Staff1{
   String worked(){
      return "我是小A,我完成了项目一期的设计";
   }
}
//员工二
class Staff2{
   String worked(){
      return "我是小D,我完成了项目一期的UI";
   }
}
//员工三
class Staff3{
   String worked(){
      return "我是小G,我完成了项目一期的编码";
   }
}

外观模式的核心就是把一个业务的完成需要综合了多个类的调用，封装到一个更高层的函数里面。然后把业务完成的内部封装隐藏。返回客户端调用的信息。