软考软件设计师---面向对象技术（设计模式--行为型--责任链、命令、解释器、迭代器、中介者）

一、理解

（1）责任链：将处理用户请求的多个对象构成一条链，对用户而言只需将请求交给这条链就行，可用降低请求的发送者和接收者之间的耦合关系。

（2）命令：将请求封装成对象，用户使用请求对象就能完成求情操作，请求对象里有求情接收者的引用，即对用户而言请求接收者不可见。

（3）解释器：给定一个语言,定义它文法的一种表示，并定义一个解释器，这个解释器使用该表示来解释语言中的句子。

（4）迭代器：提供一种访问聚合对象中的各元素的方法，即对一个类中聚合着大量对象而言，写一个类单独来实现对这些聚合对象的访问。

（5）中介者：交互的对象不直接交互，通过中介者交互来实现间接交互，每个交互对象都只知道自己的中介者，中介者则知道交互双方对象，并决定将收到的信息传递给谁。

二、代码理解

（1）责任链

比如一个表单验证，假设验证顺序为，用户名、密码、验证码

定义一个处理求情的接口

public interface handler {
       handler next;
       void handlerRequest(); 
}

定义具体的验证用户名类

public authName implements handler {

      public authName(handler next){
            super.next=next;
      }
      void handlerRequest(form f) {
             if(f.name.equals()=="lusong") {
                   if(super.next!=null){
                      super.next.handlerRequest(f);
                   }
             }
             else{
                  System.out.println("用户名错误");
            }
     }
}

定义验证密码类

public authPasswd implements handler {

      public authName(handler next){
            super.next=next;
      }
      void handlerRequest(form f) {
             if(f.passwd.equals()=="123456") {
                   if(super.next!=null){
                      super.next.handlerRequest(f);
                   }
             else{
                  System.out.println("密码错误");
            }
     }
}

定义验证验证码类

public authAuthcode implements handler {

      public authName(handler next){
            super.next=next;
      }
      void handlerRequest(form f) {
             if(f.authCode.equals()=="ABCD") {
                   if(super.next!=null){
                      super.next.handlerRequest(f);
                   }                   
             }
             else{
                  System.out.println("验证码错误");
            }
     }
}

测试代码

public calss test {
      public static void main(String[] sgrc) {
              //假设有一表单 f
                                 //将验证功能的每个对象构成一条链
             bandler authAuthcode = new authAuthcode(null);
             bandler authPasswd = new authPasswd(authauthcode);
             bandler authName = new authName(authPasswd);
             form f =new form("lusong","123456","ABC");   //假设有表单类
             authName(f) 
      }

}

（2）命令

将命令封装成对象，对用户而言只需要使用命令对象就能和信息接收者进行交互。

例如，小明想打开电视，使用遥控器就能打开电视，

定义电视类

public class TV {
     void openTV() {
         System.out.println("电视打开");
     }
}

定义抽象命令接口

public abstract calss command {
      TV tv;
      execute();
}

定义打开电视具体命令

public class openTV  extends {
     public openTV() {
        super.tv=new TV();
     }
     excute() {
          tv.openTV();
     }
}

定义调用者

public class invoker {
        String name;
        command c;
        public invoker(String name,command c) {
              this.name=name;
               this.c=c;
        }
        public void openTV(){
              c.excute();
        }
}

测试

public class test {
      public static void main(String[] agrc) {
            command opnTV = new opentv();
           invoker xiaoming = new invoker("小明",opentv);
           xiaoming.open();
      }
 
}

（3）解释器

如有：A-->B-->C

非终止符：解释过程的中间产物，A、B都是非终止符。

终止符：解释的目标产物，C是终止符。

解释器：就是封装解释过程为对象，一个或多个，因为产物可能是非终止符。

例子：设计一个读卡器，北京或太原的老年和孕妇刷卡免费，其余人群标准价

抽象表达式

 public interface Expression {
     boolean interpret(String info);
 }

终结符表达式（具体实现者）

 public class TerminalExpression implements Expression{
     private Set<String> set = new HashSet<String>();
     public TerminalExpression(String[] data) {
         for (int i = 0; i < data.length; i++) {
             set.add(data[i]);
         }
     }
     public boolean interpret(String info) {
         if (set.contains(info)) {
             return true;
         }
         return false;
     }
 }

非终结符表达式（具体实现者）

 public class AndExpression implements Expression{
     //左半部分
     private Expression left;
     //右半部分
     private Expression right;
     //切分关键字
     public static final String FLEX = "的";
     public AndExpression(Expression city, Expression person) {
         this.left = city;
         this.right = person;
     }
     public boolean interpret(String info) {
         String s[] = info.split(FLEX);
         //符合文法的全部才会返回true
         return left.interpret(s[0]) && right.interpret(s[1]);
     }
 }

上下文Context

 public class Context {
     private String[] citys = {"北京", "太原"};
     private String[] persons = {"老人", "孕妇"};
     private Expression expression;
     public Context() {
         Expression city = new TerminalExpression(citys);
         Expression person = new TerminalExpression(persons);
         expression = new AndExpression(city, person);
     }
     public void freeRide(String info) {
         //提示语，可自行设置
         String s1 = "哔！"+info.split(FLEX)[1] + "卡，欢迎乘车，您本次乘车免费！";
         String s2 = "哔！欢迎乘车，您本次乘车扣费2元！";
         System.out.println(expression.interpret(info) ? s1 : s2);
     }
 }

程序调用

 //创建上下文运行环境，这里指刷卡用的bus
 Context bus = new Context();
 //不同人群刷卡
 System.out.println("公交乘车开始刷卡");
 bus.freeRide("北京的老人");
 bus.freeRide("太原的孕妇");
 bus.freeRide("太原的儿童");
 bus.freeRide("上海的老人");

输出

 公交乘车开始刷卡
 哔！老人卡，欢迎乘车，您本次乘车免费！
 哔！孕妇卡，欢迎乘车，您本次乘车免费！
 哔！欢迎乘车，您本次乘车扣费2元！
 哔！欢迎乘车，您本次乘车扣费2元！

（4）迭代器
为聚合类对象里的聚合元素提供顺序访问的方法。

例子：一学生容器里用很多学生对象。先封装一迭代器来实现遍历访问

/**
 * @author: xuzhilei6656
 * @create: 2022-02-14
 * @description: 学生类
 **/
public class Student {
    /**
     * 姓名
     */
    private String name;
    /**
     * 学号
     */
    private String number;
 
    public Student(String name, String number) {
        this.name = name;
        this.number = number;
    }
 
    public String getName() {
        return name;
    }
 
    public void setName(String name) {
        this.name = name;
    }
 
    public String getNumber() {
        return number;
    }
 
    public void setNumber(String number) {
        this.number = number;
    }
 
    @Override
    public String toString() {
        return "Student{" +
                "name='" + name + '\'' +
                ", number='" + number + '\'' +
                '}';
    }
}
/**
 * @author: xuzhilei6656
 * @create: 2022-02-14
 * @description: 抽象迭代器类
 **/
public interface StudentIterator {
    /**
     * 是否有下一个值
     * @return
     */
    boolean hasNext();
 
    /**
     * 取出下一个值
     * @return
     */
    Student next();
}
/**
 * @author: xuzhilei6656
 * @create: 2022-02-14
 * @description: 具体迭代器类
 **/
public class StudentIteratorImpl implements StudentIterator {
    private List<Student> list;
    private int position = 0;
 
    public StudentIteratorImpl(List<Student> list){
        this.list = list;
    }
 
    @Override
    public boolean hasNext() {
        return position < list.size();
    }
 
    @Override
    public Student next() {
        Student student = list.get(position);
        position++;
        return student;
    }
}
/**
 * @author: xuzhilei6656
 * @create: 2022-02-14
 * @description: 抽象容器类
 **/
public interface StudentAggregate {
    /**
     * 往容器添加元素
     * @param student
     */
    void addStudent(Student student);
 
    /**
     * 删除容器中元素
     * @param student
     */
    void removeStudent(Student student);
 
    /**
     * 获取迭代器
     * @return
     */
    StudentIterator getStudentIterator();
}
/**
 * @author: xuzhilei6656
 * @create: 2022-02-14
 * @description: 具体容器类
 **/
public class StudentAggregateImpl implements StudentAggregate {
    public static final List<Student> list = new ArrayList<>();
 
    @Override
    public void addStudent(Student student) {
        list.add(student);
    }
 
    @Override
    public void removeStudent(Student student) {
        list.remove(student);
    }
 
    @Override
    public StudentIterator getStudentIterator() {
        return new StudentIteratorImpl(list);
    }
}
/**
 * @author: xuzhilei6656
 * @create: 2022-02-14
 * @description: 测试
 **/
public class Client {
    public static void main(String[] args) {
        //创建容器对象
        StudentAggregate studentAggregate = new StudentAggregateImpl();
        //添加元素
        studentAggregate.addStudent(new Student("张三","123456"));
        studentAggregate.addStudent(new Student("李四","123789"));
        //获取迭代器
        StudentIterator studentIterator = studentAggregate.getStudentIterator();
        while (studentIterator.hasNext()){
            Student student = studentIterator.next();
            System.out.println(student);
        }
    }
}

（5）中介者

中介者对象有交互双方对象引用，交互双发只有中介者引用，即交互双发只能和中介者交互，再有中介者转发信息。

例子：详见这篇文章