设计模式整理_迭代器模式

　　迭代器模式提供了一种方法顺序访问一个聚合对象中的各个元素,而又不是暴露其内部的表示.将在聚合对象内部游走的任务放在迭代器上而不是放在聚合上,这样简化了聚合的接口和实现,也让责任各得其所.

　　例如在没有进行优化的下列代码中,在处理不同的对象的聚合的时候,获取了对象的内部实现,这对封装造成了破坏,另外一方面,当需要处理其他类型的聚合对象的时候,也会造成需要对源代码进行修改,不利于扩展.

/*
 *    定义Food类,Food类是需要被聚合的对象 
 * */
public class Food {
    private String name;
    private double price;
    
    public Food(String name, double price) {
        super();
        this.name = name;
        this.price = price;
    }
    public String getName() {
        return name;
    }
    public void setName(String name) {
        this.name = name;
    }
    public double getPrice() {
        return price;
    }
    public void setPrice(double price) {
        this.price = price;
    }
    @Override
    public String toString() {
        return name+",$"+price;
    }
    
}

//FoodArray为聚合Food的一种形式,其内部用的是数组实现
public class FoodArray {
    Food[] foods=new Food[10];
    int i=0;
    
    public FoodArray() {
        addFood(new Food("汉堡包", 16));
        addFood(new Food("鸡肉卷", 14));
        addFood(new Food("炸鸡腿", 8));
    }
    public void addFood(Food food) {
        foods[i]=food;
        i++;
    }
    public Food[] getFood() {
        return foods;        //将底层暴露了出去.
    }
}

//FoodList是聚合对象的另外一种形式,其底层用的是ArrayList
import java.util.ArrayList;
public class FoodList {
    private ArrayList<Food> al=new ArrayList<Food>();
    
    public FoodList() {
        addFood(new Food("蛋炒饭",10));
        addFood(new Food("炒面",11));
        addFood(new Food("豆花饭",7));
    }
    public void addFood(Food food) {
        al.add(food);    //添加元素
    }
    public ArrayList<Food> getFood() {
        return al;        //将底层暴露了出去.
    }
}

import java.util.ArrayList;
//Drive类用于实现对于聚合对象的遍历.
public class Drive {
    FoodList list;
    FoodArray array;
    public void print(FoodList list,FoodArray array) {
        this.list=list;
        this.array=array;
        ArrayList<Food> al=list.getFood();
        Food[] foods=array.getFood();
        //对于一种聚合对象的实现法则
        for(int i=0;i<al.size();i++) {
            System.out.println(al.get(i));
        }
        //对于另一种聚合对象的实现法则
        for(int i=0;i<foods.length;i++) {
            if(foods[i]==null)
                break;
            System.out.println(foods[i]);
        }
    }
}

//测试遍历
public class Test {
    public static void main(String[] args) {
        FoodArray array=new FoodArray();
        FoodList list=new FoodList();
        Drive drive=new Drive();
        drive.print(list, array);
    }
}

　　为了解决这种在不同类型的数据结构聚合内部遍历元素的问题,我们在数据结构内部定义迭代器用来遍历元素,并且在Drive类中用迭代器统一的进行访问.所有的数据结构抽象为一个共有的父接口,便于进行统一管理.

import java.util.Iterator;
//所有数据结构统一的父类,只有一个方法,它返回了一个迭代器.
public interface AbstractFood {
    public Iterator<Food> getIterator();

}

import java.util.Iterator;

//FoodArray为聚合Food的一种形式,其内部用的是数组实现
public class FoodArray implements AbstractFood {
    Food[] foods=new Food[10];
    int i=0;
    
    public FoodArray() {
        addFood(new Food("汉堡包", 16));
        addFood(new Food("鸡肉卷", 14));
        addFood(new Food("炸鸡腿", 8));
    }
    public void addFood(Food food) {
        foods[i]=food;
        i++;
    }
    public Iterator<Food> getIterator() {
        return new FoodArrayIterator();    //定义迭代器
    }
    class FoodArrayIterator implements Iterator<Food>{
        int pos=0;
        @Override
        public boolean hasNext() {
            return pos<i;
        }

        @Override
        public Food next() {
            Food food=foods[pos];
            pos++;
            return food;
        }

        @Override
        public void remove() {
        }
        
    }
}

import java.util.ArrayList;
import java.util.Iterator;
public class FoodList implements AbstractFood {
    private ArrayList<Food> al=new ArrayList<Food>();
    int i=0;
    public FoodList() {
        addFood(new Food("蛋炒饭",10));
        addFood(new Food("炒面",11));
        addFood(new Food("豆花饭",7));
    }
    public void addFood(Food food) {
        al.add(food);    //添加元素
    }
    public Iterator<Food> getIterator() {
        return new FoodListIterator();    //定义迭代器
    }
    class FoodListIterator implements Iterator<Food> /*内部类方便操作外部类中的元素.*/{
        
        @Override
        public boolean hasNext() {
            return i<al.size();
        }

        @Override
        public Food next() {
            Food food=al.get(i);
            i++;
            return food;
        }

        @Override
        public void remove() {
        }
        
    }
}

import java.util.ArrayList;
import java.util.Iterator;
//Drive类用于实现对于聚合对象的遍历.
public class Drive {
    AbstractFood foods1;
    AbstractFood foods2;
    
    public void print(AbstractFood list,AbstractFood array) {
        this.foods1=list;
        this.foods2=array;
        
        Iterator<Food> i1=foods1.getIterator();
        Iterator<Food> i2=foods2.getIterator();
        print(i1);
        print(i2);
    }

    public void print(Iterator<Food> i1) {
        while(i1.hasNext()) {
            System.out.println(i1.next());
        }
    }
}

　　可以看出在Drive类中大大简化了对不同数据结构的操作,且如果要插入其他操作十分简便,只需实现AbstractFood类即可.