又不需求精通聚合对象的内部结构,Android 架构师之路 目录

情势动机
图片 1

形式动机
图片 2

Android 架构师之路 目录

二个集合对象,如三个列表(List)也许三个凑合(Set),应该提供一种方法来让旁人能够访问它的成分,而又不须求揭穿它的内部结构。
本着分歧的急需,或然还要以差异的方法遍历整个聚合对象,可是我们并不希望在集合对象的抽象层接口中充满着各类不相同遍历的操作。
怎么样遍历二个集聚对象,又不须要通晓聚合对象的内部结构,还能够够提供三种差别的遍历格局,那正是迭代器情势所要消除的标题。
在迭代器格局中,提供三个表面包车型地铁迭代器来对聚集对象开始展览走访和遍历,迭代器定义了三个做客该聚合成分的接口,并且能够跟踪当前遍历的因素,掌握哪些要素已经遍历过而怎么着没有。
有了迭代器情势,大家会意识对三个复杂的集纳对象的操作会变得这么容易。

贰个汇集对象,如多个列表(List)或许一个聚集(Set),应该提供一种方式来令人家能够访问它的因素,而又不须求暴光它的内部结构。
本着不一样的供给,大概还要以分化的办法遍历整个聚合对象,可是大家并不希望在联谊对象的抽象层接口中充满着种种区别遍历的操作。
怎样遍历二个集合对象,又不须要精通聚合对象的内部结构,还是能够够提供各类差异的遍历格局,那正是迭代器方式所要化解的标题。
在迭代器形式中,提供多个表面包车型客车迭代器来对聚集对象进行访问和遍历,迭代器定义了二个做客该聚合成分的接口,并且可以跟踪当前遍历的成分,精通哪些要素已经遍历过而什么没有。
有了迭代器格局,大家会发现对1个繁杂的汇合对象的操作会变得这么不难。

一 、迭代器形式概念

情势定义
迭代器方式(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图
图片 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图
图片 4

1.1 介绍

迭代器形式(Iterator
Pattern)又叫做游标(Cursor)格局,是行为型设计格局之一。
来源对容器的访问,比如java中的list,Map,数组等,大家知晓对容器对象的拜访必将是应有尽有的,所以大家把遍历的法子封装在容器中,只怕不提供遍历方法。

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

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

1.2 定义

提供一种办法顺序访问3个容器对象中的各种要素,而又不须求揭破该对象的内部表示。

情势分析
聚拢是贰个管制和公司数量对象的数据结构。
汇合对象首要存有三个职责:一是储存个中数据;二是遍历内部数据。
存款和储蓄数据是汇集对象最中央的任务。
将遍历聚合对象中多少的行事提取出来,封装到二个迭代器中,通过专门的迭代器来遍历聚合对象的内部数据,那正是迭代器形式的原形。迭代器情势是“单一职责规范”的一应俱整体现。

情势分析
聚拢是一个管理和团队数量对象的数据结构。
集结对象首要持有几个职务:一是储存当中数据;二是遍历内部数据。
仓库储存数据是汇集对象最中央的天职。
将遍历聚合对象中数据的行为提取出来,封装到三个迭代器中,通过专门的迭代器来遍历聚合对象的个中数据,这正是迭代器方式的原形。迭代器格局是“单一职责规范”的两整突显。

1.3 使用情状
  • 访问二个集聚对象的剧情而无需暴光它的在那之中表示

  • 帮衬对聚集对象的多样遍历

  • 为遍历不相同的聚众结构提供三个统一的接口

在迭代器方式中央银行使了工厂方法情势,聚合类充当工厂类,而迭代器充当产品类,由于定义了抽象层,系统的扩充性很好,在客户端能够针对抽象聚合类和架空迭代器进行编制程序。
由于许多编制程序语言的类库都曾经落到实处了迭代器形式,因而在实际利用中大家很少自定义迭代器,只需求一向运用Java、C#等语言中已定义好的迭代器即可,迭代器已经变成大家操作聚合对象的主干工具之一。

在迭代器格局中使用了工厂方法方式,聚合类充当工厂类,而迭代器充当产品类,由于定义了抽象层,系统的增添性很好,在客户端能够针对抽象聚合类和抽象迭代器实行编制程序。
出于广大编制程序语言的类库都早就落到实处了迭代器形式,因而在实际上利用中我们很少自定义迭代器,只须要一向行使Java、C#等语言中已定义好的迭代器即可,迭代器已经变为大家操作聚合对象的宗旨工具之一。

② 、迭代器方式UML类图

图片 5

迭代器格局UML类图

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

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

剧中人物如下:

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

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

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

  • ConcreteAggregate
    (具体集合)
    :具体集合落成成立相应迭代器的接口,该操作返回ConcreteIterator的一个得体的实例

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

三 、迭代器方式完成

ConcreteIterator: 具体迭代器

ConcreteIterator: 具体迭代器

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];//返回当前的聚集对象
        }
    }
}
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];//返回当前的聚集对象
        }
    }
}
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;
    }
}

Aggregate: 抽象聚合类

Aggregate: 抽象聚合类

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

    void remove(T t);

    Iterator<T> iterator();
}
namespace IteratorPattern
{
    //Aggregate聚集抽象类
    abstract class Aggregate
    {
        //创建迭代器
        public abstract Iterator CreateIterator();
    }
}
namespace IteratorPattern
{
    //Aggregate聚集抽象类
    abstract class Aggregate
    {
        //创建迭代器
        public abstract Iterator CreateIterator();
    }
}
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);
    }
}

ConcreteAggregate: 具体聚合类

ConcreteAggregate: 具体聚合类

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
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); }
        }
    }
}
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); }
        }
    }
}

肆 、Android源码中的情势达成

1.除了种种数据结构体,如List,Map等带有的迭代器外
2.Android本身源码中也为大家提供了迭代器遍历数据,最为典型的例证就是数据库查询利用Cursor(当大家采取SQLiteDatabase的query方法查询数据库时再次来到的),该游标对象实质正是2个切实可行的迭代器,大家得以动用它来遍历数据库查询所得的结果集

Client:客户类

Client:客户类

伍 、形式计算

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();
        }
    }
}
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();
        }
    }
}
5.1 优点
  • 它辅助以不相同的法门遍历四个相会对象。
  • 迭代器简化了聚合类。
  • 在同一个聚集上能够有三个遍历。
  • 在迭代器形式中,增添新的聚合类和迭代器类都很便利,无须修改原有代码。

方式优缺点
迭代器格局的帮助和益处
 它帮助以差异的艺术遍历叁个聚集对象。
 迭代器简化了聚合类。
 在同3个集合上得以有四个遍历。

在迭代器形式中,增添新的聚合类和迭代器类都很有益于,无须修改原有代码,知足“开闭原则”的供给。
迭代器情势的后天不足

由于迭代器情势将积存数据和遍历数据的天职务开,增添新的聚合类供给对应增添新的迭代器类,类的个数成对扩大,这在一定水平上扩大了系统的扑朔迷离。

情势优缺点
迭代器形式的优点
 它补助以不一致的法子遍历3个会晤对象。
 迭代器简化了聚合类。
 在同3个聚集上得以有多个遍历。

在迭代器方式中,扩充新的聚合类和迭代器类都很有益,无须修改原有代码,满意“开闭原则”的供给。
迭代器情势的弱项

由于迭代器方式将积存数据和遍历数据的职分分开,扩张新的聚合类要求对应增加新的迭代器类,类的个数成对扩展,那在听其自然程度上平添了系统的复杂。

5.2 缺点
  • 是因为迭代器方式将积存数据和遍历数据的天任务开,增添新的聚合类须求对应增添新的迭代器类,类的个数成对扩充,那在必然水平上加码了系统的繁杂。

情势适用条件
在偏下意况下能够运用迭代器方式:
 访问三个聚集对象的始末而无须暴光它的内部表示。
 需求为汇集对象提供多样遍历方式。
 为遍历差异的聚众结构提供二个联合的接口。

方式适用条件
在以下情形下得以应用迭代器形式:
 访问3个成团对象的剧情而无须暴露它的个中表示。
 须要为集聚对象提供各样遍历格局。
 为遍历区别的集纳结构提供3个统一的接口。

【表明与谢谢】
本文,站在无数壮汉的双肩上,借鉴和引用了见怪不怪别人拥有版权的文章或撰文,在此,对前人们的贡献致谢。并同时公布引用的始末、原来的书文者或出自(一些来自互连网的内容自己无法追述本源,深表遗憾)。

【申明与多谢】
正文,站在层见迭出壮汉的肩膀上,借鉴和引用了重重别人拥有版权的著述或撰文,在此,对前人们的孝敬致谢。并同时发表引用的内容、原著者或出自(一些来自网络的剧情本人不能追述本源,深表遗憾)。

【参考文献】
《设计方式—可复用面向对象软件的根底》小编: [美] 埃里克h Gamma / RichardHelm / 拉尔夫 约翰逊 / John Vlissides 译者: 李英军 / 马晓星 / 蔡敏 /
刘建中 等 机械工业出版社
《重构—改进既有代码的统一筹划》作者: 马丁 Fowler译者:候捷
中华夏族民共和国电力出版社
《敏捷软件开发—原则、方式与实践》小编: Robert C. 马丁 清华大学出版社
《程序员修炼之道—从小工到学者》小编: Andrew Hunt / 大卫 Thomas电子工业出版社
《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 译者: 李英军 / 马晓星 / 蔡敏 /
刘建中 等 机械工业出版社
《重构—改进既有代码的布署性》作者: Martin Fowler译者:候捷
中华夏族民共和国电力出版社
《敏捷软件开发—原则、情势与实施》小编: 罗Bert C. 马丁 南开东军政大学学出版社
《程序员修炼之道—从小工到大家》小编: Andrew Hunt / 大卫 托马斯电子工业出版社
《Head First 设计方式》小编: Freeman 译者: O’Reilly Taiwan公司中华夏族民共和国电力出版社
《设计方式之禅》 笔者: 秦小波 机械工业出版社
MSDN WebCast 《C#面向对象设计情势纵横谈》 教授:李建忠
刘伟同志. 设计形式. 北京:北大东军大学出版社, 二零一二.
刘伟先生. 设计格局实验和培养和磨炼教程. 新加坡:哈工业余大学学东军事和政治大学学出版社, 2013.
《大话设计形式》 作者: 程杰 北大东军大学出版社
《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

相关文章