Android 架构师之路 目录,又不须求明白聚合对象的内部结构

ConcreteIterator: 具体迭代器

格局动机
图片 1

5.1 优点
  • 它辅助以不相同的不二法门遍历一个集合对象。
  • 迭代器简化了聚合类。
  • 在同1个汇聚上得以有八个遍历。
  • 在迭代器格局中,扩展新的聚合类和迭代器类都很便宜,无须修改原有代码。
namespace IteratorPattern
{
    //Iterator迭代器抽象类
    abstract class Iterator
    {
        //用于定义得到开始对象、得到下一个对象、
        //判断是否到结尾、当前对象等抽象方法,统一接口
        public abstract object First();
        public abstract object Next();
        public abstract bool IsDone();
        public abstract object CurrentItem();
    }
}

情势定义
迭代器形式(Iterator Pattern)
:提供一种情势来访问聚合对象,而不用暴光那一个目的的中间表示,其别称为游标(Cursor)。迭代器形式是一种对象行为型情势。
Iterator Pattern: Provide a way to access the elements of an aggregate
object sequentially without exposing its underlying representation.
Frequency of use: high
UML图
图片 2

肆 、Android源码中的格局达成

1.除了各个数码结构体,如List,Map等含有的迭代器外
2.Android自己源码中也为大家提供了迭代器遍历数据,最为优良的事例正是数据库查询利用Cursor(当大家运用SQLiteDatabase的query方法查询数据库时回来的),该游标对象实质正是1个实际的迭代器,大家得以选拔它来遍历数据库查询所得的结果集

形式分析
集结是二个管制和集体数据对象的数据结构。
集合对象首要存有七个职责:一是储存在这之中数据;二是遍历内部数据。
积存数据是聚众对象最宗旨的天职。
将遍历聚合对象中多少的一举一动提取出来,封装到三个迭代器中,通过专门的迭代器来遍历聚合对象的在那之中数据,那就是迭代器形式的原形。迭代器格局是“单一职务规范”的通盘体现。

ConcreteAggregate: 具体聚合类

1.2 定义

提供一种方法顺序访问三个容器对象中的各类要素,而又不须要揭示该对象的里边表示。

【参考文献】
《设计方式—可复用面向对象软件的底子》小编: [美] 埃里克h Gamma / RichardHelm / 拉尔夫 Johnson / John Vlissides 译者: 李英军 / 马晓星 / 蔡敏 /
刘建中 等 机械工业出版社
《重构—革新既有代码的统一筹划》作者: 马丁 Fowler译者:候捷
中华人民共和国电力出版社
《敏捷软件开发—原则、方式与执行》小编: Robert C. 马丁 南开东军大学出版社
《程序员修炼之道—从小工到大方》小编: Andrew Hunt / 大卫 托马斯电子工业出版社
《Head First 设计形式》作者: Freeman 译者: O’Reilly Taiwan公司中华夏族民共和国电力出版社
《设计模式之禅》 小编: 秦小波 机械工业出版社
MSDN WebCast 《C#面向对象设计形式纵横谈》 助教:李建忠
Liu Wei. 设计形式. 东京:清华出版社, 贰零壹贰.
刘伟先生. 设计情势实验和培训教程. 东京(Tokyo):哈工业余大学学东军大学出版社, 贰零壹壹.
《大话设计情势》 笔者: 程杰 浙大东军事和政院学出版社
《C#图解教程》小编: 索Liss 译者: 苏林 / 朱晔 人民邮电出版社
《你必须了然的.NET》小编: 王涛
《项目中的.NET》小编: 李天平 电子工业出版社
《Microsoft .NET集团级应用架构划设想计》小编: (美)埃斯波西托等创作 译者:
陈黎夫
http://www.dofactory.com/Patterns/Patterns.aspx .NET Design Patterns
http://www.cnblogs.com/zhenyulu 博客小编:吕震宇
http://www.cnblogs.com/terrylee 博客我:李会军
http://www.cnblogs.com/anlyren/ 博客笔者:anlyren
http://www.cnblogs.com/idior 博客作者:idior
http://www.cnblogs.com/allenlooplee 博客小编:Allen lee
http://blog.csdn.net/ai92 博客小编:ai92
http://www.cnblogs.com/umlonline/ 博客小编:张传波
http://www.cnblogs.com/lovecherry/ 博客笔者:LoveCherry

【参考文献】
《设计形式—可复用面向对象软件的底子》笔者: [美] 埃里克h Gamma / RichardHelm / 拉尔夫 Johnson / John Vlissides 译者: 李英军 / 马晓星 / 蔡敏 /
刘建中 等 机械工业出版社
《重构—改革既有代码的统筹》小编: 马丁 Fowler译者:候捷
中中原人民共和国电力出版社
《敏捷软件开发—原则、情势与执行》作者: Robert C. 马丁 浙大东军事和政院学出版社
《程序员修炼之道—从小工到学者》小编: Andrew Hunt / 大卫 托马斯电子工业出版社
《Head First 设计形式》笔者: Freeman 译者: O’Reilly Taiwan公司中国电力出版社
《设计情势之禅》 笔者: 秦小波 机械工业出版社
MSDN WebCast 《C#面向对象设计方式纵横谈》 教授:李建忠
刘伟同志. 设计方式. 东京:浙大东军政高校学出版社, 二零一二.
刘伟同志. 设计情势实验和培养和练习教程. 香江:北大东军事和政院学出版社, 二零一一.
《大话设计格局》 小编: 程杰 哈工业余大学学东军事和政院学出版社
《C#图解教程》小编: 索Liss 译者: 苏林 / 朱晔 人民邮政和邮电通讯出版社
《你必须知道的.NET》我: 王涛
《项目中的.NET》笔者: 李天平 电子工业出版社
《Microsoft .NET公司级应用架构划设想计》我: (美)埃斯波西托等作品 译者:
陈黎夫
http://www.dofactory.com/Patterns/Patterns.aspx .NET Design Patterns
http://www.cnblogs.com/zhenyulu 博客作者:吕震宇
http://www.cnblogs.com/terrylee 博客笔者:李会军
http://www.cnblogs.com/anlyren/ 博客笔者:anlyren
http://www.cnblogs.com/idior 博客作者:idior
http://www.cnblogs.com/allenlooplee 博客小编:Allen lee
http://blog.csdn.net/ai92 博客作者:ai92
http://www.cnblogs.com/umlonline/ 博客小编:张传波
http://www.cnblogs.com/lovecherry/ 博客作者:LoveCherry

伍 、形式计算

using System;
using System.Collections.Generic;

namespace IteratorPattern
{
    //ConcreteAggregate具体聚集类 继承Aggregate
    class ConcreteAggregate : Aggregate
    {
        //声明一个IList泛型变量,用于存放聚合对象,用ArrayList同样可以实现
        private IList<object> items = new List<Object>();
        public override Iterator CreateIterator()
        {
            return new ConcreteIterator(this);
        }
        public int Count
        {
            get { return items.Count; }//返回聚集总个数
        }
        //声明一个索引器
        public object this[int index]
        {
            get { return items[index]; }
            set { items.Insert(index, value); }
        }
    }
}

情势结构
迭代器形式涵盖如下角色:
Iterator: 抽象迭代器
ConcreteIterator: 具体迭代器
Aggregate: 抽象聚合类
ConcreteAggregate: 具体聚合类

ConcreteItertor:
/**
 * 具体的迭代角色
 */
public class ConcreteItertor<T> implements Iterator<T>{
    public ConcreteItertor(List<T> list) {
        this.list = list;
    }
    private List<T> list = new ArrayList<>();
    private int cursor = 0;
    @Override
    public boolean hasNext() {
        return cursor!=list.size();
    }

    @Override
    public T next() {
        T obj = null;
        if(this.hasNext()){
            obj = list.get(cursor++);
        }
        return obj;
    }
}

方式适用条件
在以下情形下能够动用迭代器方式:
 访问多个汇聚对象的内容而无须揭示它的里边表示。
 须求为汇集对象提供种种遍历情势。
 为遍历不一致的集结结构提供二个统一的接口。

ConcreteIterator: 具体迭代器

Aggregate:
/**
 * 容器的接口
 */
public interface Aggregate<T> {
    void add(T t);

    void remove(T t);

    Iterator<T> iterator();
}

格局动机
图片 3

方式优缺点
迭代器格局的独到之处
 它援助以不一样的点子遍历三个集合对象。
 迭代器简化了聚合类。
 在同1个集聚上能够有七个遍历。

在迭代器形式中,扩充新的聚合类和迭代器类都很便利,无须修改原有代码,满意“开闭原则”的渴求。
迭代器形式的症结

由于迭代器形式将积存数据和遍历数据的职分分开,扩展新的聚合类需求对应扩充新的迭代器类,类的个数成对扩展,这在任其自然程度上平添了系统的复杂。

1.1 介绍

迭代器格局(Iterator
Pattern)又称为游标(Cursor)情势,是行为型设计形式之一。
发源对容器的拜访,比如java中的list,Map,数组等,我们领悟对容器对象的拜会必将是司空见惯的,所以大家把遍历的方法封装在容器中,只怕不提供遍历方法。

namespace IteratorPattern
{
    //Aggregate聚集抽象类
    abstract class Aggregate
    {
        //创建迭代器
        public abstract Iterator CreateIterator();
    }
}

情势适用条件
在以下情状下能够利用迭代器形式:
 访问二个集结对象的剧情而无须揭发它的中间表示。
 需求为汇集对象提供各类遍历情势。
 为遍历差异的汇集结构提供1个联合的接口。

Client:
public class Client {
    public static void main(String[] args){
        //实例化容器类对象
        Aggregate<String> aggregate = new ConcreteAggregate<>();
        aggregate.add("aaaa");
        aggregate.add("bbbb");
        aggregate.add("cccc");
        Iterator<String> iterator = aggregate.iterator();
        while (iterator.hasNext()){
            System.out.println(iterator.next());
        }
    }
}

结果输出:

aaaa
bbbb
cccc

形式结构
迭代器格局涵盖如下剧中人物:
Iterator: 抽象迭代器
ConcreteIterator: 具体迭代器
Aggregate: 抽象聚合类
ConcreteAggregate: 具体聚合类

namespace IteratorPattern
{
    //Aggregate聚集抽象类
    abstract class Aggregate
    {
        //创建迭代器
        public abstract Iterator CreateIterator();
    }
}

壹 、迭代器形式概念

using System;

namespace IteratorPattern
{
    class Program
    {
        static void Main(string[] args)
        {
            ConcreteAggregate a = new ConcreteAggregate();
            a[0] = "张三";
            a[1] = "李四";
            a[2] = "王五";

            Iterator i = new ConcreteIterator(a);
            object item = i.First();
            while (!i.IsDone())
            {
                Console.WriteLine("{0} 请买车票!", i.CurrentItem());
                i.Next();//下一乘客
            }
            Console.Read();
        }
    }
}

Aggregate: 抽象聚合类

5.2 缺点
  • 鉴于迭代器方式将积存数据和遍历数据的职务分开,扩大新的聚合类须求对应增添新的迭代器类,类的个数成对扩展,那在早晚水准上加码了系统的复杂性。

形式优缺点
迭代器形式的长处
 它扶助以不一致的不二法门遍历多个汇合对象。
 迭代器简化了聚合类。
 在同四个集结上得以有五个遍历。

在迭代器方式中,扩展新的聚合类和迭代器类都很有益,无须修改原有代码,满足“开闭原则”的须求。
迭代器形式的缺点

由于迭代器格局将积存数据和遍历数据的职务分开,扩展新的聚合类供给对应增添新的迭代器类,类的个数成对增添,那在任其自流程度上平添了系统的复杂。

using System;

namespace IteratorPattern
{
    //ConcreteIterator具体迭代器类,继承Iterator
    class ConcreteIterator : Iterator
    {
        //定义一个具体聚集对象
        private ConcreteAggregate aggregate;
        private int current = 0;        
        //初始化时将具体的聚集对象传入
        public ConcreteIterator(ConcreteAggregate aggregate)
        {
            this.aggregate = aggregate;
        }
        public override object First()
        {
            return aggregate[0];
        }
        public override object Next()
        {
            Object ret = null;
            current++;
            if (current < aggregate.Count)
            {
                ret = aggregate[current];
            }
            return ret;
        }
        public override bool IsDone()
        {
            return current >= aggregate.Count ? true : false;
        }
        public override object CurrentItem()
        {
            return aggregate[current];//返回当前的聚集对象
        }
    }
}

叁 、迭代器格局完结

在迭代器情势中使用了工厂方法情势,聚合类充当工厂类,而迭代器充当产品类,由于定义了抽象层,系统的扩充性很好,在客户端能够本着抽象聚合类和抽象迭代器举行编制程序。
是因为广大编制程序语言的类库都已经落成了迭代器形式,因而在实质上选拔中我们很少自定义迭代器,只须求直接行使Java、C#等语言中已定义好的迭代器即可,迭代器已经化为我们操作聚合对象的焦点工具之一。

格局实例与分析
想走?能够!先定票—迭代器方式示例
系统布局
图片 4
Iterator: 抽象迭代器

Android 架构师之路 目录

【证明与感激】
本文,站在许多高个儿的肩头上,借鉴和引用了累累客人拥有版权的小说或撰文,在此,对前人们的进献致谢。并还要宣布引用的剧情、原小编或缘于(一些源于网络的始末小编不能够追述本源,深表遗憾)。

using System;

namespace IteratorPattern
{
    class Program
    {
        static void Main(string[] args)
        {
            ConcreteAggregate a = new ConcreteAggregate();
            a[0] = "张三";
            a[1] = "李四";
            a[2] = "王五";

            Iterator i = new ConcreteIterator(a);
            object item = i.First();
            while (!i.IsDone())
            {
                Console.WriteLine("{0} 请买车票!", i.CurrentItem());
                i.Next();//下一乘客
            }
            Console.Read();
        }
    }
}

贰 、迭代器情势UML类图

图片 5

迭代器形式UML类图

2个凑合对象,如一个列表(List)可能2个会面(Set),应该提供一种方法来让外人能够访问它的因素,而又不需求揭发它的内部结构。
本着分化的内需,恐怕还要以分歧的措施遍历整个聚合对象,可是大家并不愿目的在于集结对象的抽象层接口中浸透着各类区别遍历的操作。
什么遍历三个集结对象,又不须求理解聚合对象的内部结构,还是能够提供各类区别的遍历格局,这正是迭代器方式所要解决的题材。
在迭代器格局中,提供三个外部的迭代器来对聚集对象开始展览走访和遍历,迭代器定义了二个走访该聚合成分的接口,并且能够跟踪当前遍历的因素,掌握怎么因素已经遍历过而怎么样没有。
有了迭代器情势,大家会意识对二个繁杂的会合对象的操作会变得那般简约。

Client:客户类

ConcreteAggregate:
public class ConcreteAggregate<T> implements Aggregate<T> {

    private List<T> list = new ArrayList<>();
    @Override
    public void add(T t) {
      list.add(t);
    }

    @Override
    public void remove(T t) {
        list.remove(t);
    }

    @Override
    public Iterator<T> iterator() {
        return new ConcreteItertor<>(list);
    }
}

Client:客户类

在迭代器方式中采取了工厂方法情势,聚合类充当工厂类,而迭代器充当产品类,由于定义了抽象层,系统的扩充性很好,在客户端能够本着抽象聚合类和架空迭代器进行编制程序。
由于许多编制程序语言的类库都曾经落实了迭代器方式,因而在实际上利用中我们很少自定义迭代器,只须要从来运用Java、C#等语言中已定义好的迭代器即可,迭代器已经变为我们操作聚合对象的主题工具之一。

Iterator:
/**
*抽象迭代接口
*/
public interface Iterator <T>{

    /**
     * 是否有下一元素
     * @return
     */
    boolean hasNext();

    T next();
}
using System;

namespace IteratorPattern
{
    //ConcreteIterator具体迭代器类,继承Iterator
    class ConcreteIterator : Iterator
    {
        //定义一个具体聚集对象
        private ConcreteAggregate aggregate;
        private int current = 0;        
        //初始化时将具体的聚集对象传入
        public ConcreteIterator(ConcreteAggregate aggregate)
        {
            this.aggregate = aggregate;
        }
        public override object First()
        {
            return aggregate[0];
        }
        public override object Next()
        {
            Object ret = null;
            current++;
            if (current < aggregate.Count)
            {
                ret = aggregate[current];
            }
            return ret;
        }
        public override bool IsDone()
        {
            return current >= aggregate.Count ? true : false;
        }
        public override object CurrentItem()
        {
            return aggregate[current];//返回当前的聚集对象
        }
    }
}

【注解与多谢】
正文,站在广大大汉的肩头上,借鉴和引用了过多客人拥有版权的著述或撰文,在此,对前人们的孝敬致谢。并还要公布引用的剧情、原小编或缘于(一些源于互连网的始末笔者不可能追述本源,深表遗憾)。

1.3 使用意况
  • 做客3个集聚对象的内容而无需揭穿它的内部表示

  • 支撑对聚集对象的多样遍历

  • 为遍历区别的聚合结构提供四个合并的接口

方式定义
迭代器情势(Iterator Pattern)
:提供一种艺术来拜访聚合对象,而不用暴光这一个指标的内部表示,其别称为游标(Cursor)。迭代器格局是一种对象行为型情势。
Iterator Pattern: Provide a way to access the elements of an aggregate
object sequentially without exposing its underlying representation.
Frequency of use: high
UML图
图片 6

多个凑合对象,如一个列表(List)或许三个会合(Set),应该提供一种形式来让别人能够访问它的因素,而又不必要暴露它的内部结构。
针对区别的要求,只怕还要以区别的措施遍历整个聚合对象,不过我们并不期待在联谊对象的抽象层接口中浸透着各类差别遍历的操作。
什么遍历2个集合对象,又不须要精通聚合对象的内部结构,还是可以够够提供种种不相同的遍历格局,那正是迭代器形式所要化解的题目。
在迭代器格局中,提供贰个外部的迭代器来对聚集对象开展走访和遍历,迭代器定义了2个拜访该聚合成分的接口,并且能够跟踪当前遍历的因素,驾驭什么要素已经遍历过而什么没有。
有了迭代器情势,大家会意识对一个错综复杂的汇集对象的操作会变得这么简单。

剧中人物如下:

  • Iterator(迭代器):迭代器定义访问和遍历成分的接口

  • ConcreteIterator
    (具体迭代器)
    :具体迭代器落成迭代器接口,对该聚合遍历时跟踪当前职责

  • Aggregate (聚合):聚合定义创制相应迭代器对象的接口

  • ConcreteAggregate
    (具体集合)
    :具体集合达成成立相应迭代器的接口,该操作重返ConcreteIterator的八个适度的实例

ConcreteAggregate: 具体聚合类

using System;
using System.Collections.Generic;

namespace IteratorPattern
{
    //ConcreteAggregate具体聚集类 继承Aggregate
    class ConcreteAggregate : Aggregate
    {
        //声明一个IList泛型变量,用于存放聚合对象,用ArrayList同样可以实现
        private IList<object> items = new List<Object>();
        public override Iterator CreateIterator()
        {
            return new ConcreteIterator(this);
        }
        public int Count
        {
            get { return items.Count; }//返回聚集总个数
        }
        //声明一个索引器
        public object this[int index]
        {
            get { return items[index]; }
            set { items.Insert(index, value); }
        }
    }
}

情势实例与分析
想走?能够!先订票—迭代器格局示例
系统布局
图片 7
Iterator: 抽象迭代器

格局分析
聚拢是一个管理和协会数量对象的数据结构。
汇集对象首要持有多个职务:一是储存个中数据;二是遍历内部数据。
储存数据是集聚对象最基本的任务。
将遍历聚合对象中多少的一言一动提取出来,封装到多个迭代器中,通过专门的迭代器来遍历聚合对象的个中数据,那正是迭代器情势的原形。迭代器方式是“单一任务规范”的布帆无恙突显。

Aggregate: 抽象聚合类

namespace IteratorPattern
{
    //Iterator迭代器抽象类
    abstract class Iterator
    {
        //用于定义得到开始对象、得到下一个对象、
        //判断是否到结尾、当前对象等抽象方法,统一接口
        public abstract object First();
        public abstract object Next();
        public abstract bool IsDone();
        public abstract object CurrentItem();
    }
}

相关文章