行为型设计模式---解释器模式和观察者模式
一、解释器模式
解释器模式提供了评估语言的语法或表达式的方式。给定一个语言，定义它的文法表示，并定义一个解释器，这个解释器使用该标识来解释语言中的句子。
手动模拟后缀表达式(也叫逆波兰表达式)的例子。
解释器接口：
public interface Interpreter {
int interpret();
}
加法解释器：
public class AddInterpreter implements Interpreter {
private Interpreter firstExpression, secondExpression;
public AddInterpreter(Interpreter firstExpression, Interpreter secondExpression) {
this.firstExpression = firstExpression;
this.secondExpression = secondExpression;
}
@Override
public int interpret() {
return this.firstExpression.interpret() + this.secondExpression.interpret();
}
@Override
public String toString() {
return "+";
}
}
乘法解释器：
public class MultiInterpreter implements Interpreter {
private Interpreter firstExpression, secondExpression;
public MultiInterpreter(Interpreter firstExpression, Interpreter secondExpression) {
this.firstExpression = firstExpression;
this.secondExpression = secondExpression;
}
@Override
public int interpret() {
return this.firstExpression.interpret() * this.secondExpression.interpret();
}
@Override
public String toString() {
return "*";
}
}
数字解释器：
public class NumberInterpreter implements Interpreter {
private int number;
public NumberInterpreter(int number) {
this.number = number;
}
public NumberInterpreter(String number) {
this.number = Integer.valueOf(number);
}
@Override
public int interpret() {
return this.number;
}
}
操作工具类：
public class OperatorUtil {
public static boolean isOperator(String symbol) {
return (symbol.equals("+") || symbol.equals("*"));
}
public static Interpreter getExpressionObject(Interpreter firstExpression, Interpreter secondExpression, String symbol) {
if (symbol.equals("+")) {
return new AddInterpreter(firstExpression, secondExpression);
} else if (symbol.equals("*")) {
return new MultiInterpreter(firstExpression, secondExpression);
} else {
return null;
}
}
}
解析后缀表达式的类：
public class CJExpressionParser {
private Stack<Interpreter> stack = new Stack<>();
public int parse(String str) {
String[] strItemArray = str.split(" ");
for (String symbol : strItemArray) {
if (!OperatorUtil.isOperator(symbol)) {
Interpreter numberExpression = new NumberInterpreter(symbol);
stack.push(numberExpression);
System.out.println(String.format("入栈: %d", numberExpression.interpret()));
} else {
//是符号可以计算
Interpreter firstExpression = stack.pop();
Interpreter secondExpression = stack.pop();
Interpreter operator = OperatorUtil.getExpressionObject(firstExpression, secondExpression, symbol);
System.out.println(String.format("出栈: %d 和 %d", firstExpression.interpret(), secondExpression.interpret()));
int result = operator.interpret();
NumberInterpreter resultExpression = new NumberInterpreter(result);
stack.push(resultExpression);
System.out.println(String.format("阶段结果入栈: %d", resultExpression.interpret()));
}
}
int result = stack.pop().interpret();
return result;
}
}
测试类：
public class InterpreterTest {
public static void main(String[] args) {
String cjInputStr = "6 5 11 + *";
CJExpressionParser expressionParser = new CJExpressionParser();
int result = expressionParser.parse(cjInputStr);
System.out.println("解释器计算结果: " + result);
}
}
测试结果：
此时的UML图如下：
二、观察者模式
1、基于JDK的观察者模式
用户类(被观察者)：
public class User extends Observable {
private String name;
public User(String name) {
this.name = name;
}
public String getName() {
return name;
}
public void setName(String name) {
this.name = name;
}
public void send(Message m) {
System.out.println(this.name + " 发送了一条消息");
setChanged();
//将要传递的消息作为参数传入
notifyObservers(m);
}
}
群组类(观察者)：
public class Group implements Observer {
@Override
public void update(Observable o, Object arg) {
User user = (User) o;
Message msg = (Message) arg;
System.out.println("群成员: " + user.getName() + "发送了一条消息, 消息内容为: " + msg.getContent());
}
}
消息类：
public class Message {
private String content;
public String getContent() {
return content;
}
public void setContent(String content) {
this.content = content;
}
}
测试类：
public class ObserverTest {
public static void main(String[] args) {
Group group = new Group();
Message msg = new Message();
msg.setContent("大家好, 我是来自地球的处女座男生");
User user = new User("大明");
//需要将观察者列表注册到被观察者里面
user.addObserver(group);
user.send(msg);
}
}
测试结果：
2、基于Guava的观察者模式
消息类：
public class Message {
private String content;
public Message(String content) {
this.content = content;
}
public String getContent() {
return content;
}
public void setContent(String content) {
this.content = content;
}
}
观察者1类(直接在方法上加上注解即可)：
public class DataObserver1 {
@Subscribe
public void fun1(String msg) {
System.out.println(this.getClass().getSimpleName() + "类的fun1()方法执行了...");
System.out.println(msg);
}
@Subscribe
public void fun2(Message msg) {
System.out.println(this.getClass().getSimpleName() + "类的fun2()方法执行了...");
System.out.println(msg.getContent());
}
}
观察者2类：
public class DataObserver2 {
@Subscribe
public void fun(Integer msg) {
System.out.println(this.getClass().getSimpleName() + "类的fun()方法执行了...");
System.out.println("Integer msg: " + msg);
}
}
测试类：
public class GuavaTest {
public static void main(String[] args) {
DataObserver1 observer1 = new DataObserver1();
DataObserver2 observer2 = new DataObserver2();
EventBus eventBus = new EventBus();
//将观察者注册到消息总线中
eventBus.register(observer1);
eventBus.register(observer2);
System.out.println("============ before unregister ============");
// 只有注册的参数类型为String的方法会被调用
eventBus.post(new Message("广播一条消息"));
eventBus.post(123);
eventBus.post("Hello World!");
System.out.println("============ after unregister ============");
eventBus.unregister(observer1); // 注销observer1
eventBus.post(new Message("再次广播一条消息"));
eventBus.post(123);
eventBus.post("Hello World!");
}
}
测试结果：
