行为型模式

观察者模式

定义对象间的一种一对多的依赖关系，当一个对象的状态发生改变时，所有依赖于它的对象都得到通知并被自动更新。

角色

抽象观察者角色：为所有的具体观察者定义一个接口，在得到主题通知时更新自己。

具体被观察者角色：也就是一个具体的主题，在集体主题的内部状态改变时，所有登记过的观察者发出通知。

具体观察者角色：实现抽象观察者角色所需要的更新接口，一边使本身的状态与制图的状态相协调。

定义一个抽象被观察者接口

public interface Subject {
  public void registerObserver(Observer o);
  public void removeObserver(Observer o);
  public void notifyObserver();
}

定义一个抽象观察者接口

public interface Observer {
	public void update(String message);
}

定义被观察者，实现了Observerable接口，对Observerable接口的三个方法进行了具体实现，同时有一个List集合，用以保存注册的观察者，等需要通知观察者时，遍历该集合即可。

public class WechatServer implements Subject {
  private List<Observer> list;
  private String message;
  public WechatServer() {
    list = new ArrayList<Observer>();
  }
  @Override
  public void registerObserver(Observer o) {
    // TODO Auto-generated method stub
    list.add(o);
  }
  @Override
  public void removeObserver(Observer o) {
    // TODO Auto-generated method stub
    if (!list.isEmpty()) {
      list.remove(o);
    }
  }
  @Override
  public void notifyObserver() {
    // TODO Auto-generated method stub
    for (Observer o : list) {
      o.update(message);
    }
  }
  public void setInfomation(String s) {
    this.message = s;
    System.out.println("微信服务更新消息： " + s);
    // 消息更新，通知所有观察者
    notifyObserver();
  }
}

测试

public class MainTest {
  public static void main(String[] args) {
    WechatServer server = new WechatServer();
    Observer userZhang = new User("ZhangSan");
    Observer userLi = new User("LiSi");
    Observer userWang = new User("WangWu");
    server.registerObserver(userZhang);
    server.registerObserver(userLi);
    server.registerObserver(userWang);
    server.setInfomation("PHP是世界上最好用的语言！");
    System.out.println("----------------------------------------------");
    server.removeObserver(userZhang);
    server.setInfomation("JAVA是世界上最好用的语言！");
  }
}

迭代器模式

提供一种方法顺序访问一个聚合对象中各个元素, 而又无须暴露该对象的内部表示。

角色

迭代器角色（Iterator）:定义遍历元素所需要的方法，一般来说会有这么三个方法：取得下一个元素的方法next()，判断是否遍历结束的方法hasNext()），移出当前对象的方法remove(),
具体迭代器角色（Concrete Iterator）：实现迭代器接口中定义的方法，完成集合的迭代。
容器角色(Aggregate): 一般是一个接口，提供一个iterator()方法，例如java中的Collection接口，List接口，Set接口等
具体容器角色（ConcreteAggregate）：就是抽象容器的具体实现类，比如List接口的有序列表实现ArrayList，List接口的链表实现LinkList，Set接口的哈希列表的实现HashSet等。

迭代器接口

public interface Iterator {
  public boolean hasNext();
  public Object next();
}

咖啡店菜单和咖啡店菜单遍历器

public class CakeHouseMenu {
  private ArrayList<MenuItem> menuItems;
  public CakeHouseMenu() {
    menuItems = new ArrayList<MenuItem>();
    addItem("KFC Cake Breakfast","boiled eggs&toast&cabbage",true,3.99f);
    addItem("MDL Cake Breakfast","fried eggs&toast",false,3.59f);
    addItem("Stawberry Cake","fresh stawberry",true,3.29f);
    addItem("Regular Cake Breakfast","toast&sausage",true,2.59f);
  }
  private void addItem(String name, String description, boolean vegetable,
                       float price) {
    MenuItem menuItem = new MenuItem(name, description, vegetable, price);
    menuItems.add(menuItem);
  }
  public Iterator getIterator()
  {
    return new CakeHouseIterator() ;
  }
  class CakeHouseIterator implements  Iterator
  {		
    private int position=0;
    public CakeHouseIterator()
    {
      position=0;
    }
    @Override
    public boolean hasNext() {
      // TODO Auto-generated method stub
      if(position<menuItems.size())
      {
        return true;
      }
      return false;
    }
    @Override
    public Object next() {
      // TODO Auto-generated method stub
      MenuItem menuItem =menuItems.get(position);
      position++;
      return menuItem;
    }};
}

中餐厅菜单和中餐厅菜单遍历器

public class DinerMenu {
  private final static int Max_Items = 5;
  private int numberOfItems = 0;
  private MenuItem[] menuItems;

  public DinerMenu() {
    menuItems = new MenuItem[Max_Items];
    addItem("vegetable Blt", "bacon&lettuce&tomato&cabbage", true, 3.58f);
    addItem("Blt", "bacon&lettuce&tomato", false, 3.00f);
    addItem("bean soup", "bean&potato salad", true, 3.28f);
    addItem("hotdog", "onions&cheese&bread", false, 3.05f);
  }
  private void addItem(String name, String description, boolean vegetable,
                       float price) {
    MenuItem menuItem = new MenuItem(name, description, vegetable, price);
    if (numberOfItems >= Max_Items) {
      System.err.println("sorry,menu is full!can not add another item");
    } else {
      menuItems[numberOfItems] = menuItem;
      numberOfItems++;
    }
  }
  public Iterator getIterator() {
    return new DinerIterator();
  }
  class DinerIterator implements Iterator {
    private int position;

    public DinerIterator() {
      position = 0;
    }
    @Override
    public boolean hasNext() {
      // TODO Auto-generated method stub
      if (position < numberOfItems) {
        return true;
      }
      return false;
    }
    @Override
    public Object next() {
      // TODO Auto-generated method stub
      MenuItem menuItem = menuItems[position];
      position++;
      return menuItem;
    }
  };
}

女服务员

public class Waitress {
  private ArrayList<Iterator> iterators = new ArrayList<Iterator>();
  public Waitress() {}
  public void addIterator(Iterator iterator) {
    iterators.add(iterator);
  }
  public void printMenu() {
    Iterator iterator;
    MenuItem menuItem;
    for (int i = 0, len = iterators.size(); i < len; i++) {
      iterator = iterators.get(i);
      while (iterator.hasNext()) {
        menuItem = (MenuItem) iterator.next();
        System.out
          .println(menuItem.getName() + "***" + menuItem.getPrice() + "***" + menuItem.getDescription());
      }
    }
  }
  public void printBreakfastMenu() {}
  public void printLunchMenu() {}
  public void printVegetableMenu() {}
}

行为型模式​

观察者模式​

迭代器模式​

行为型模式

观察者模式

迭代器模式