一,中介者模式（Mediator Pattern）
中介者模式（Mediator Pattern）是用来降低多个对象和类之间的通信复杂性。这种模式提供了一个中介类，该类通常处理不同类之间的通信，并支持松耦合，使代码易于维护。
案例, 用户发消息, 并打印出来:
中间类,打印发送的消息(如果有其他对消息的处理, 都由此类完成):
public class MessageCenter {
public static void printMsg(User user, String msg) {
System.out.println(new Date().toString() + " " + user.getUsername() + ":" + msg);
}
}
用户类
public class User {
private String username;
public User(String username) {
this.username = username;
}
public String getUsername() {
return username;
}
public void sendMsg(String msg) {
MessageCenter.printMsg(this, msg);
}
}
Demo
public static void main(String[] args) {
User user1 = new User("李雷");
User user2 = new User("寒梅");
user1.sendMsg("天气真好");
user2.sendMsg("是呀, 您吃了吗!");
}
二,备忘录模式（Memento Pattern）
备忘录模式（Memento Pattern）保存一个对象的某个状态，以便在适当的时候恢复对象。
在不破坏封装的前提下，捕获一个对象的内部状态，并在该对象之外保存这个状态，这样可以在以后将对象恢复到原先保存的状态。
案例, 保存文件名
记忆类, 记录需要保存的信息, 此处只保存文件名
public class Memento {
private String name;
public Memento(String name) {
this.name = name;
}
public String getName() {
return name;
}
public void setName(String name) {
this.name = name;
}
}
记忆管理类, 保存多个记忆单元, 提供最后一个记忆单元
public class MementoManager {
private List<Memento> mementoList = new ArrayList<>();
public void add(Memento memento) {
mementoList.add(memento);
}
public Memento getLast(){
return mementoList.remove(mementoList.size() - 1);
}
}
文件名类, 封装一个管理类, 提供记录恢复
public class FileName {
private String name;
private MementoManager manager;
public FileName(MementoManager manager) {
this.manager = manager;
}
public String getName() {
return name;
}
public void setName(String name) {
manager.add(new Memento(this.name));
this.name = name;
}
public void returnLast(){
this.name = manager.getLast().getName();
}
}
Demo
public static void main(String[] args) {
FileName fileName = new FileName(new MementoManager());
fileName.setName("张三");
System.out.println(fileName.getName());
fileName.setName("李四");
System.out.println(fileName.getName());
fileName.setName("王五");
System.out.println(fileName.getName());
fileName.returnLast(); // 撤销一下
System.out.println(fileName.getName());
fileName.returnLast(); // 撤销一下
System.out.println(fileName.getName());
}
张三
李四
王五
李四
张三
三,观察者模式（Observer Pattern）
当对象间存在一对多关系时，则使用观察者模式（Observer Pattern）。比如，当一个对象被修改时，则会自动通知依赖它的对象。
案例,修改用户名字后通知观察者:
观察者接口
public interface Observer {
void updateChange(String newName);
String getName();
}
2个实现观察者
public class ObserverA implements Observer {
@Override
public void updateChange(String newName) {
System.out.println(getName() + "接收到新的名字:" + newName);
}
@Override
public String getName() {
return "观察者A";
}
}
public class ObserverB implements Observer {
@Override
public void updateChange(String newName) {
System.out.println(getName() + "接收到新的名字:" + newName);
}
@Override
public String getName() {
return "观察者B";
}
}
用户类
维护一个观察者列表(也可以专门用一个中间类维护列表), 当用户名称发生改变时, 调用观察者
public class User {
private String username;
private List<Observer> observers = new ArrayList<>();
public String getUsername() {
return username;
}
public void setUsername(String username) {
this.username = username;
notice();
}
public void addObserver(Observer observer) {
observers.add(observer);
}
private void notice(){
for (Observer observer : observers) {
observer.updateChange(username);
}
}
}
Demo
public static void main(String[] args) {
User user = new User();
user.addObserver(new ObserverA());
user.addObserver(new ObserverB());
user.setUsername("张三");
user.setUsername("李四");
}
观察者A接收到新的名字:张三
观察者B接收到新的名字:张三
观察者A接收到新的名字:李四
观察者B接收到新的名字:李四
四,状态模式（State Pattern）
在状态模式（State Pattern）中，类的行为是基于它的状态改变的.
在状态模式中，我们创建表示各种状态的对象和一个行为随着状态对象改变而改变的 context 对象。
context 对象的行为依赖于它的状态（属性），并且可以根据它的状态改变而改变它的相关行为。
例如: 假设一个订单分四种状态: 下单, 付款, 发货, 收货. 订单的推动是根据状态的不同, 而进行不同的操作.
定义状态抽象类
public abstract class State {
/**
* 状态名称
*/
abstract String getName();
/**
* 改状态下执行的逻辑
*/
abstract void doAction(Order order);
}
4中状态
public class BeginState extends State {
@Override
String getName() {
return "下单状态";
}
@Override
void doAction(Order order) {
System.out.println("下单成功");
System.out.println("当前订单状态为:" + getName());
order.setState(new PayState());
order.advance();
}
}
public class PayState extends State {
@Override
String getName() {
return "付款状态";
}
@Override
void doAction(Order order) {
System.out.println("用户付款成功");
System.out.println("当前订单状态为:" + getName());
order.setState(new TransportState());
order.advance();
}
}
public class TransportState extends State {
@Override
String getName() {
return "运输状态";
}
@Override
void doAction(Order order) {
System.out.println("快递员上门取件了!");
System.out.println("当前订单状态为:" + getName());
order.setState(new FinishState());
order.advance();
}
}
public class FinishState extends State {
@Override
String getName() {
return "订单完成";
}
@Override
void doAction(Order order) {
System.out.println("快递已签收");
System.out.println("当前订单状态为:" + getName());
order.setFinished(true);
order.advance();
}
}
订单类, 具有一个状态的变量, 根据状态的不同, 会有不同的推进方式
public class Order {
private String name;
private State state;
private boolean finished = false;
/**
* 推进订单
*/
public void advance(){
if (finished) {
System.out.println("订单结束!");
} else if (null != state) {
state.doAction(this);
} else {
System.out.println("请先下单");
}
}
... Setter/Getter 方法略 ...
}
Demo
public static void main(String[] args) {
// 创建订单
Order order = new Order();
// 下单
BeginState beginState = new BeginState();
order.setState(beginState);
// 订单开始推进
order.advance();
}
下单成功
当前订单状态为:下单状态
用户付款成功
当前订单状态为:付款状态
快递员上门取件了!
当前订单状态为:运输状态
快递已签收
当前订单状态为:订单完成
订单结束!
