通知 网站从因情语写改为晴雨,这个网站的模板也从calmlog_ex改为 whimurmur

行为型模式-迭代子模式

902人浏览 / 0人评论 / | 作者:因情语写  | 分类: 设计模式与算法  | 标签: 设计模式与算法

作者:因情语写

链接:https://www.qingyu.blue/article/453

声明:请尊重原作者的劳动,如需转载请注明出处


  行为型模式又可以分成以下四类:第一类:通过父类与子类的关系进行实现。第二类:两个类之间。第三类:类的状态。第四类:通过中间类

  迭代子模式属于第二类,两个类之间的关系

  迭代子模式分为外禀迭代子和内禀迭代子,外禀迭代子是迭代类在聚集类之外,内禀迭代子是聚集类包括迭代类

  先看外禀迭代子

package behavior.pattern.betweenclass.iterator.extrinsiciterator;

public abstract class Aggregate {
    /**
     * 工厂方法,创建相应迭代子对象的接口
     */
    public abstract Iterator createIterator();
}
package behavior.pattern.betweenclass.iterator.extrinsiciterator;

public class ConcreteAggregate extends Aggregate {
    private Object[] objArray = null;
    /**
     * 构造方法,传入聚合对象的具体内容
     */
    public ConcreteAggregate(Object[] objArray){
        this.objArray = objArray;
    }
    
    @Override
    public Iterator createIterator() {
        
        return new ConcreteIterator(this);
    }
    /**
     * 取值方法:向外界提供聚集元素
     */
    public Object getElement(int index){
        
        if(index < objArray.length){
            return objArray[index];
        }else{
            return null;
        }
    }
    /**
     * 取值方法:向外界提供聚集的大小
     */
    public int size(){
        return objArray.length;
    }
}
package behavior.pattern.betweenclass.iterator.extrinsiciterator;

public interface Iterator {
    /**
     * 迭代方法:移动到第一个元素
     */
    public void first();
    /**
     * 迭代方法:移动到下一个元素
     */
    public void next();
    /**
     * 迭代方法:是否为最后一个元素
     */
    public boolean isDone();
    /**
     * 迭代方法:返还当前元素
     */
    public Object currentItem();
}
package behavior.pattern.betweenclass.iterator.extrinsiciterator;

public class ConcreteIterator implements Iterator {

    //持有被迭代的具体的聚合对象
    private ConcreteAggregate agg;
    //内部索引,记录当前迭代到的索引位置
    private int index = 0;
    //记录当前聚集对象的大小
    private int size = 0;
    
    public ConcreteIterator(ConcreteAggregate agg){
        this.agg = agg;
        this.size = agg.size();
        index = 0;
    }
    /**
     * 迭代方法:返还当前元素
     */
    @Override
    public Object currentItem() {
        return agg.getElement(index);
    }
    /**
     * 迭代方法:移动到第一个元素
     */
    @Override
    public void first() {
        
        index = 0;
    }
    /**
     * 迭代方法:是否为最后一个元素
     */
    @Override
    public boolean isDone() {
        return (index >= size);
    }
    /**
     * 迭代方法:移动到下一个元素
     */
    @Override
    public void next() {

        if(index < size)
        {
            index ++;
        }
    }

}

  测试代码

package behavior.pattern.betweenclass.iterator.extrinsiciterator;

public class Client {

    public void operation(){
        Object[] objArray = {"One","Two","Three","Four","Five","Six"};
        //创建聚合对象
        Aggregate agg = new ConcreteAggregate(objArray);
        //循环输出聚合对象中的值
        Iterator it = agg.createIterator();
        while(!it.isDone()){
            System.out.println(it.currentItem());
            it.next();
        }
    }
    public static void main(String[] args) {
        
        Client client = new Client();
        client.operation();
    }

}

  运行结果

  再看一下内禀迭代子

package behavior.pattern.betweenclass.iterator.intrinsiciterator;

public abstract class Aggregate {
    /**
     * 工厂方法,创建相应迭代子对象的接口
     */
    public abstract Iterator createIterator();
}
package behavior.pattern.betweenclass.iterator.intrinsiciterator;

public class ConcreteAggregate extends Aggregate {

    private Object[] objArray = null;
    /**
     * 构造方法,传入聚合对象的具体内容
     */
    public ConcreteAggregate(Object[] objArray){
        this.objArray = objArray;
    }
    
    @Override
    public Iterator createIterator() {

        return new ConcreteIterator();
    }
    /**
     * 内部成员类,具体迭代子类
     */
    private class ConcreteIterator implements Iterator
    {
        //内部索引,记录当前迭代到的索引位置
        private int index = 0;
        //记录当前聚集对象的大小
        private int size = 0;
        /**
         * 构造函数
         */
        public ConcreteIterator(){
            
            this.size = objArray.length;
            index = 0;
        }
        /**
         * 迭代方法:返还当前元素
         */
        @Override
        public Object currentItem() {
            return objArray[index];
        }
        /**
         * 迭代方法:移动到第一个元素
         */
        @Override
        public void first() {
            
            index = 0;
        }
        /**
         * 迭代方法:是否为最后一个元素
         */
        @Override
        public boolean isDone() {
            return (index >= size);
        }
        /**
         * 迭代方法:移动到下一个元素
         */
        @Override
        public void next() {

            if(index < size)
            {
                index ++;
            }
        }
    }

}
package behavior.pattern.betweenclass.iterator.intrinsiciterator;

public interface Iterator {
    /**
     * 迭代方法:移动到第一个元素
     */
    public void first();
    /**
     * 迭代方法:移动到下一个元素
     */
    public void next();
    /**
     * 迭代方法:是否为最后一个元素
     */
    public boolean isDone();
    /**
     * 迭代方法:返还当前元素
     */
    public Object currentItem();
}

  测试代码

package behavior.pattern.betweenclass.iterator.intrinsiciterator;

public class Client {
    public void operation() {
        Object[] objArray = { "One", "Two", "Three", "Four", "Five", "Six" };
        // 创建聚合对象
        Aggregate agg = new ConcreteAggregate(objArray);
        // 循环输出聚合对象中的值
        Iterator it = agg.createIterator();
        while (!it.isDone()) {
            System.out.println(it.currentItem());
            it.next();
        }
    }

    public static void main(String[] args) {
        Client client = new Client();
        client.operation();
    }
}

  运行结果


亲爱的读者:如果你喜欢文章的话,不妨点赞评论支持作者一下吧


点赞(0) 打赏

全部评论

还没有评论!