设计模式-迭代器模式和组合模式

1.迭代器模式完成的功能是和迭代器一样的，封装了对对象的顺序遍历，因为子类的对象集合的存储方式可能并不一致。但是存储的对象是一致的。

public classItem{
    .....//各种属性
}
public class Set1{
    item[] items;
    ...
    public Iterator createIterator(){
        return new ItemIterator(items);
    }
}
public class Set2{
    ArrayList items;
    ...
    public Iterator createIterator(){
        return  items.iterator();
    }
}
public class ItemIterator implements Iterator{
    Item[] items;
     int position;
    public ItemIterator(Item[] items)
    {
        this.items=items;
        position=0;
    }
    public Object next()
    {
        Item i=items[position];
        position=position+1;
        return i;
    }
    public boolean hasNext()
    {
        if (position>=items.lenght || items[position]==null)
            return false;
        else
            return true;
    }
}

通过这种方法，我们就可以通过自己定义的一个迭代器来访问数组，同时通过createIterator的方法来顺序遍历存储结构不一样的Set1和Set2中item对象。所以迭代器模式就是:

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

2.组合模式

组合模式其实就是整体与部分的一个关系，其实就是一个树形结构，根节点由他的子节点组合而成，而子节点又有自己的子节点来组合而成，所以组合模式的定义如下：

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

现在我们需要对组合模式下的对象这棵进行遍历怎么办？

public abstract class ItemComponent{
    ....//方法
    public void method1(){
    }
}
public classItem extends ItemComponent{
    .....//各种属性
    public void method1()
    {
        System.out.println("leaf");
    }    
}
public class Set1 extends ItemComponent{
    item[] items;
    ...
    public Iterator Iterator(){
        return new ItemIterator(items);
    }
    public void method1()
    {
        System.out.println("not leaf");
        Iterator iterator=itemComponent.iterator();//重写
        while (iterator.hasNext())
        {
            ItemComponent t=(ItemComponent) iterator.next();
            t.method1();
        }
    }
}
public class Set2 extends ItemComponent{
    ArrayList items;
    ...
    public Iterator Iterator(){
        return  items.iterator();
    }
        public void method1()
    {
        System.out.println("not leaf");
        Iterator iterator=itemComponent.iterator();//重写
        while (iterator.hasNext())
        {
            ItemComponent t=(ItemComponent) iterator.next();
            t.method1();
        }
    }
    
}

上面这种方式是一种通过递归的方式来实现全部遍历的

public class ItemIterator implements Iterator{
    stack stack = new Stack();
    public ItemIterator(Iterator iter)
    {
        stack.push(iter);
    }

     public Object next()
    {
        if (hasNext()){
            Iterator iterator=(Iterator)stack.peek();
            ItemComponent t=(ItemComponent) iterator.next();
            if (t instanceof Set1)
            {
                stack.push(t.createIterator());    
            }
            return t;
        }else{
            return null;
        }
    }
    public boolean hasNext()
    {
        if (stack.empty()){
            return false;
        }else{
            Iterator iterator=(Iterator) stack.peek();
            if (!iterator.hasNext()){
                stack.pop();
                return hasNext();
            }else {
                return true;
            }
        }
    }
}

现在定义的这种方式，是通过迭代器用栈模拟递归的一种方式。

3。设计模式-职责单一

单一责任： 一个类应该只有一个引起变化的原因。