1.备忘录模式
备忘录模式的主要角色如下：
-
发起人（Originator）角色：记录当前时刻的内部状态信息，提供创建备忘录和恢复备忘录数据的功能，实现其他业务功能，它可以访问备忘录里的所有信息。
-
备忘录（Memento）角色：负责存储发起人的内部状态，在需要的时候提供这些内部状态给发起人。
-
管理者（Caretaker）角色：对备忘录进行管理，提供保存与获取备忘录的功能，但其不能对备忘录的内容进行访问与修改。
备忘录有两个等效的接口：
窄接口：管理者(Caretaker)对象（和其他发起人对象之外的任何对象）看到的是备忘录的窄接口(narror Interface)，这个窄接口只允许他把备忘录对象传给其他的对象。
宽接口：与管理者看到的窄接口相反，发起人对象可以看到一个宽接口(wide Interface)，这个宽接口允许它读取所有的数据，以便根据这些数据恢复这个发起人对象的内部状态。
白箱备忘录模式
备忘录角色对任何对象都提供一个接口，即宽接口，备忘录角色的内部所存储的状态就对所有对象公开。
发起人：
//游戏角色类：发起人角色
public class GameRole {
private int vit; //生命力
private int atk; //攻击力
private int def; //防御力
//初始化内部状态
public void initState() {
this.vit = 100;
this.atk = 100;
this.def = 100;
}
//战斗
public void fight() {
this.vit = 0;
this.atk = 0;
this.def = 0;
}
//保存角色状态功能
public RoleStateMemento saveState() {
return new RoleStateMemento(vit, atk, def);
}
//恢复角色状态
public void recoverState(RoleStateMemento roleStateMemento) {
//将备忘录对象中存储的状态赋值给当前对象的成员
this.vit = roleStateMemento.getVit();
this.atk = roleStateMemento.getAtk();
this.def = roleStateMemento.getDef();
}
//展示状态功能
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 getAtk() {
return atk;
}
public void setAtk(int atk) {
this.atk = atk;
}
public int getDef() {
return def;
}
public void setDef(int def) {
this.def = def;
}
}
备忘录：
//备忘录角色类
public class RoleStateMemento {
private int vit; //生命力
private int atk; //攻击力
private int def; //防御力
public RoleStateMemento(int vit, int atk, int def) {
this.vit = vit;
this.atk = atk;
this.def = def;
}
public RoleStateMemento() {
}
public int getVit() {
return vit;
}
public void setVit(int vit) {
this.vit = vit;
}
public int getAtk() {
return atk;
}
public void setAtk(int atk) {
this.atk = atk;
}
public int getDef() {
return def;
}
public void setDef(int def) {
this.def = def;
}
}
管理者：
//备忘录对象管理对象
public class RoleStateCaretaker {
//声明RoleStateMemento类型的变量
private RoleStateMemento roleStateMemento;
public RoleStateMemento getRoleStateMemento() {
return roleStateMemento;
}
public void setRoleStateMemento(RoleStateMemento roleStateMemento) {
this.roleStateMemento = roleStateMemento;
}
}
测试类：
public class Client {
public static void main(String[] args) {
System.out.println("---------------大战boos前-----------------");
//创建游戏角色对象
GameRole gameRole = new GameRole();
gameRole.initState();//初始化状态操作
gameRole.stateDisplay();
//将该游戏角色内部状态进行备份
RoleStateCaretaker roleStateCaretaker = new RoleStateCaretaker();//创建管理者对象
RoleStateMemento roleStateMemento = gameRole.saveState();//获取备忘录对象
roleStateCaretaker.setRoleStateMemento(roleStateMemento);//给管理者对象设置备忘录对象
System.out.println("---------------大战boos后-----------------");
//损耗严重
gameRole.fight();
gameRole.stateDisplay();
System.out.println("---------------恢复之前的状态-----------------");
gameRole.recoverState(roleStateCaretaker.getRoleStateMemento());
gameRole.stateDisplay();
//---------------大战boos前-----------------
//角色生命力：100
//角色攻击力：100
//角色防御力：100
//---------------大战boos后-----------------
//角色生命力：0
//角色攻击力：0
//角色防御力：0
//---------------恢复之前的状态-----------------
//角色生命力：100
//角色攻击力：100
//角色防御力：100
}
}黑箱备忘录模式
备忘录角色对发起人对象提供一个宽接口，而为其他对象提供一个窄接口。在Java语言中，实现双重接口的办法就是将备忘录类设计成发起人类的内部成员类。
发起人：
//游戏角色类：属于发起人角色
public class GameRole {
private int vit; //生命力
private int atk; //攻击力
private int def; //防御力
//初始化内部状态
public void initState() {
this.vit = 100;
this.atk = 100;
this.def = 100;
}
//战斗
public void fight() {
this.vit = 0;
this.atk = 0;
this.def = 0;
}
//保存角色状态功能
public Memento saveState() {
return new RoleStateMemento(vit,atk,def);
}
//恢复角色状态
public void recoverState(Memento memento) {
RoleStateMemento roleStateMemento = (RoleStateMemento) memento;
//将备忘录对象中存储的状态赋值给当前对象的成员
this.vit = roleStateMemento.getVit();
this.atk = roleStateMemento.getAtk();
this.def = roleStateMemento.getDef();
}
//展示状态功能
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 getAtk() {
return atk;
}
public void setAtk(int atk) {
this.atk = atk;
}
public int getDef() {
return def;
}
public void setDef(int def) {
this.def = def;
}
//内部类，备忘录具体实现类
private class RoleStateMemento implements Memento {
private int vit; //生命力
private int atk; //攻击力
private int def; //防御力
public RoleStateMemento(int vit, int atk, int def) {
this.vit = vit;
this.atk = atk;
this.def = def;
}
public RoleStateMemento() {
}
public int getVit() {
return vit;
}
public void setVit(int vit) {
this.vit = vit;
}
public int getAtk() {
return atk;
}
public void setAtk(int atk) {
this.atk = atk;
}
public int getDef() {
return def;
}
public void setDef(int def) {
this.def = def;
}
}
}
备忘录：
//备忘录接口，对外提供窄接口
//具体的实现类定义在GameRole的内部类
public interface Memento {
}管理者：
//备忘录对象管理对象
public class RoleStateCaretaker {
//声明Memento类型的变量
private Memento memento;
public Memento getMemento() {
return memento;
}
public void setMemento(Memento memento) {
this.memento = memento;
}
}
测试类：
public class Client {
public static void main(String[] args) {
System.out.println("---------------大战boos前-----------------");
//创建游戏角色对象
GameRole gameRole = new GameRole();
gameRole.initState();//初始化状态操作
gameRole.stateDisplay();
//将该游戏角色内部状态进行备份
RoleStateCaretaker roleStateCaretaker = new RoleStateCaretaker();//创建管理者对象
roleStateCaretaker.setMemento(gameRole.saveState());//给管理者对象设置备忘录对象
System.out.println("---------------大战boos后-----------------");
//损耗严重
gameRole.fight();
gameRole.stateDisplay();
System.out.println("---------------恢复之前的状态-----------------");
gameRole.recoverState(roleStateCaretaker.getMemento());
gameRole.stateDisplay();
}
}2.解释器模式
定义：
给定一个语言，定义它的文法表示，并定义一个解释器，这个解释器使用该标识来解释语言中的句子。
文法（语法）规则：
文法是用于描述语言的语法结构的形式规则。
expression ::= value | plus | minus plus ::= expression ‘+’ expression minus ::= expression ‘-’ expression value ::= integer
注意： 这里的符号 ::= 表示 “ 定义为 ” 的意思，竖线 | 表示或，左右的其中一个，引号内为字符本身，引号外为语法。
上面规则描述为 ：
表达式可以是一个值，也可以是plus或者minus运算，而plus和minus又是由表达式结合运算符构成，值的类型为整型数。
抽象语法树：
在计算机科学中，抽象语法树（AbstractSyntaxTree，AST），或简称语法树（Syntax tree），是源代码语法结构的一种抽象表示。它以树状的形式表现编程语言的语法结构，树上的每个节点都表示源代码中的一种结构。
用树形来表示符合文法规则的句子。
解释器模式包含以下主要角色
-
抽象表达式（Abstract Expression）角色：定义解释器的接口，约定解释器的解释操作，主要包含解释方法 interpret()。
-
终结符表达式（Terminal Expression）角色：是抽象表达式的子类，用来实现文法中与终结符相关的操作，文法中的每一个终结符都有一个具体终结表达式与之相对应。
-
非终结符表达式（Nonterminal Expression）角色：也是抽象表达式的子类，用来实现文法中与非终结符相关的操作，文法中的每条规则都对应于一个非终结符表达式。
-
环境（Context）角色：通常包含各个解释器需要的数据或是公共的功能，一般用来传递被所有解释器共享的数据，后面的解释器可以从这里获取这些值。
-
客户端（Client）：主要任务是将需要分析的句子或表达式转换成使用解释器对象描述的抽象语法树，然后调用解释器的解释方法，当然也可以通过环境角色间接访问解释器的解释方法。
抽象表达式：
//抽象表达式
public abstract class AbstractExpression {
//解释的方法
public abstract int interpret(Context context);
}
终结符表达式：
//封装变量的类
public class Variable extends AbstractExpression {
//声明存储变量名的成员变量
private String name;
public Variable(String name) {
this.name = name;
}
public int interpret(Context context) {
//直接返回变量的值
return context.getValue(this);
}
@Override
public String toString() {
return name;
}
}
非终结符表达式：
//加法表达式类
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 interpret(Context context) {
//将左边表达式的结果和右边表达式的结果进行相加
return left.interpret(context) + right.interpret(context);
}
@Override
public String toString() {
return "(" + left.toString() + " + " + right.toString() + ")";
}
}
//减法表达式类
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 interpret(Context context) {
//将左边表达式的结果和右边表达式的结果进行相减
return left.interpret(context) - right.interpret(context);
}
@Override
public String toString() {
return "(" + left.toString() + " - " + right.toString() + ")";
}
}
环境角色：
import java.util.HashMap;
import java.util.Map;
//环境角色类
public class Context {
//定义一个map集合，用来存储变量及对应的值
private Map<Variable,Integer> map = new HashMap<>();
//添加变量的功能
public void assign(Variable var, Integer value) {
map.put(var,value);
}
//根据变量获取对应的值
public int getValue(Variable var) {
return map.get(var);
}
}
测试类：
//测试类
public class Client {
public static void main(String[] args) {
//创建环境对象
Context context = new Context();
//创建多个变量对象
Variable a = new Variable("a");
Variable b = new Variable("b");
//将变量存储到环境对象中
context.assign(a, 1);
context.assign(b, 2);
//获取抽象语法树 a + b
AbstractExpression expression = new Plus(a, b);
/**
* Plus的构造方法
*
public Plus(AbstractExpression left, AbstractExpression right) {
this.left = left;
this.right = right;
}
*/
//解释（计算）
int result = expression.interpret(context);
/**
* 第一步：调用Plus的interpret(context)方法
public int interpret(Context context) {
return left.interpret(context) + right.interpret(context);
}
*/
/**
* 第二步：left.interpret(context)和right.interpret(context)，调用的是Variable的interpret(context)方法
public int interpret(Context context) {
return context.getValue(this);
}
*/
System.out.println(expression + " = " + result);//(a + b) = 3
}
}
优缺点
1，优点：
-
易于改变和扩展文法。
由于在解释器模式中使用类来表示语言的文法规则，因此可以通过继承等机制来改变或扩展文法。每一条文法规则都可以表示为一个类，因此可以方便地实现一个简单的语言。
-
实现文法较为容易。
在抽象语法树中每一个表达式节点类的实现方式都是相似的，这些类的代码编写都不会特别复杂。
-
增加新的解释表达式较为方便。
如果用户需要增加新的解释表达式只需要对应增加一个新的终结符表达式或非终结符表达式类，原有表达式类代码无须修改，符合 "开闭原则"。
2，缺点：
-
对于复杂文法难以维护。
在解释器模式中，每一条规则至少需要定义一个类，因此如果一个语言包含太多文法规则，类的个数将会急剧增加，导致系统难以管理和维护。
-
执行效率较低。
由于在解释器模式中使用了大量的循环和递归调用，因此在解释较为复杂的句子时其速度很慢，而且代码的调试过程也比较麻烦。
使用场景
-
当语言的文法较为简单，且执行效率不是关键问题时。
-
当问题重复出现，且可以用一种简单的语言来进行表达时。
-
当一个语言需要解释执行，并且语言中的句子可以表示为一个抽象语法树的时候。
766
被折叠的 条评论
为什么被折叠?
到【灌水乐园】发言
