Java进阶篇设计模式之九----- 解释器模式和迭代器模式

时间 2019-11-10

原文原文链接

前言

在上一篇中咱们学习了行为型模式的责任链模式(Chain of Responsibility Pattern)和命令模式（Command Pattern）。本篇则来学习下行为型模式的两个模式，解释器模式(Interpreter Pattern)和迭代器模式（Iterator Pattern）。html

解释器模式

简介java

解释器模式顾名思义，就是对某事物进行解释。给定一个语言以后，解释器模式能够定义出其文法的一种表示，并同时提供一个解释器。客户端可使用这个解释器来解释这个语言中的句子。git

解释器模式其实就是对某事物进行解释。好比生活中常常用到的计算器，将咱们用的语言转换成计算器预言，还有咱们编写代码时用到的正则表达式等等。《大话设计模式》中对这个模式有个比较有意思的讲解，其中示例就是把老板对不一样人说相同的话，不一样的人会理解不一样。这也说明的解释器模式核心就是进行解释。github

解释器模式主要由这四个角色组成，抽象表达式(Expression)角色、终结符表达式(Terminal Expression)角色、非终结符表达式(Nonterminal Expression)角色和环境(Context)角色。正则表达式

抽象解释器：声明一个全部具体表达式都要实现的抽象接口（或者抽象类），接口中主要是一个interpret()方法，称为解释操做。具体解释任务由它的各个实现类来完成，具体的解释器分别由终结符解释器TerminalExpression和非终结符解释器NonterminalExpression完成。
终结符表达式：实现与文法中的元素相关联的解释操做，一般一个解释器模式中只有一个终结符表达式，但有多个实例，对应不一样的终结符。终结符一半是文法中的运算单元，好比有一个简单的公式R=R1+R2，在里面R1和R2就是终结符，对应的解析R1和R2的解释器就是终结符表达式。
非终结符表达式：文法中的每条规则对应于一个非终结符表达式，非终结符表达式通常是文法中的运算符或者其余关键字，好比公式R=R1+R2中，+就是非终结符，解析+的解释器就是一个非终结符表达式。非终结符表达式根据逻辑的复杂程度而增长，原则上每一个文法规则都对应一个非终结符表达式。
环境角色：这个角色的任务通常是用来存放文法中各个终结符所对应的具体值，好比R=R1+R2，咱们给R1赋值100，给R2赋值200。这些信息须要存放到环境角色中，不少状况下咱们使用Map来充当环境角色就足够了。

这里为了方便理解，咱们使用一个简单的示例来加以说明。
日常咱们在进行英语学习的时候，会自行翻译或者用到翻译工具。可是不一样的翻译工具翻译的结果也可能不同，这时咱们只须要拿到本身想要的结果就好了。好比，使用百度和有道翻译“好好学习，每天向上！”，它们翻译的结果分别为“Study hard and keep up!”和“study hard and make progress every day！”，而xuwujing翻译的结果是“ Good good study, day day up！”。
那么咱们即可以用解释器模式来实现这种场景。
首先定义一个抽象的解释器接口，有解释的这个方法，而后再定义不一样的解释器实现该接口和方法，最后再来进行测试。那么代码以下:sql

interface Expreeion{
   void interpert(String word);
}

class  BaiduExpreeion implements Expreeion{
   String str ="好好学习，每天向上!";
   @Override
   public void interpert(String word) {
       if(str.equals(word)) {
           System.out.println("百度翻译："+word+" 的英文是  Study hard and keep up!");
       }
   }
}

class  YouDaoExpreeion implements Expreeion{
   String str ="好好学习，每天向上!";
   @Override
   public void interpert(String word) {
       if(str.equals(word)) {
           System.out.println("有道翻译："+word+" 的英文是  study hard and make progress every day！");
       }
   }
}

class  XuWuJingExpreeion implements Expreeion{
   String str ="好好学习，每天向上!";
   @Override
   public void interpert(String word) {
       if(str.equals(word)) {
           System.out.println("xuwujing翻译："+word+" 的英文是  Good good study, day day up！");
       }
   }
}

public class InterpreterTest {
   public static void main(String[] args) {
       String word = "好好学习，每天向上!";
       Expreeion expreeion =new  BaiduExpreeion();
       Expreeion expreeion2 =new  YouDaoExpreeion();
       Expreeion expreeion3 =new  XuWuJingExpreeion();
       expreeion.interpert(word);
       expreeion2.interpert(word);
       expreeion3.interpert(word);
   }
}

输出结果:设计模式

百度翻译：好好学习，每天向上! 的英文是  Study hard and keep up!
有道翻译：好好学习，每天向上! 的英文是  study hard and make progress every day！
xuwujing翻译：好好学习，每天向上! 的英文是  Good good study, day day up！

解释器模式优势：数组

扩展性好，子类扩展很是方便。
实现简单。ide

解释器模式缺点：工具

可以使用的场景比较少；
类过多的话，会使代码臃肿，难以维护；

使用场景：

一个简单的语法规则须要解释的场景，好比sql。
有重复的问题的时候。

迭代器模式

简介

迭代器模式用于顺序访问集合对象的元素，不须要知道集合对象的底层表示，属于行为型模式。它提供一种方法顺序访问一个聚合对象中各个元素, 而又无须暴露该对象的内部表示。

咱们对迭代器（Iterator）确定不陌生，由于咱们在Java开发中会常常用到，好比对List、Set和Map集合进行遍历或对数组进行遍历的时候。可是迭代器模式的话，可能就不太理解了，这里咱们就简单讲讲迭代器模式。

迭代器模式主要由这四个角色组成，迭代器角色（Iterator）、具体迭代器角色（Concrete Iterator）、容器角色（Container）和具体容器角色（Concrete Container）。

迭代器角色（Iterator）：经过接口或抽象类声明实现的方法。
具体迭代器角色（Concrete Iterator）：具体迭代器角色要实现迭代器接口，并要记录遍历中的当前位置。
容器角色（Container）：容器角色负责提供建立具体迭代器角色的接口。
具体容器角色（Concrete Container）：具体容器角色实现建立具体迭代器角色的接口——这个具体迭代器角色于该容器的结构相关。

由于迭代器咱们平时用的比较多，这里也不在过多描述了，这里就简单的介绍下迭代器模式的运做。
首先，定义一个迭代器角色（MyIterator ）和容器角色（MyIterable）的接口。
代码以下:

interface MyIterator {
    boolean hasNext();
    String next();
}

interface MyIterable{
    MyIterator getIterator();
    void add(String str);
    String get(int index);
}

而后定义一个具体容器角色（ListContainer ）实现容器角色的接口，这里的实现方法经过List自带的进行实现；而后再定义一个具体迭代器角色（ListIterator ）实现迭代器角色的接口，这里的实现的方法由本身实现。
那么代码以下:

class ListContainer implements MyIterable {
    
     private List<String> list =new ArrayList<>(); 

     
    @Override
    public MyIterator getIterator() {
        return new ListIterator();
    }

    @Override
    public void add(String str) {
        list.add(str);
    }

    @Override
    public String get(int index) {
        return list.get(index);
    }
    
    class ListIterator implements MyIterator{
        int index;
        @Override
        public boolean hasNext() {
            return index < list.size();
        }

        @Override
        public String next() {
            if (this.hasNext()) {
                return list.get(index++);
            }
            return null;
        }
    }
}

最后再来进行代码的测试。
测试代码以下:

public static void main(String[] args) {
        MyIterable myIterable = new ListContainer();
        myIterable.add("1");
        myIterable.add("zhangsan");
        myIterable.add("2");
        myIterable.add("lisi");
        myIterable.add("3");
        myIterable.add("xuwujing"); 
        MyIterator myIterator = myIterable.getIterator();
        while (myIterator.hasNext()){
            String str = myIterator.next();
            System.out.println(str);
        }      
    }

输出结果:

1
        zhangsan
        2
        lisi
        3
        xuwujing

迭代器模式优势：

灵活度高，能够经过不一样的方式遍历对象；
扩展性好，能够很方便的增长新的聚合类和迭代器类而不用修改以前的代码。

迭代器模式缺点：

因为迭代器模式将存储数据和遍历数据的职责分离，增长新的聚合类须要对应增长新的迭代器类，类的个数成对增长，这在必定程度上增长了系统的复杂性。

使用场景：

须要为聚合对象提供遍历的功能的时候。

其它

音乐推荐

分享一首很好听的日语歌曲！

项目的代码

java-study是本人在学习Java过程当中记录的一些代码，也包括以前博文中使用的代码。若是感受不错，但愿顺手给个start，固然若是有不足，也但愿提出。
github地址: https://github.com/xuwujing/java-study