“数据结构”模式

常常有一些组件在内部具有特定的数据结构，如果让客户程序依赖这些特定的数据结构，将极大地破坏组件的复用。这时候，将这些特定数据结构封装在内部，在外部提供统一的接口，来实现与特定数据结构无关的访问，是一种行之有效的解决方案。

典型模式

• Composite
• Iterator
• Chain of Resposibility

1.Composite模式（举例android:View）

---

动机

• 在软件某些情况下，客户代码过多地依赖于对象容器复杂的内部实现结构，对象容器内部实现结构（而非抽象接口）的变化将引起客户代码的频繁变化，带来了代码的维护性、扩展性等弊端。

• 如何将“客户代码与复杂的对象容器结构”解耦？让对象容器自己来实现自身的复杂结构，从而使得使得客户代码就像处理简单对象一样来处理复杂的对象容器？

模式定义

• 将对象组合成树形结构以表示“部分整体”的层次结构。组合模式使得用户对单个对象和使用具有一致性（稳定）。

结构

类图

涉及角色

• 1.Component 是组合中的对象声明接口，在适当的情况下，实现所有类共有接口的默认行为。声明一个接口用于访问和管理Component子部件。
• 2.Leaf 在组合中表示叶子结点对象，叶子结点没有子结点。
• 3.Composite 定义有枝节点行为，用来存储子部件，在Component接口中实现与子部件有关操作，如增加(add)和删除（remove）等

要点总结

• Composite模式采用树形结构来实现普遍存在的对象容器，从而将“一对多”的关系转化为“一对一”的关系，使得客户代码可以一致地（复用）处理对象和对象容器，无需关心处理的是单个的对象，还是组合的对象容器。
• 将“客户代码与复杂的对象容器结构”解耦是Composite的核心思想，解耦之后，客户代码将与纯粹的抽象接口——而非对象容器的内部实现结构——发生依赖，从而更能“应对变化”。
• Composite模式在具体实现中，可以让父对象中的子对象反向追溯；如果父对性爱那个有频繁的遍历需求，可使用缓存技巧来改善效率。

---

2.Iterator迭代器

---

动机

• 在软件构建过程中，集合对象内部结构常常变化各异。但对于这些集合对象，我们希望在不暴露其内部结构的同时，可以让外部客户代码透明地访问其中包含的元素；同时这种“透明遍历”也为“同一种算法在多种集合对象上进行操作”提供了可能。
• 使用面向对象技术将这种遍历机制抽象为“迭代器对象”为“应对变化中的集合对象”
  提供了一种优雅的方式。

模式定义

• 提供一种方法顺序访问一个聚合对象中的各个元素，而又不暴露（稳定）该对象的内部表示。

结构

类图

结构组成

• 抽象迭代器(Iterator): 定义遍历元素所需要的方法，一般来说会有这么三个方法：取得第一个元素的方法first()，取得下一个元素的方法next()，判断是否遍历结束的方法isDone()（或者叫hasNext()），移出当前对象的方法remove(),
• 具体迭代器(ConcreteIterator): 就是抽象容器的具体实现类，比如List接口的有序列表实现ArrayList，List接口的链表实现LinkList，Set接口的哈希列表的实现HashSet等。
• 抽象聚合类(Aggregate): 一般是一个接口，提供一个iterator()方法，例如java中的Collection接口，List接口，Set接口等。
• 具体聚合类(ConcreteAggregate): 聚合实现创建相应迭代器的接口，该操作返回ConcreteIterator的一个适当的实例。

代码实现

  interface Iterator {  
      public Object next();  
      public boolean hasNext();  
  }  
  class ConcreteIterator implements Iterator{  
      private List list = new ArrayList();  
      private int cursor =0;  
      public ConcreteIterator(List list){  
          this.list = list;  
      }  
      public boolean hasNext() {  
          if(cursor==list.size()){  
              return false;  
          }  
          return true;  
      }  
      public Object next() {  
          Object obj = null;  
          if(this.hasNext()){  
              obj = this.list.get(cursor++);  
          }  
          return obj;  
      }  
  }  
  interface Aggregate {  
      public void add(Object obj);  
      public void remove(Object obj);  
      public Iterator iterator();  
  }  
  class ConcreteAggregate implements Aggregate {  
      private List list = new ArrayList();  
      public void add(Object obj) {  
          list.add(obj);  
      }  
    
      public Iterator iterator() {  
          return new ConcreteIterator(list);  
      }  
    
      public void remove(Object obj) {  
          list.remove(obj);  
      }  
  }  
  public class Client {  
      public static void main(String[] args){  
          Aggregate ag = new ConcreteAggregate();  
          ag.add("小明");  
          ag.add("小红");  
          ag.add("小刚");  
          Iterator it = ag.iterator();  
          while(it.hasNext()){  
              String str = (String)it.next();  
              System.out.println(str);  
          }  
      }  
  }  

要点总结

• 迭代抽象：访问一个聚合对象的内容而无需暴露它的内部表示。
• 迭代多态：为遍历不同的集合结构提供一个统一的接口，从而支持同样的算法在不同的集合结构上进行操作。
• 迭代器的健壮性考虑:遍历的同时更改迭代器所在的集合结构（add、remove）会导致问题（抛出异常）。

---