迭代器模式&组合模式

1.迭代器：统一形式访问聚合对象中元素，不暴露内部表示；取出元素没有次序，next() 不代表+1

                 可以编写多态的代码搭配

                 内部的：由迭代器自身控制 next()

                 外部的：客户决定next()，调用，实现

    组合：当有数个对象的集合，彼此之间有“整体/部分”关系，想用一致的方式对待这些对象时；（比如图形 Frame 内含小widget...，都需要show()）

2.代码

C++

//composite c++
#include <iostream>
#include <string>
#include <vector>
using namespace std;

class Component{
public:
    Component(string str): m_str(str){}
    virtual void add(Component*) = 0;
    virtual void display(int )   = 0;

    string m_str;
};

class Leaf : public Component{
public:
    Leaf(string strName): Component(strName){}
    void add(Component* comp){ cout<<"can`t add in leaf"<<endl; }
    void display(int nDepth){
        string tStr;
        for(int i = 0;i<nDepth;i++) tStr += "-";
        tStr += m_str;
        cout<<tStr<<endl;
    }
};

class Composite : public Component{
public:
    Composite(string str):Component(str){}
    void add(Component* pComp){
        m_component.push_back(pComp);
    }
    void display(int nDepth){
        string tStr;
        for(int i = 0;i<nDepth;i++) tStr += "-";
        
        tStr += m_str;
        cout<<tStr<<endl;
        //
        vector<Component*>::iterator it = m_component.begin();
        while(it != m_component.end()){
            (*it)->display(nDepth + 2);
            it++;
        }
    }
private:
    vector<Component*> m_component;
};

int main(){
    Component* p_root = new Composite("root");
    p_root->add(new Leaf("leaf_1"));
    p_root->add(new Leaf("leaf_2"));
    
    Component* p_L1 = new Composite("node_1");
    p_L1->add(new Leaf("node_1_1"));
    p_L1->add(new Leaf("node_1_2"));
    p_root->add(p_L1);
    
    p_root->display(0);
    
    return 0;
}

 Java:

//interator java
import java.util.ArrayList;
import java.util.Iterator;
import java.util.Stack;
//CompositeIterator
class CompositeIterator implements Iterator<MenuComponent>{
    Stack<Iterator<MenuComponent>> stack = new Stack<Iterator<MenuComponent>>();
    public CompositeIterator(Iterator<MenuComponent> iterator){
        stack.push(iterator);
    }
    public MenuComponent next(){
        if(hasNext()){
            Iterator<MenuComponent> iterator = stack.peek();
            MenuComponent component = iterator.next();
            if(component instanceof Menu){
                stack.push(component.createIterator());
            }
            return component;
        }
        else{
            return null;
        }
    }
    public boolean hasNext(){
        if(stack.empty()){
            return false;
        }else{
            Iterator<MenuComponent> iterator = stack.peek();
            if(!iterator.hasNext()){
                stack.pop();
                return hasNext();
            }else{
                return true;
            }
        }
    }
    public void remove(){
        throw new UnsupportedOperationException();
    }
}
class NullIterator implements Iterator<MenuComponent>{
    public MenuComponent next(){
        return null;
    }
    public boolean hasNext(){
        return false;
    }
    public void remove(){
        throw new UnsupportedOperationException();
    }
}

//MenuComponent
abstract class MenuComponent{
    public void add(MenuComponent menuComponent){
        throw new UnsupportedOperationException();
    }
    public void remove(MenuComponent menuComponent){
        throw new UnsupportedOperationException();
    }
    public MenuComponent getChild(int i){
        throw new UnsupportedOperationException();
    }
    public String getName(){
        throw new UnsupportedOperationException();
    }
    public String getDescription(){
        throw new UnsupportedOperationException();
    }
    public double getPrice(){
        throw new UnsupportedOperationException();
    }
    public boolean isVegetarian(){
        throw new UnsupportedOperationException();
    }
    public void print(){
        throw new UnsupportedOperationException();
    }
    //use it to composite all child
    public Iterator<MenuComponent> createIterator(){
        throw new UnsupportedOperationException();
    }
}

//
class MenuItem extends MenuComponent{
    String  name;
    String  description;
    boolean vegetarian;
    double  price;
    
    public MenuItem(String  name,
                    String  description,
                    boolean vegetarian,
                    double  price)
    {
        this.name        = name;
        this.description = description;
        this.vegetarian  = vegetarian;
        this.price       = price;
    }
    public String getName(){
        return this.name;
    }
    public String getDescription(){
        return this.description;
    }
    public boolean isVegetarian(){
        return vegetarian;
    }
    public double getPrice(){
        return this.price;
    }
    public void print(){
        System.out.print(" " + getName());
        if(isVegetarian()){
            System.out.print("(v)");
        }
        System.out.println(", Price: " + getPrice());
        System.out.println("       - - " + getDescription());
    }
    public Iterator<MenuComponent> createIterator(){
        return new NullIterator(); //use null object 
    }
}
//Menu is a composite
class Menu extends MenuComponent{
    ArrayList<MenuComponent> menuComponents = new ArrayList<MenuComponent>();
    String name;
    String description;
    
    public Menu(String name,String description){
        this.name        = name;
        this.description = description;
    }
    public void add(MenuComponent menuComponent){
        menuComponents.add(menuComponent);
    }
    public void remove(MenuComponent menuComponent){
        menuComponents.remove(menuComponent);
    }
    public MenuComponent getChild(int i){
        return menuComponents.get(i);
    }
    public String getName(){
        return name;
    }
    public String getDescription(){
        return description;
    }
    public void print(){
        System.out.print("\n" + getName());
        System.out.println(", " + getDescription());
        System.out.println("- - - - - - - - - - - - - - - - - ");
        //use iterator
        Iterator<MenuComponent> iterator = menuComponents.iterator();
        while(iterator.hasNext()){
            MenuComponent menuComponent = iterator.next();
            menuComponent.print();
        }
    }
    public Iterator<MenuComponent> createIterator(){
        return new CompositeIterator(menuComponents.iterator());
    }    
}

//Waitress
class Waitress{
    MenuComponent allMenus;

    public Waitress(MenuComponent allMenus){
        this.allMenus = allMenus;
    }
    public void printMenu(){
        allMenus.print();
    }
    public void printVegetarianMenu(){
        Iterator<MenuComponent> iterator = allMenus.createIterator();
        System.out.println("\nVEGETTARIAN MENU\n - - - ");
        while(iterator.hasNext()){
            MenuComponent menuComponent = iterator.next();
            try{
                if(menuComponent.isVegetarian()){
                    menuComponent.print();
                }
            }catch(UnsupportedOperationException e){}
        }
    }
}

//main
class iterator_composite{
    public static void main(String[] args){
        
        MenuComponent pancakeHouseMenu = new Menu("PANCAKE HOUSE MENU","Break fast");
        MenuComponent dinerMenu        = new Menu("DINER MENU"        ,"Lunch"     );
        MenuComponent dessert          = new Menu("DESSERT MENU"      ,"Sessert"   );
        
        MenuComponent allMenus = new Menu("ALL MENUS","All menus combined");
        allMenus.add(pancakeHouseMenu);
        allMenus.add(dinerMenu);
        allMenus.add(dessert);
        
        //add:pancakeHouseMenu 
        pancakeHouseMenu.add(new MenuItem("K&B's Pancake Breakfast",
                                          "Pancakes with scrambled eggs,and toast",
                                          true,
                                          1.99));
        pancakeHouseMenu.add(new MenuItem("Regular Pancake Breakfast",
                                          "Pancakes with fried eggs,sausage",
                                          false,
                                          2.99));
        //add:dinerMenu
        dinerMenu.add(new MenuItem("Vegetarian BLT",
                                   "Bacon with lettuce & tomato on whole wheat",
                                   true,
                                   1.99));
        dinerMenu.add(new MenuItem("Soup of the day",
                                   "Soup of the day,with a side of potato salad",
                                   false,
                                   2.66));
        dinerMenu.add(new MenuItem("Hotdog",
                                   "with saurkraut,relish,onions,topped with cheese",
                                   false,
                                   3.05));
        //add:dessert
        dessert.add(new MenuItem("Pasta",
                                 "with Marinara Sauce,and a slice of sourdough bread",
                                 true,
                                 0.99));
        //
        Waitress waitress = new Waitress(allMenus);
        waitress.printMenu();
        waitress.printVegetarianMenu();
    }
}

3.杂记：

（1）一个类应该只有一个引起变化的原因，高内聚，一个责任指派一个类