设计模式之迭代器与组合模式

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

来个类图

 再来看一个具体的例子

public interface Menu{


    public Iterator createIterator();


}


public class PancakeHouseMenu implments Menu{


        ArrayList menuItems;
        
        public PacakeHouseMenu(){
       
         menuItems=new ArrayList();
            addItem("煎饼","有蛋有肉",true,10.00);
            //....懒的写
                

        }
        
    public void addItem(String name,String description,boolean vegetarian,double price){

        MenuItem menuItem=new MenuItem(name,description,vegetarian,price);
        menuItems.add(menuItem);


    }

 public Iterator createIterator(){

            return menuItms.iterator();


        }


}



public class DinerMenu implments Menu{

        static final int Max_ITEMS=6;
        int numberOfItems =0;
        MenuItem[]menuItems;

        public  DinerMenu{
        
        menuItems=new MenuItem[Max_ITEMS];
        addItme("热狗","有菜有肉",true,14.00);
             //....懒的写其余addIeme

        }



  public void addItem(String name,String description,boolean vegetarian,double price){

        MenuItem menuItem=new MenuItem(name,description,vegetarian,price);
        menuItems.add(menuItem);


    }


       public Iterator createIterator(){

            return new DinerMenuIterator(menuItems);


        }



}


public class DinerMenuIterator implemtns Iterator{

        MenuItme list;
        int position =0;
        
    public DinerMenuIterator ( MenuItme list){

        this.list=list;


    }

    public Object next(){

        MenuItme menuItem=list[position];
        position=position+1;
        return list;
        
    }


   public Object hasNext(){
        
        if(position>=list.length || list[position] ==null){

                return false;

            }else{
                    return true;

                }

        

    }


   public void remove(){

        if(position<0=0){

                throw new IllegalStateException("你不能删除");

            }

        if(list[position-1] !=null){

            for(int i= position-1;i<(list.length-1);I++){
                    list[i]=list[i+1];

                }

            list[list.length-1]=null
            }
    }

}

public class Waitress{

    Menu pancakeHouseMenu;
    Menu dinerMenu;


    public Waitress( Menu pancakeHouseMenu,Menu dinerMenu){

        this.pancakeHouseMenu=pancakeHouseMenu;
        this.dinerMenu=dinermenu;

    


    }


    public void printMenu(){

            Iterator pancakeIterator=dinerMenu.createIterator();
             Iterator dinerIterator=dinerMenu.createIterator();
            printMenu(pancakeIterator);

            printMenu(dinerIterator);


    }

    public void printMenu(Iterator iterator){


        While(iterator.hasNext()){
        
            MenuItem menuItem=(MenuItem )iterator.next();


        
        }



    }
















}

 总结一把：迭代器将遍历聚合的工作封装进一个对象中，当使用迭代器的时候，我们依赖聚合提供遍历。迭代器提供了一个通用的接口。让我们遍历聚合的项。当我们编码使用聚合的项时，就可以使用多态机制。我们应该努力让一个类只分配一个责任。

---

组合模式定义：允许你将对象组成树形结构来表现“整体/部分”的层次结构。组合能让客户以一致的方式处理个别对象和对象组合。

老规矩来个类图：

具体的例子：

public abstract class MenuComponent{

        //默认的操作
    public void add(MenuComponent menuComponent  ){

        throw new UnsupportedOperation();

    }

     public void remove(MenuComponent menuComponent  ){

        throw new UnsupportedOperation();

    }
    
     public void getChild(int i  ){

        throw new UnsupportedOperation();

    }

    
    public String getName(){


         throw new UnsupportedOperation();

    }


   public String getDescription(){


         throw new UnsupportedOperation();

    }


      public double getPrice(){


         throw new UnsupportedOperation();

    }


     public String isVegetarian(){


         throw new UnsupportedOperation();

    }


     public void print(){


         throw new UnsupportedOperation();

    }


    public Iterator creteIterator(){

        throw new UnsupportedOperation();

    }




}





//实现菜单项也就是叶子


   public class MenuItem extends MenuComponent{

        String name;
        String description;
        double price;
        boolean vegetarian;


        public MenuItem (String name, String description,double price,boolean vegetarian)  
              
        {

            this.name=name;
            this.description=description;
            this.price=price;
            this.vegetarian=vegetarian;



        }


     public String getName(){


         return name;

    }


   public String getDescription(){


        return descripition;

    }


      public double getPrice(){


         return price;

    }


     public String isVegetarian(){


        return vegetarian;

    }


     public void print(){

        System.out.print(""+getName());
        if(isVegetarian()){
            
             System.out.print("v”);
         }
        

          System.out.print(""+getPrice());
          System.out.print(""+getDescription());

    }

    public Iterator creteIterator(){

        throw new NullIterator();

    }

 }


//实现菜单也就是组合项


public class Menu extends MenuComponent{

    ArrayList menuComponents=new ArrayList();
    String name;
    String description;

    public Menu(String description,String name){
        
        this.description=description;
        this.name=name;


    }


      public void add(MenuComponent menuComponent  ){

       return menuComponents.add(menuComponent);

    }

     public void remove(MenuComponent menuComponent  ){

        return  menuComponents.remove(menuComponent);

    }
    
     public void getChild(int i  ){

        return (MenuComponent) menuComponents.get(i);


    }

    
    public String getName(){


         return name;

    }


   public String getDescription(){

        return description;

    }


    public void print(){

        System.out.print(getName());
        System.out.print(getDescription());

        Iterator iterator = menuCompents.iterator();
        while(iterator.hasNext() ){
            
            MenuComponent menuComponent = (MenuComponent )iterator.next();
                menuComponent.print();

        }


        public Iterator creteIterator(){

             return new CompositeIterator(menuCompents.iterator());

        }
    
    }

public class CompositeIterator implements Iterator{

        Stack stack =new Stack();
        
        public CompositeIterator (Iterator iterator){

            stack.push(iterator);


        }


        public Object next(){

            if(hasNext() ){
                Iterator iterator = (Iterator ) stack.peek();
                MenuComponent component = iterator.next();
                if(component instanceof Menu){
                
                    stack.push(component.cteateIterator());

                }
                
                return component;
             }else{
                    
                    return null;

                }


        }

    

    public boolean hasNext(){

            if(stack.empty()){
            
                return false;

            }else{
        
                Iterator iterator =()stack.peek();
                if(!iterator.hasNext() ){

                    stack.pop();
                    return hasNext();
                    
                }else{
                        return false;

                    }



            }





    }



}


public void remove(){

        
    throw new UnsuppoortedOperation();




}




}



public class NullIterator implements Iterator{

    public Object next(){


            return null;
    

    }



      public boolean hasNext(){


            return false;
    

    }


      public void next(){


            return null;
    

    }



    public void remove (){


        throw new UnsupportedOperation();

    }

}

 总结一把：