常用设计模式----迭代器与组合模式

package org.design.patterns;

import java.util.ArrayList;
import java.util.List;

/**
 *迭代器模式：
 *提供一种方法顺序访问一个聚合对象中的各个元素，而不暴露其内部的表示。 
 *
 */

//下面以java.uitil.Iterator为例进行说明
public interface Iterator<E> {
    boolean hasNext();
    E next();
    void remove();
}

/*
 * 以下是java.util.AbstractList，其中有对Iterator的实现，java的集合类中还有很多类似的实现，这里不再一一举例
*/
abstract class AbstractList<E> extends AbstractCollection<E> implements List<E> {
 protected AbstractList() {
 }
 public boolean add(E e) {
  add(size(), e);
  return true;
 }
 abstract public E get(int index);
 public E set(int index, E element) {
  throw new UnsupportedOperationException();
 }
 public void add(int index, E element) {
  throw new UnsupportedOperationException();
 }
 public E remove(int index) {
  throw new UnsupportedOperationException();
 }
 
 ......
 
 // Iterators
 public Iterator<E> iterator() {
  return new Itr();
 }
 
 private class Itr implements Iterator<E> {
  int cursor = 0;

  int lastRet = -1;
  int expectedModCount = modCount;

  public boolean hasNext() {
   return cursor != size();
  }

  public E next() {
   checkForComodification();
   try {
    E next = get(cursor);
    lastRet = cursor++;
    return next;
   } catch (IndexOutOfBoundsException e) {
    checkForComodification();
    throw new NoSuchElementException();
   }
  }

  public void remove() {
   if (lastRet == -1)
    throw new IllegalStateException();
   checkForComodification();

   try {
    AbstractList.this.remove(lastRet);
    if (lastRet < cursor)
     cursor--;
    lastRet = -1;
    expectedModCount = modCount;
   } catch (IndexOutOfBoundsException e) {
    throw new ConcurrentModificationException();
   }
  }

  final void checkForComodification() {
   if (modCount != expectedModCount)
    throw new ConcurrentModificationException();
  }
 }
 ......
}
*/

//====================================================================
 /**
  *组合模式：
  *允许将对象组合成树形结构类表现"整体/部分"层次结构。
  *组合能让客户以一致的方式处理个别对象以及对象组合 ，
  *"忽略"单个对象和组合对象的差别。
  *
  */
//顶层抽象类
abstract class Component{
 abstract void operation();
 
 void add(Component component){
  throw new UnsupportedOperationException();
 }
 void remove(Component component){
  throw new UnsupportedOperationException();
 }
 Component getChild(int i){
  throw new UnsupportedOperationException();
 }
 
}
//个体实现
class Leaf extends Component{
 @Override
 void operation() {
        System.out.println("Leaf.operation()");  
 }
}
//组合实现
class Composite extends Component{
    List<Component> comList;
    public Composite() {
      comList=new ArrayList<Component>();
    }
    
 @Override
 void add(Component component) {
       comList.add(component);
 }
 @Override
 void remove(Component component) {
      comList.remove(component);
 }
 @Override
 Component getChild(int i) {
  return comList.get(i);
 }
 
 @Override
 void operation() {
  System.out.println("Composite.operation()");
//         for(Component com:comList){
//          com.operation();
//         }  
  //用迭代器的方式（该迭代器是java.util的）
  java.util.Iterator<Component>  iterator = comList.iterator();
  while(iterator.hasNext()){
   Component component=iterator.next();
   component.operation();
  }
 }
}
//这样，Leaf和Composite都是Component对象，具有相同的接口
//菜单Menu和菜单项MenuItem是使用组合很好的例子
//=========================================================
/*
 *相关模式比较：
 * 策略：          封装可互换的行为（算法），并使用委托决定使用哪一个
 * 
 * 适配器：     改变一个或多个类的接口
 * 
 * 迭代器：     提供一个方式遍历集合，而无须暴露集合的实现
 * 
 * 外观：          简化一群类的接口
 * 
 * 组合：          客户可以将对象的集合以及个别的对象一视同仁
 * 
 * 观察者：     当某个状态改变时，允许一群对象被通知到  
 */