24种设计模式之行为型模式(下)-Java版

最新推荐文章于 2024-05-20 23:45:16 发布
最新推荐文章于 2024-05-20 23:45:16 发布
阅读量1.2k 收藏 18
点赞数 15
分类专栏： 设计模式 文章标签： 设计模式 java 开发语言
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/nuist_NJUPT/article/details/136009992
版权

软件设计模式是前辈们代码设计经验的总结，可以反复使用。设计模式共分为3大类，创建者模式(6种)、结构型模式(7种)、行为型模式(11种)，一共24种设计模式，软件设计一般需要满足7大基本原则。下面通过5章的学习一起来看看设计模式的魅力吧。

行为模式(11种)：本质是描述类与对象协助完成单个对象无法完成的任务，以及怎么分配职责。

包括：模板方法、策略、命令、责任链、状态、观察者、中介者模式、迭代器、访问者、备忘录、解释器。

目录

1.中介者模式

2.迭代器模式

3.访问者模式

4.备忘录模式

5.解释器模式

1.中介者模式

定义：中介者模式又称为调停模式，定义一个中介角色来封装一系列对象的交互操作，使得原有对象之间耦合度减小。

中介者模式包含以下角色：

01.抽象中介者：中介者接口，提供同事对象注册与转发同事对象的抽象方法。

02.具体中介者：协调各个同事之间的关系。

03.抽象同事类：定义同事类的接口，保存中介者对象，提供同事对象交互的抽象方法。

04.具体同事类：抽象同事类的实现者。

中介者模式的优缺点及使用场景：

优点：松散耦合、集中控制。

缺点：同事类比较多的情况下，中介者的职责将变得复杂而庞大。

使用场景：系统中对象存在复杂的引用关系，系统结构混乱且难以理解。

下面通过一个租房的案例学习一下中介者模式，房主和租客是同事类，中介就是中介类。

1.首先定义一个抽象同事类，包含房主与租客的名字，以及中介对象。

/**
 * @author nuist__NJUPT
 * @ClassName Person
 * @description: 抽象同事类
 * @date 2024年02月03日
 */
public abstract class Person {
    protected String name ;
    protected Mediator mediator ;

    public Person(String name, Mediator mediator) {
        this.name = name;
        this.mediator = mediator;
    }
}

2.然后定义一个抽象的中介对象，用于和房主以及租客进行沟通。

/**
 * @author nuist__NJUPT
 * @ClassName Mediator
 * @description: 抽象中介者类
 * @date 2024年02月03日
 */
public abstract class Mediator {
    public abstract void contact(String message, Person person) ;
}

3.定义具体的同事角色类，即租客类与房主类，需要获取信息并与中介进行沟通。

/**
 * @author nuist__NJUPT
 * @ClassName HouseOwner
 * @description: 具体的同事角色类
 * @date 2024年02月03日
 */
public class HouseOwner extends Person {

    public HouseOwner(String name, Mediator mediator) {
        super(name, mediator);
    }

    // 和中介进行沟通
    public void contact(String message){
        mediator.contact(message, this);
    }

    // 获取信息
    public void getMessage(String message){
        System.out.println("房东" + name + "获取到的信息：" + message);
    }
}


/**
 * @author nuist__NJUPT
 * @ClassName Tenant
 * @description: 具体同事角色类
 * @date 2024年02月03日
 */
public class Tenant extends Person {

    public Tenant(String name, Mediator mediator) {
        super(name, mediator);
    }

    // 和中介进行沟通
    public void contact(String message){
        mediator.contact(message, this);
    }

    // 获取信息
    public void getMessage(String message){
        System.out.println("租房者" + name + "获取到的信息：" + message);
    }

}

4.定义具体的中介类，用于和房主以及租客进行沟通。

/**
 * @author nuist__NJUPT
 * @ClassName MediatorStructure
 * @description: 具体的中介者类
 * @date 2024年02月03日
 */
public class MediatorStructure extends Mediator {

    // 聚合同事角色类：房主和租客
    private HouseOwner houseOwner ;
    private Tenant tenant ;

    public HouseOwner getHouseOwner() {
        return houseOwner;
    }

    public void setHouseOwner(HouseOwner houseOwner) {
        this.houseOwner = houseOwner;
    }

    public Tenant getTenant() {
        return tenant;
    }

    public void setTenant(Tenant tenant) {
        this.tenant = tenant;
    }

    // 和中介沟通
    public void contact(String message, Person person){
        if(person == houseOwner){
            tenant.getMessage(message);
        }else if(person == tenant){
            houseOwner.getMessage(message);
        }
    }

}

5.最后创建测试类：创建中介，创建房主与租客，使中介知道该房主与租客，最后通过中介进行沟通。

/**
 * @author nuist__NJUPT
 * @ClassName Client
 * @description: 客户端测试类
 * @date 2024年02月03日
 */
public class Client {
    public static void main(String[] args) {
        // 创建中介对象
        MediatorStructure mediatorStructure = new MediatorStructure() ;
        // 创建房主与租客对象
        HouseOwner houseOwner = new HouseOwner("肥婆", mediatorStructure) ;
        Tenant tenant = new Tenant("小王", mediatorStructure) ;
        // 中介需要知道具体的房主与租客
        mediatorStructure.setHouseOwner(houseOwner);
        mediatorStructure.setTenant(tenant);
        // 通过中介完成房主与租客进行沟通
        tenant.contact("请问有单间可以出租吗？");
        houseOwner.contact("有的...");
    }
}

2.迭代器模式

定义：提供一个对象来访问聚合对象中的一系列数据，而不暴露聚合对象的内部表示。

迭代器模式主要包含如下角色：
01.抽象聚合角色：定义元素操作以及迭代器对象的接口。

02.具体聚合角色：实现抽象聚合角色，返回一个具体的迭代器对象。

03.抽象迭代器角色：定义访问和遍历聚合元素的接口，包含next()等方法。

04.具体迭代器角色：实现抽象迭代器类并重写相应的抽象方法遍历与访问聚合元素。

迭代器模式的优缺点及使用场景：

优点：支持以不同方式遍历一个聚合对象，简化了聚合类的设计，满足开闭原则。

缺点：增加了类的数目，在一定程度上增加了系统的复杂度。

使用场景：遍历聚合对象，提供统一接口，不暴露内部实现细节。在java的集合中使用了迭代器模式，使用迭代器可以遍历集合元素。

下面定义一个存储学生对象的容器对象，将遍历该容器的功能交给迭代器实现。

1.定义一个学生对象，包含姓名合编号。


/**
 * @author nuist__NJUPT
 * @ClassName Student
 * @description: 学生对象
 * @date 2024年02月03日
 */
public class Student {

    private String name ;
    private String 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 + '\'' +
                '}';
    }

    public Student(String name, String number) {
        this.name = name;
        this.number = number;
    }

    public Student() {
    }
}

2.定义聚合接口及其实现类，用于用于添加/删除学生对象以及获取迭代器对象。



/**
 * @author nuist__NJUPT
 * @InterfaceName StudentAggregate
 * @description: 抽象聚合角色
 * @date 2024年02月03日
 */
public interface StudentAggregate {

    // 添加学生
    void addStudent(Student student) ;
    // 删除学生
    void removeStudent(Student student) ;
    // 获取迭代器对象
    StudentIterator getStudentIterator() ;
}


import java.util.ArrayList;
import java.util.List;

/**
 * @author nuist__NJUPT
 * @ClassName StudentAggregateImpl
 * @description: 具体聚合角色
 * @date 2024年02月03日
 */
public class StudentAggregateImpl implements  StudentAggregate {

    private List<Student> list = new ArrayList<Student>() ;

    public void addStudent(Student student) {
        list.add(student) ;
    }

    public void removeStudent(Student student) {
        list.remove(student) ;
    }

    public StudentIterator getStudentIterator() {
        return new StudentIteratorImpl(list);
    }
}

3.定义迭代器接口及其实现类，用于遍历迭代器元素。

/**
 * @author nuist__NJUPT
 * @InterfaceName StudentIterator
 * @description: 抽象迭代器角色接口
 * @date 2024年02月03日
 */
public interface StudentIterator {

    // 判断是否还有元素
    boolean hasNext() ;

    // 获取下一个元素
    Student next() ;

}
import java.util.List;

/**
 * @author nuist__NJUPT
 * @ClassName StudentIteratorImpl
 * @description: 具体迭代器角色
 * @date 2024年02月03日
 */
public class StudentIteratorImpl implements StudentIterator {

    List<Student> list ;
    private int position = 0 ;

    public StudentIteratorImpl(List<Student> list) {
        this.list = list;
    }

    public boolean hasNext() {
        return position < list.size() ;
    }

    public Student next() {
        return list.get(position++);
    }
}

4.定义客户端测试类，通过向聚合对象添加学生对象，通过获取迭代器对象，遍历元素。


/**
 * @author nuist__NJUPT
 * @ClassName Client
 * @description: 客户端测试类
 * @date 2024年02月03日
 */
public class Client {
    public static void main(String[] args) {
        // 创建聚合对象
        StudentAggregate studentAggregate = new StudentAggregateImpl() ;
        // 添加学生对象
        studentAggregate.addStudent(new Student("张三", "1"));
        studentAggregate.addStudent(new Student("王五", "2"));
        studentAggregate.addStudent(new Student("李四", "3"));
        // 获取迭代器对象
        StudentIterator iterator = studentAggregate.getStudentIterator();
        // 通过迭代器对象遍历
        while (iterator.hasNext()){
            System.out.println(iterator.next().toString());
        }
    }

}
3.访问者模式

定义：封装一些作用于某种数据结构的各种操作，在不改变数据结构的前提下定义作用于这些元素的新操作。

访问者模式包含以下角色：

01.抽象访问者角色：定义了对每个元素的访问行为。

02.具体访问者角色：定义了对每个元素类访问时所产生的具体行为。

03.抽象元素角色：定义一个接收访问者的方法。

04.具体元素角色：定义一个接收方法的具体实现。
05.对象结构：定义对象结构，包含一组元素及其迭代方式，供访问者访问。

访问者模式的优缺点及使用场景：

优点：扩展性好，复用性好，通过访问者来分离无关行为。

缺点：违背依赖倒转原则，访问者是依赖具体而不是依赖抽象。
使用场景：对象结构相对稳定，但是操作算法经常变化。

下面通过给宠物喂食的案例学习一下访问者模式。其中各个类对应的角色如下：

抽象访问者角色：给宠物喂食的人

具体访问者角色：主人、其它人

抽象元素角色：动物角色

具体元素角色：宠物狗、宠物猫

结构对象角色：主人家

1.首先定义一个抽象元素角色，定义由访问者访问的方法。

/**
 * @author nuist__NJUPT
 * @InterfaceName Animal
 * @description: 抽象元素角色类
 * @date 2024年02月04日
 */
public interface Animal {

    // 接受访问者访问
    void accept(Person person) ;

}

2.定义两个具体元素角色，实现抽象元素角色接口，并重写相应的接口方法。


/**
 * @author nuist__NJUPT
 * @ClassName Dog
 * @description: 具体元素角色
 * @date 2024年02月04日
 */
public class Dog implements Animal{

    public void accept(Person person) {
        person.feedDog(this);
        System.out.println("好吃，汪汪汪...");
    }
}


/**
 * @author nuist__NJUPT
 * @ClassName Cat
 * @description: 具体元素角色类
 * @date 2024年02月04日
 */
public class Cat implements Animal{

    public void accept(Person person) {
        person.feedCat(this);
        System.out.println("好吃，喵喵喵...");
    }
}

3.定义抽象访问者类，类中定义访问方法。


/**
 * @author nuist__NJUPT
 * @InterfaceName Person
 * @description: 抽象访问者角色
 * @date 2024年02月04日
 */
public interface Person {

    // 给猫喂食
    void feedCat(Cat cat) ;
    // 给狗喂食
    void feedDog(Dog dog) ;

}

4.定义具体访问者类，并实现抽象访问者接口，重写接口方法。


/**
 * @author nuist__NJUPT
 * @ClassName Owner
 * @description: 具体访问者
 * @date 2024年02月04日
 */
public class Owner implements Person {

    public void feedCat(Cat cat) {
        System.out.println("主人喂宠物猫");
    }

    public void feedDog(Dog dog) {
        System.out.println("主人喂宠物狗");
    }
}

/**
 * @author nuist__NJUPT
 * @ClassName Someone
 * @description: 具体访问者
 * @date 2024年02月04日
 */
public class Someone implements Person {

    public void feedCat(Cat cat) {
        System.out.println("其它人喂宠物猫");
    }

    public void feedDog(Dog dog) {
        System.out.println("其它人喂宠物狗");
    }

}

5.定义对象结构类，用于添加元素，并为访问者类提供访问对象的方法。

import java.util.ArrayList;
import java.util.List;

/**
 * @author nuist__NJUPT
 * @ClassName Home
 * @description: 对象结构类
 * @date 2024年02月04日
 */
public class Home {

    // 定义一个集合对象，用来存储元素对象
    List<Animal> animals = new ArrayList<Animal>() ;

    // 添加元素
    public void addAnimal(Animal animal){
        animals.add(animal) ;
    }
    // 提供访问者访问元素对象的方法
    public void action(Person person){
        for(Animal animal : animals){
            animal.accept(person);
        }
    }

}

6.定义客户端测试类，验证访问者模式。


/**
 * @author nuist__NJUPT
 * @ClassName Client
 * @description: 客户端测试类
 * @date 2024年02月04日
 */
public class Client {
    public static void main(String[] args) {
        // 创建结构对象
        Home home = new Home() ;
        // 添加元素对象
        home.addAnimal(new Dog());
        home.addAnimal(new Cat());
        // 创建访问者对象
        Owner owner = new Owner() ;
        // 结构对象提供访问者对象访问相应的元素
        home.action(owner);
    }
}
4.备忘录模式

定义：备忘录模式又称为快照模式，在不破坏封装性的前提下，捕获一个对象的内部状态，并在外部保存这个对象的内部状态，当需要使用到的时候可以快速恢复到保存的状态。

备忘录模式的主要角色如下：
01.发起人角色：记录当前时刻的内部状态信息，提供创建备忘录记录和恢复备忘录记录的功能。

02.备忘录角色：存储发起人的内部状态信息，在需要的时候将这个状态传递给发起人。

03.管理者角色：对备忘录进行管理，提供保存与获取备忘录的功能，不能更改备忘录内部细节。

备忘录模式的优缺点及使用场景：
优点：提供了状态恢复机制，实现了内部状态的封装，也符合单一职责原则。

缺点：资源多的情况下，资源消耗大。

使用场景：需要保存与恢复数据，提供一个可以回滚的场景。

备忘录模式有黑箱备忘录和白箱备忘录模式，白箱备忘录模式是破坏封装性的，即备忘录管理者能构修改备忘录内部的细节。

下面通过一个游戏案例学习备忘录模式，一个游戏角色有生命力、攻击力、防御力等数据，在打boss前和打boss后一定会不一样，玩家在跟boss决斗不理想的情况下允许恢复到之前的状态。

1.首先先一下白箱备忘录模式，定义一个游戏角色，即发起人对象。


/**
 * @author nuist__NJUPT
 * @ClassName GameRole
 * @description: 游戏角色类-发起人对象
 * @date 2024年02月04日
 */
public class GameRole {

    // 攻击力
    private int vit ;
    // 防御力
    private int def ;
    // 生命力
    private int atk ;

    // 初始化内部状态
    public void initState(){
        this.vit = 100 ;
        this.def = 100 ;
        this.atk = 100 ;
    }
    // 战斗
    public void fight(){
        this.vit = 0 ;
        this.atk = 0 ;
        this.def = 0 ;
    }
    // 保存角色状态功能
    public RoleStateMemento saveState(){
        return new RoleStateMemento(vit, def, atk) ;
    }
    // 恢复角色状态
    public void recoveryState(RoleStateMemento roleStateMemento){
        // 将备忘录中存储的对象状态赋值到当前对象
        this.vit = roleStateMemento.getVit() ;
        this.def = roleStateMemento.getDef() ;
        this.atk = roleStateMemento.getAtk() ;
    }
    // 展示状态功能
    public void stateDisplay(){
        System.out.println("角色生命力:" + vit);
        System.out.println("角色攻击力" + atk);
        System.out.println("角色防御力" + def);
    }

    public int getVit() {
        return vit;
    }

    public void setVit(int vit) {
        this.vit = vit;
    }

    public int getDef() {
        return def;
    }

    public void setDef(int def) {
        this.def = def;
    }

    public int getAtk() {
        return atk;
    }

    public void setAtk(int atk) {
        this.atk = atk;
    }
}

2.定义备忘录角色，用于保存发起人角色的状态。

/**
 * @author nuist__NJUPT
 * @ClassName RoleStateMemento
 * @description: 备忘录角色类
 * @date 2024年02月04日
 */
public class RoleStateMemento {

    // 攻击力
    private int vit ;
    // 防御力
    private int def ;
    // 生命力
    private int atk ;

    public RoleStateMemento(int vit, int def, int atk) {
        this.vit = vit;
        this.def = def;
        this.atk = atk;
    }

    public RoleStateMemento() {
    }

    public int getVit() {
        return vit;
    }

    public void setVit(int vit) {
        this.vit = vit;
    }

    public int getDef() {
        return def;
    }

    public void setDef(int def) {
        this.def = def;
    }

    public int getAtk() {
        return atk;
    }

    public void setAtk(int atk) {
        this.atk = atk;
    }
}

3.定义管理者角色，用于管理备忘录，备忘录提供宽接口，即提供具体备忘录实现类给管理者管理

/**
 * @author nuist__NJUPT
 * @ClassName RoleStateCaretaker
 * @description: 管理者类
 * @date 2024年02月04日
 */
public class RoleStateCaretaker {

    // 声明备忘录类对象
    private RoleStateMemento roleStateMemento ;

    public RoleStateMemento getRoleStateMemento() {
        return roleStateMemento;
    }

    public void setRoleStateMemento(RoleStateMemento roleStateMemento) {
        this.roleStateMemento = roleStateMemento;
    }

}

4.最后，定义测试类，测试白箱备忘录模式。

/**
 * @author nuist__NJUPT
 * @ClassName Client
 * @description: 客户端测试类-白箱备忘录模式
 * @date 2024年02月04日
 */
public class Client {
    public static void main(String[] args) {

        System.out.println("-----------------大战Boss前-------------------") ;
        // 创建发起人角色
        GameRole gameRole = new GameRole() ;
        gameRole.initState();
        gameRole.stateDisplay();
        // 创建备忘录管理者管理备忘录
        RoleStateCaretaker roleStateCaretaker = new RoleStateCaretaker() ;
        roleStateCaretaker.setRoleStateMemento(gameRole.saveState());

        System.out.println("-----------------大战Boss后-------------------") ;
        // 战斗
        gameRole.fight();
        gameRole.stateDisplay();

        System.out.println("-----------------恢复到之前的状态-------------------") ;
        gameRole.recoveryState(roleStateCaretaker.getRoleStateMemento());
        gameRole.stateDisplay();

    }
}

还是这个案例，下面我们看一下黑箱备忘录模式，该模式是将备忘录实现类放到发起人角色类的内部，通过提供一个抽象接口给管理者管理。

1.定义发起人类对象，在发起人对象内部定义备忘录类对象。





/**
 * @author nuist__NJUPT
 * @ClassName GameRole
 * @description: 将备忘录角色类定义在发起者角色类的内部
 * @date 2024年02月04日
 */
public class GameRole {

    // 攻击力
    private int vit ;
    // 防御力
    private int def ;
    // 生命力
    private int atk ;

    // 初始化内部状态
    public void initState(){
        this.vit = 100 ;
        this.def = 100 ;
        this.atk = 100 ;
    }
    // 战斗
    public void fight(){
        this.vit = 0 ;
        this.atk = 0 ;
        this.def = 0 ;
    }
    // 保存角色状态功能
    public Memento saveState(){
        return new RoleStateMemento(vit, def, atk) ;
    }
    // 恢复角色状态
    public void recoveryState(Memento memento){
        RoleStateMemento roleStateMemento = (RoleStateMemento) memento;
        // 将备忘录中存储的对象状态赋值到当前对象
        this.vit = roleStateMemento.getVit() ;
        this.def = roleStateMemento.getDef() ;
        this.atk = roleStateMemento.getAtk() ;
    }
    // 展示状态功能
    public void stateDisplay(){
        System.out.println("角色生命力:" + vit);
        System.out.println("角色攻击力" + atk);
        System.out.println("角色防御力" + def);
    }

    public int getVit() {
        return vit;
    }

    public void setVit(int vit) {
        this.vit = vit;
    }

    public int getDef() {
        return def;
    }

    public void setDef(int def) {
        this.def = def;
    }

    public int getAtk() {
        return atk;
    }

    public void setAtk(int atk) {
        this.atk = atk;
    }

    public class RoleStateMemento implements  Memento{
        // 攻击力
        private int vit ;
        // 防御力
        private int def ;
        // 生命力
        private int atk ;

        public RoleStateMemento(int vit, int def, int atk) {
            this.vit = vit;
            this.def = def;
            this.atk = atk;
        }

        public RoleStateMemento() {
        }

        public int getVit() {
            return vit;
        }

        public void setVit(int vit) {
            this.vit = vit;
        }

        public int getDef() {
            return def;
        }

        public void setDef(int def) {
            this.def = def;
        }

        public int getAtk() {
            return atk;
        }

        public void setAtk(int atk) {
            this.atk = atk;
        }
    }
}

2.对外提供一个备忘录抽象接口由管理者管理。

/**
 * @author nuist__NJUPT
 * @InterfaceName Memento
 * @description: 备忘录接口-对外提供窄接口
 * @date 2024年02月04日
 */
public interface Memento {

}

3.声明管理者类管理备忘录对象。


/**
 * @author nuist__NJUPT
 * @ClassName RoleStateCaretaker
 * @description: 管理者类-只管理备忘录的接口抽象，不管理具体内部实现类细节
 * @date 2024年02月04日
 */
public class RoleStateCaretaker {

    // 声明备忘录类对象
    private Memento memento ;

    public Memento getMemento() {
        return memento;
    }

    public void setMemento(Memento memento) {
        this.memento = memento;
    }
}

4.定义客户端测试类，测试黑盒备忘录模式。

/**
 * @author nuist__NJUPT
 * @ClassName Client
 * @description: 客户端测试类-黑箱备忘录模式
 * @date 2024年02月04日
 */

public class Client {
    public static void main(String[] args) {

        System.out.println("-----------------大战Boss前-------------------") ;
        // 创建发起人角色
        GameRole gameRole = new GameRole() ;
        gameRole.initState();
        gameRole.stateDisplay();
        // 创建备忘录管理者管理备忘录
        RoleStateCaretaker roleStateCaretaker = new RoleStateCaretaker() ;
        roleStateCaretaker.setMemento(gameRole.saveState());

        System.out.println("-----------------大战Boss后-------------------") ;
        // 战斗
        gameRole.fight();
        gameRole.stateDisplay();

        System.out.println("-----------------恢复到之前的状态-------------------") ;
        gameRole.recoveryState(roleStateCaretaker.getMemento());
        gameRole.stateDisplay();

    }
}
5.解释器模式

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

解释器模式包含以下角色：

01.抽象表达式角色：定义解释器接口，约定解释器的解释操作。

02.终结符表达式角色：抽象表达式的子类，用来实现文法中与终结符相关的操作。

03.非终结符表达式角色：抽象表达式的子类，用来实现文法中与非终结符相关的操作。

04.环境角色：通常包含各个解释器需要的数据或是公共的功能。

05.客户端：将需要分析的句子或者表达式转换成使用解释器对象描述的抽象语法树。

解释器模式的优缺点及使用场景：

优点：易于改变与扩展文。

缺点：对于复杂的文法难以维护。
使用场景：当语言的文法较为简单，且执行效率不是关键问题的时候。

通过实现用于加减法的案例来学习解释器模式，具体如下：

1.首先定义抽象表达式类，定义解释器接口。


/**
 * @author nuist__NJUPT
 * @ClassName AbstractExpression
 * @description: 抽象表达式角色
 * @date 2024年02月04日
 */
public abstract class AbstractExpression {

    public abstract int intercept(Context context) ;

}

2.定义三个具体表达式角色，是抽象表达式的子类。

/**
 * @author nuist__NJUPT
 * @ClassName Plus
 * @description: 加法表达式角色
 * @date 2024年02月04日
 */
public class Plus extends AbstractExpression {

    // +号左边的表达式
    private AbstractExpression left ;
    // +号右边的表达式
    private AbstractExpression right ;

    public Plus(AbstractExpression left, AbstractExpression right) {
        this.left = left;
        this.right = right;
    }

    public int intercept(Context context) {
        // 将左边表达式的结果与右边表达式的结果进行相加
        return left.intercept(context) + right.intercept(context);
    }

    @Override
    public String toString() {
        return "Plus{" +
                "left=" + left +
                ", right=" + right +
                '}';
    }
}


/**
 * @author nuist__NJUPT
 * @ClassName Minus
 * @description: 减法表达式类
 * @date 2024年02月04日
 */
public class Minus extends AbstractExpression {

    // -号左边的表达式
    private AbstractExpression left ;
    // -号右边的表达式
    private AbstractExpression right ;

    public Minus(AbstractExpression left, AbstractExpression right) {
        this.left = left;
        this.right = right;
    }

    public int intercept(Context context) {
        // 将左边表达式的结果与右边表达式的结果进行相减
        return left.intercept(context) - right.intercept(context);
    }

    @Override
    public String toString() {
        return "Plus{" +
                "left=" + left +
                ", right=" + right +
                '}';
    }
}

/**
 * @author nuist__NJUPT
 * @ClassName Variable
 * @description: TODO
 * @date 2024年02月04日
 */
public class Variable extends AbstractExpression {

    // 声明存储变量名的成员变量
    private String name ;

    public Variable(String name){
        this.name = name ;
    }

    public int intercept(Context context) {
        // 直接返回变量的值
        return context.getValue(this);
    }

    @Override
    public String toString() {
        return "Variable{" +
                "name='" + name + '\'' +
                '}';
    }
}

3.定义环境角色，用于对变量进行操作。


import java.util.HashMap;
import java.util.Map;

/**
 * @author nuist__NJUPT
 * @ClassName Context
 * @description: 环境角色类
 * @date 2024年02月04日
 */
public class Context {

    // 定义一个Map集合用来存储变量及其对应的值
    private Map<Variable,Integer> map = new HashMap<Variable, Integer>() ;

    // 添加变量的功能
    public void assign(Variable variable, Integer value){
        map.put(variable, value) ;
    }
    // 根据变量获取相应的值
    public int getValue(Variable variable){
        return map.get(variable) ;
    }

}

4.最后定义测试类，测试解释器模式。

/**
 * @author nuist__NJUPT
 * @ClassName Client
 * @description: 客户端测试类
 * @date 2024年02月04日
 */
public class Client {
    public static void main(String[] args) {
       // 创建环境对象
        Context context = new Context() ;
       // 创建多个变量
        Variable a = new Variable("a") ;
        Variable b = new Variable("b") ;
        Variable c = new Variable("c") ;
        Variable d = new Variable("d") ;
        // 将变量存储到环境中
        context.assign(a,1);
        context.assign(b,2);
        context.assign(c,3);
        context.assign(d,4);
        // 获取抽象语法树
        AbstractExpression abstractExpression = new Minus(a, new Plus(new Minus(b, c), d));
        // 解释
        int intercept = abstractExpression.intercept(context);
        System.out.println(intercept);
    }
}
nuist__NJUPT
关注
  • 15
    点赞
  • 踩
  • 18
    收藏
    觉得还不错? 一键收藏
  • 打赏
    打赏
  • 0
    评论
专栏目录
Java学习资料-行为型设计模式
06-16
Java学习资料—行为型设计模式；Java学习资料—行为型设计模式；Java学习资料—行为型设计模式；Java学习资料—行为型设计模式；
设计模式 - 行为型设计模式 - 策略模式（Java）
了解➔熟悉➔掌握➔精通
02-27 5万+
分享一个大牛的人工智能教程。零基础！通俗易懂！风趣幽默！希望你也加入到人工智能的队伍中来！请点击http://www.captainbed.net Definition Define a family of algorithms, encapsulate each one, and make them interchangeable. Strategy lets the algorithm ...
设计模式 - 行为型设计模式 - 状态模式（Java）
了解➔熟悉➔掌握➔精通
02-12 6万+
分享一个大牛的人工智能教程。零基础！通俗易懂！风趣幽默！希望你也加入到人工智能的队伍中来！请点击http://www.captainbed.net Definition Allow an object to alter its behavior when its internal state changes. The object will appear to change its clas...
设计模式 - 行为型设计模式 - 模板方法模式（Java）
了解➔熟悉➔掌握➔精通
02-26 5万+
分享一个大牛的人工智能教程。零基础！通俗易懂！风趣幽默！希望你也加入到人工智能的队伍中来！请点击http://www.captainbed.net Definition Define the skeleton of an algorithm in an operation, deferring some stepsto subclasses. Template Method lets su...
Java设计模式之行为型：中介者模式
张维鹏的博客
09-14 1万+
中介者模式通过中介者对象来封装一系列的对象交互，将对象间复杂的关系网状结构变成结构简单的以中介者为核心的星形结构，对象间一对多的关联转变为一对一的关联，简化对象间的关系，便于理解；各个对象之间的关系被解耦，每个对象不再和它关联的对象直接发生相互作用，而是通过中介者对象来与关联的对象进行通讯，使得对象可以相对独立地使用，提高了对象的可复用和系统的可扩展性。在中介者模式中，中介者类处于核心地位，它封装了系统中所有对象类之间的关系，除了简化对象间的关系，还可以对对象间的交互进行进一步的控制。
Java中23种设计模式
呜呜老司机的博客家园
10-10 7万+
Java中23种设计模式，包括简单介绍，适用场景以及优缺点等
Java常见设计模式总结
热门推荐
张维鹏的博客
09-18 18万+
设计模式是一套经过反复使用的代码设计经验，目的是为了重用代码、让代码更容易被他人理解、保证代码可靠性。设计模式于己于人于系统都是多赢的，它使得代码编写真正工程化，它是软件工程的基石，如同大厦的一块块砖石一样。项目中合理的运用设计模式可以完美的解决很多问题，每种模式在现实中都有相应的原理来与之对应，每种模式描述了一个在我们周围不断重复发生的问题，以及该问题的核心解决方案，这也是它能被广泛应用的原因。总体来说，设计模式分为三大类：5种创建型模式、7种结构型模式、11种行为型模式
Java设计模式之行为型：迭代器模式
张维鹏的博客
11-03 1万+
迭代器模式提供一种访问集合中的各个元素，而不暴露其内部表示的方法。将在元素之间游走的职责交给迭代器，而不是集合对象，从而简化集合容器的实现，让集合容器专注于在它所应该专注的事情上，更加符合单一职责原则。
设计模式 - 行为型设计模式 - 观察者模式（Java）
了解➔熟悉➔掌握➔精通
02-12 6万+
分享一个大牛的人工智能教程。零基础！通俗易懂！风趣幽默！希望你也加入到人工智能的队伍中来！请点击http://www.captainbed.net Definition Define a one-to-many dependency between objects so that when one object changes state, all its dependents are no...
Java设计模式之行为型：命令模式
张维鹏的博客
11-04 1万+
命令模式的本质是将请求封装成对象，将发出命令与执行命令的责任分开，命令的发送者和接收者完全解耦，发送者只需知道如何发送命令，不需要关心命令是如何实现的，甚至是否执行成功都不需要理会。命令模式的关键在于引入了抽象命令接口，发送者针对抽象命令接口编程，只有实现了抽象命令接口的具体命令才能与接收者相关联。另外命令可以像强对象一样可以被存储和传递，所以可支持撤销的操作
设计模式 - 行为型设计模式 - 责任链模式（Java）
了解➔熟悉➔掌握➔精通
03-23 3万+
分享一个大牛的人工智能教程。零基础！通俗易懂！风趣幽默！希望你也加入到人工智能的队伍中来！请点击http://www.captainbed.net Definition Avoid coupling the sender of a request to its receiver by giving more than one object a chance to handle the req...
JAVA-设计模式-行为型模式-命令模式
08-10
JAVA-设计模式-行为型模式-命令模式
JAVA-设计模式-行为型模式-状态模式
08-10
JAVA-设计模式-行为型模式-状态模式
JAVA-设计模式-行为型模式-策略模式
08-10
JAVA-设计模式-行为型模式-策略模式
JAVA-设计模式-行为型模式-迭代器模式
08-10
JAVA-设计模式-行为型模式-迭代器模式
【设计模式深度剖析】【1】【结构型】【代理模式】| 玩游戏打怪、升级为例加深理解
最新发布
浣花御劍
05-20 1076
玩游戏打怪、升级为例深入理解代理模式
Java设计模式-备忘录模式（23）
艾利克斯冰的博客
05-17 69
备忘录模式
Java设计模式-责任链模式（17）
艾利克斯冰的博客
05-16 64
责任链模式提供了一种优雅的方式来组织和管理请求的处理流程，它不仅降低了请求发送者与接收者之间的耦合度，还为系统的扩展和维护创造了良好基础。通过灵活的设计，可以适应多种复杂的业务场景，是解决请求处理问题的有效手段之一。然而，其使用也需注意平衡系统复杂度与性能需求，确保模式的应用既满足功能需求，又保持了系统的高效与简洁。
【设计模式】JAVA Design Patterns——Bridge（桥接模式）
CSBIGDOG的博客
05-20 582
考虑一下你拥有一种具有不同附魔的武器，并且应该允许将具有不同附魔的不同武器混合使用。为每个附魔创建每种武器的多个副本，还是只是创建单独的附魔并根据需要为武器设置它？桥接模式使您可以进行第二次操作。桥接模式是一个更推荐组合而不是继承的模式。将实现细节从一个层次结构推送到具有单独层次结构的另一个对象。桥接模式是软件工程中使用的一种设计模式，旨在“将抽象与其实现分离，从而使两者可以独立变化”将抽象与其实现分离，以便二者可以独立变化。
图解Java设计模式-23种设计模式
08-28
Java设计模式是一组经过实践验证的面向对象设计原则和模式，可以帮助开发人员解决常见的软件设计问题。下面是常见的23种设计模式： 1. 创建型模式（Creational Patterns）： - 工厂方法模式（Factory Method Pattern） - 抽象工厂模式（Abstract Factory Pattern） - 单例模式（Singleton Pattern） - 原型模式（Prototype Pattern） - 建造者模式（Builder Pattern） 2. 结构型模式（Structural Patterns）： - 适配器模式（Adapter Pattern） - 桥接模式（Bridge Pattern） - 组合模式（Composite Pattern） - 装饰器模式（Decorator Pattern） - 外观模式（Facade Pattern） - 享元模式（Flyweight Pattern） - 代理模式（Proxy Pattern） 3. 行为型模式（Behavioral Patterns）： - 责任链模式（Chain of Responsibility Pattern） - 命令模式（Command Pattern） - 解释器模式（Interpreter Pattern） - 迭代器模式（Iterator Pattern） - 中介者模式（Mediator Pattern） - 备忘录模式（Memento Pattern） - 观察者模式（Observer Pattern） - 状态模式（State Pattern） - 策略模式（Strategy Pattern） - 模板方法模式（Template Method Pattern） - 访问者模式（Visitor Pattern） 4. 并发型模式（Concurrency Patterns）： - 保护性暂停模式（Guarded Suspension Pattern） - 生产者-消费者模式（Producer-Consumer Pattern） - 读写锁模式（Read-Write Lock Pattern） - 信号量模式（Semaphore Pattern） - 线程池模式（Thread Pool Pattern） 这些设计模式可以根据问题的特点和需求来选择使用，它们提供了一些可复用的解决方案，有助于开发高质量、可维护且易于扩展的软件系统。

“相关推荐”对你有帮助么？

  • 非常没帮助
  • 没帮助
  • 一般
  • 有帮助
  • 非常有帮助
提交
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包

打赏作者

nuist__NJUPT

给个鼓励吧，谢谢你

¥1 ¥2 ¥4 ¥6 ¥10 ¥20
扫码支付：¥1
获取中
扫码支付

您的余额不足，请更换扫码支付或充值

打赏作者

实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

1.余额是钱包充值的虚拟货币，按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载，可以购买VIP、付费专栏及课程。

余额充值