设计模式之行为型4

行为型模式，共十一种：策略模式、模板方法模式、观察者模式、迭代器模式、责任链模式、命令模式、备忘录模式、状态模式、访问者模式、中介者模式、解释器模式。

1. 解释器模式

解释器模式(interpreter)，给定一个语言，定义它的文法的一种表示，并定义一个解释器，这个解释器使用该表示来解释语言中的句子。

解释器模式需要解决的是，如果一种特定类型的问题发生的频率足够高，那么可能就值得将该问题的各个实例表述为一个简单语言中的句子。这样就可以构建一个解释器，该解释器通过解释这些句子来解决问题。

解释器模式结构图

代码实现

AbstractExpression(抽象表达式)，声明一个抽象的解释操作，这个接口作为抽象语法树中所有的节点所共享。
```
abstract class AbstractExpression{
    public abstract void interpret(Context context);
}
```

TerminalExpression(终结符表达式)，实现与文法的终结符相关联的解释操作。

class TerminalExpression extends AbstractExpression{
    
    @override
    public void interpret(Context context){
        System.out.println("终端解释器");
    }
}

NoterminalExpression(非终结符表达式)，为文法中的非终结符实现解释操作。

class NoterminalExpression extends AbstractExpression{
    
    @override
    public void interpret(Context context){
        System.out.println("非终端解释器");
    }
}

Context，包含解释器之外的一些全局信息。

class Context{
    private String input;
    
    public void setInput(String input){
        this.input = input;
    }
    
    public String getInput(){
        return input;
    }
    
    private String output;
    
    public void setOutput(String output){
        this.output = onput;
    }
    
    public String getOutput(){
        return output;
    }
}

客户端代码

static void main(String[] args){
    Context context = new Context();
    List<AbstractException> list = new ArrayList<>();
    list.add(new TerminalExpression());
    list.add(new NonterminalExpression());
    list.add(new TerminalExpression());
    list.add(new TerminalExpression());
    
    for(AbstractExpression e : list){
        e.interpret(context);
    }
}

小结

解释器模式就是使用“迷你语言”来表现程序要解决的问题。解释器模式也有不足的地方，解释器模式为文法中的每一条规则至少定义了一个类，因此包含许多规则的文法可能难维护和管理。

2. 访问者模式

访问者模式(Visitor)，表示一个作用于某对象结构中的个元素的操作。它使你可以在不改变各元素的类的前提下定义作用于这些元素的新操作。

访问者模式结构图

代码举例

以学校内的师生为例

抽象出一个person类

abstract class Person {
    public abstract void accept(IVisitor visitor);
}

学生继承person类，并实现accept方法

class Student extends Person {
    private String name;
    private int age;
    public Student(String name,int age){
        this.name = name;
        this.age = age;
    }

    public String getName() {
        return name;
    }

    public int getAge() {
        return age;
    }

    public void accept(IVisitor visitor) {
        visitor.visit(this);
    }
}

老师继承person类，并实现accept方法

class Teacher extends Person {
    private String name;
    private int age;
    public Teacher(String name,int age){
        this.name = name;
        this.age = age;
    }

    public int getAge() {
        return age;
    }

    public String getName() {
        return name;
    }

    public void accept(IVisitor visitor) {
        visitor.visit(this);
    }
}

对于访问者，抽象出一个接口IVisitor，里面定义了visit方法

interface IVisitor {
    public void visit(Student student);
    public void visit(Teacher teacher);
}

得到人员名字的访问者

class VisitorName implements IVisitor {

    public void visit(Student student) {
        System.out.println(student.getName());
    }

    public void visit(Teacher teacher) {
        System.out.println(teacher.getName());
    }
}

得到人员年龄的访问者

class VisitorAge implements IVisitor {

    public void visit(Student student) {
        System.out.println(student.getAge());
    }

    public void visit(Teacher teacher) {
        System.out.println(teacher.getAge());
    }
}

客户端调用方法

public class Client {
    public static void main(String[] args){
        List<Person> list = Allperson.getList();
        System.out.println("得到名字:");
        for(Person e: list){
            e.accept(new VisitorName());
        }
        System.out.println("得到年龄:");
        for(Person e: list){
            e.accept(new VisitorAge());
        }
    }
}

小结
- 访问者模式适用于数据结构相对稳定的系统，它把数据结构和作用于结构上的操作之间的耦合解脱开，使得操作集合可以相对自由地演化
- 增加新的操作很容易，因为增加新的操作就意味着增加一个新的访问者
- 增加新的数据结构变得困难，会违背开闭原则

3. 中介者模式

中介者模式(Mediator),用一个中介对象来封装一系列的对象交互。中介者使各对象不需要显示地相互引用，从而使其耦合松散，而且可以独立地改变它们之间的交互。

中介者模式结构图

代码实现

Mediator类，抽象中介者类

abstract class Mediator{
    //定义一个抽象的发送消息方法，得到对象和发送信息
    public abstract void send(String message,Colleague colleague);
}

Colleague类抽象同事类

abstract class Colleague{
    protected Mediator mediator;
    
    public Colleague(Mediator mediator){
        //构造方法，得到中介者对象
        this.mediator = mediator;
    }
}

ConcreteMediator类具体中介者类

class COncreteMidator extends Mediator{
    
    private ConcreteColleague1 colleague1;
    private ConcreteColleague2 colleageu2;
    
    //get set方法
    
    
    
    @override
    public void send(String message, Colleague colleague){
        if(colleague == colleague1){
            colleague2.notify(message);
        }else{
            colleague1.notify(message);
        }
    }
}

ConcreteColleague1和ConcreteColleague2

class ConcreteColleague1 extends Colleague{
    
    public ConcreteColleague1(Mediator mediator){
        this.mediator = super.mediator;
    }
    
    public void notify(String message){
        System.out.println("同事1得到信息：" + message);
    }
}

class ConcreteColleague2 extends Colleague{
    
    public ConcreteColleague2(Mediator mediator){
        this.mediator = super.mediator;
    }
    
    public void notify(String message){
        System.out.println("同事2得到信息：" + message);
    }
}

客户端调用

static void main(String[] args){
    ConcreteMediator m = new ConcreteMediator();
    
    ConcreteColleague1 c1 = new ConcreteColleague1(m);
    ConcreteColleague1 c2 = new ConcreteColleague2(m);
    
    m.setColleague(c1);
    m.setColleague(c2);
    
    c1.send("hello");
    c2.send("en heng");
    
}

小结

中介者模式的使用，使得各个部分可以分别变动和扩展，而不用考虑相互之间的耦合关系，将各部分的联系都交给中介者去处理，但这样也会使得中介者非常复杂。

posted on 2022-08-02 09:47 小迟在努力阅读(29) 评论(0) 收藏举报

刷新页面返回顶部

xiaobenchi

导航

公告

设计模式之行为型4

设计模式之行为型4