本文详细介绍了Java设计模式中的备忘录模式、解释器模式、状态模式、策略模式和职责链模式。备忘录模式用于在不破坏封装的前提下保存对象状态；解释器模式实现特定语言的解释器；状态模式根据对象状态改变行为；策略模式定义算法族并使它们可互换；职责链模式则将请求沿处理者链传递，直到某个处理者处理。文中通过代码示例展示了各模式的实现和应用场景。
Java设计模式Ⅶ
1.备忘录模式
1.1 备忘录模式概述
(1)基本介绍
①备忘录（Memento）模式在不破坏封装性的前提下，捕获一个对象的
内部状态。并在该对象之外保存这个状态，这样以后就可将该对象恢
复到原先保存的状态
②理解备忘录模式： 现实中的备忘录是要用来去记录某些要去做的事情
，或者是记录已经达成共同意见的事情，以防忘记。而在软件层面，备
忘录模式有着相同的含义，备忘录对象主要用来记录一个对象的某种状
态，或者某些数据，当要回退时，可以从备忘录对象里获取原来的数据
进行恢复操作，
③备忘录模式属于行为型模式
(2)代码类图
Originator：对象（需要保存状态的对象）
Memento：备忘录对象，负责保存好记录，即originator内部状态
Caretaker：守护者对象，负责保存多个备忘录对象，使用集合管理，提高效率
1.2 代码理解
1.Memento
package com.pattern.设计模式.备忘录模式;
public class Memento {
private String state;
public Memento() {
}
public Memento(String state) {
this.state = state;
}
@Override
public String toString() {
return "Memento{" +
"state='" + state + '\'' +
'}';
}
public String getState() {
return state;
}
public void setState(String state) {
this.state = state;
}
}
2.Caretaker
package com.pattern.设计模式.备忘录模式;
import java.util.ArrayList;
import java.util.List;
public class Caretaker {
private List<Memento> mementoList = new ArrayList<Memento>();
public void add(Memento memento) {
mementoList.add(memento);
}
// 获取到第index个Originator的备忘录对象
public Memento get(int index) {
return mementoList.get(index);
}
}
3.Originator
package com.pattern.设计模式.备忘录模式;
public class Originator {
private String state;
// 编写一个方法，可以保存一个状态对象 Memento
public Memento saveStateMemento() {
return new Memento(state);
}
// 通过备忘录对象，恢复状态
public void getStateMemento(Memento memento) {
state = memento.getState();
}
public Originator() {
}
public Originator(String state) {
this.state = state;
}
public String getState() {
return state;
}
public void setState(String state) {
this.state = state;
}
@Override
public String toString() {
return "Originator{" +
"state='" + state + '\'' +
'}';
}
}
4.Test
package com.pattern.设计模式.备忘录模式;
public class Test {
public static void main(String[] args) {
Originator originator = new Originator();
Caretaker caretaker = new Caretaker();
originator.setState("状态ok");
// 保存了当前的状态
caretaker.add(originator.saveStateMemento());
originator.setState("状态No");
caretaker.add(originator.saveStateMemento());
originator.setState("状态还行");
caretaker.add(originator.saveStateMemento());
System.out.println("当前状态：" + originator.getState());
// 希望恢复到状态ok
originator.getStateMemento(caretaker.get(0));
System.out.println("当前状态：" + originator.getState());
}
}
2.解释器模式
2.1 解释器模式概述
(1)基本介绍
①在编译原理中， 一个算术表达式通过词法分析器形成词法单元，而后
这些词法单元再通过语法分析器构建语法分析树，最终形成一颗抽象
的语法分析树。这里的词法分析器和语法分析器都可以看做是解释器
②解释器(Interpreter)模式：是指给定一个语言(表达式)， 定义它的文法
的一种表示，并定义一个解释器， 使用该解释器来解释语言中的句子
(2)原理类图
Context: 是环境角色,含有解释器之外的全局信息.
AbstractExpression: 抽象表达式， 声明一个抽象的解释操作,这个方法为抽象语法树中所有的节点所共享
?TerminalExpression: 为终结符表达式, 实现与文法中的终结符相关的解释操作
NonTermialExpression: 为非终结符表达式，为文法中的非终结符实现解释操作.
(3)代码类图
PS：Spring框架中SpelExpressionParser就用到了解释器模式
3.状态模式
3.1 状态模式概述
(1)基本介绍
①状态模式（State Pattern）：它主要用来解决对象在多种状态转换时，
需要对外输出不同的行为的问题。状态和行为是一一对应的，状态之
间可以相互转换
②当一个对象的内在状态改变时，允许改变其行为，这个对象看起来像
是改变了其类
(2)原理类图
Context 类为环境角色, 用于维护State实例,这个实例定义当前状态
State 是抽象状态角色,定义一个接口封装与Context 的一个特点接口相关行为
ConcreteState 具体的状态角色，每个子类实现一个与Context 的一个状态相关行为
(3)代码类图
3.2 代码理解
1.State
package com.pattern.设计模式.状态模式;
public abstract class State {
// 扣除积分的方法
public abstract void Subtract();
// 是否中奖
public abstract boolean getPrize();
// 发放奖品
public abstract void grantPrize();
}
2.NoRaffleState
package com.pattern.设计模式.状态模式;
public class NoRaffleState extends State{
// 初始化拆传入活动引用 扣除积分后参加活动
RaffleActivity raffleState;
public NoRaffleState(RaffleActivity raffleState) {
this.raffleState = raffleState;
}
// 当前状态可以扣积分 扣除后将状态改为可以抽奖状态
@Override
public void Subtract() {
System.out.println("扣除50积分成功，你可以进行抽奖活动了");
raffleState.setState(raffleState.getCanRaffleState());
}
// 当前状态不能抽奖
@Override
public boolean getPrize() {
System.out.println("扣除了积分才能抽奖");
return false;
}
// 当前状态不能发放奖品
@Override
public void grantPrize() {
System.out.println("不能发放奖励");
}
}
3.DispenseState
package com.pattern.设计模式.状态模式;
public class DispenseState extends State{
RaffleActivity raffleState;
public DispenseState(RaffleActivity raffleState) {
this.raffleState = raffleState;
}
@Override
public void Subtract() {
System.out.println("已经扣除过积分了");
}
@Override
public boolean getPrize() {
System.out.println("不能抽奖");
return false;
}
@Override
public void grantPrize() {
if (raffleState.getCount() > 0){
System.out.println("恭喜你，中奖了！！！");
// 改变状态为不能抽奖
raffleState.setState(raffleState.getNoRaffleState());
} else {
System.out.println("很遗憾！！！奖品已经发放完毕！");
// 改变状态为奖品发送完毕
raffleState.setState(raffleState.getDispenseOutState());
}
}
}
4.DispenseOutState
package com.pattern.设计模式.状态模式;
public class DispenseOutState extends State{
RaffleActivity raffleState;
public DispenseOutState(RaffleActivity raffleState) {
this.raffleState = raffleState;
}
@Override
public void Subtract() {
System.out.println("奖品发放完了，请下次再来参加");
}
@Override
public boolean getPrize() {
System.out.println("奖品发放完了，请下次再来参加");
return false;
}
@Override
public void grantPrize() {
System.out.println("奖品发放完了，请下次再来参加");
}
}
5.CanRaffleState
package com.pattern.设计模式.状态模式;
import java.util.Random;
public class CanRaffleState extends State{
RaffleActivity raffleState;
public CanRaffleState(RaffleActivity raffleState) {
this.raffleState = raffleState;
}
@Override
public void Subtract() {
System.out.println("已经扣除积分了");
}
@Override
public boolean getPrize() {
System.out.println("正在抽奖");
Random random = new Random();
int num = random.nextInt(10);
// 10%的几率中将
if (num == 0) {
// 改变活动状态为发放奖品
raffleState.setState(raffleState.getDispensePrize());
return true;
} else {
System.out.println("很遗憾，你没有中奖");
// 改变状态为不能中奖
raffleState.setState(raffleState.getNoRaffleState());
return false;
}
}
@Override
public void grantPrize() {
System.out.println("没中奖，不能发放奖品");
}
}
6.RaffleActivity
package com.pattern.设计模式.状态模式;
public class RaffleActivity {
// 表示当前状态
State state = null;
// 奖品数量
int count = 0;
// 四个属性表示四种状态
State noRaffleState = new NoRaffleState(this);
State canRaffleState = new CanRaffleState(this);
State dispensePrize = new DispenseState(this);
State dispenseOutState = new DispenseOutState(this);
// 构造器 会初始化一个当前的状态
public RaffleActivity(int count) {
this.state = getNoRaffleState();
this.count = count;
}
// 扣除积分
public void Subtract() {
state.Subtract();
}
// 抽奖
public void getPrize() {
if (state.getPrize()) {
state.grantPrize();
}
}
public State getState() {
return state;
}
public void setState(State state) {
this.state = state;
}
public int getCount() {
int curCount = count;
count--;
return curCount;
}
public void setCount(int count) {
this.count = count;
}
public State getNoRaffleState() {
return noRaffleState;
}
public void setNoRaffleState(State noRaffleState) {
this.noRaffleState = noRaffleState;
}
public State getCanRaffleState() {
return canRaffleState;
}
public void setCanRaffleState(State canRaffleState) {
this.canRaffleState = canRaffleState;
}
public State getDispensePrize() {
return dispensePrize;
}
public void setDispensePrize(State dispensePrize) {
this.dispensePrize = dispensePrize;
}
public State getDispenseOutState() {
return dispenseOutState;
}
public void setDispenseOutState(State dispenseOutState) {
this.dispenseOutState = dispenseOutState;
}
}
7.Test
package com.pattern.设计模式.状态模式;
public class Test {
public static void main(String[] args) {
RaffleActivity raffleActivity = new RaffleActivity(2);
for (int i = 0; i < 100; i++) {
System.out.println("" + (i + 1) + "");
raffleActivity.Subtract();
raffleActivity.getPrize();
}
}
}
4.策略模式
4.1 策略模式概述
(1)基本介绍
①策略模式（Strategy Pattern）中，定义算法族，分别封装起来，
让他们之间可以互相替换，此模式让算法的变化独立于使用算
法的客户
②这算法体现了几个设计原则，第一、把变化的代码从不变的代码
中分离出来；第二、针对接口编程而不是具体类（定义了策略接口）；
第三、多用组合/聚合，少用继承（客户通过组合方式使用策略）。
(2)原理类图
从上图可以看到，客户context 有成员变量strategy或者其他的策略接口,至于需要使用到哪个策略，我们可以在构造器中指定.
(3)代码类图
PS：JDK的Arrays的Comparator使用到了策略模式
4.2 代码理解
1.InterfaceFly
package com.pattern.设计模式.策略模式;
public interface InterfaceFly {
void fly();
}
2.NoFly
package com.pattern.设计模式.策略模式;
public class NoFly implements InterfaceFly{
@Override
public void fly() {
System.out.println("垃圾鸭！不会飞翔");
}
}
3.ToysFly
package com.pattern.设计模式.策略模式;
public class ToysFly implements InterfaceFly{
@Override
public void fly() {
System.out.println("玩具鸭飞不起来");
}
}
4.GoodFly
package com.pattern.设计模式.策略模式;
public class GoodFly implements InterfaceFly{
@Override
public void fly() {
System.out.println("这是good鸭，特别会飞");
}
}
5.Duck
package com.pattern.设计模式.策略模式;
public abstract class Duck {
InterfaceFly interfaceFly;
public Duck() {
}
public Duck(InterfaceFly interfaceFly) {
this.interfaceFly = interfaceFly;
}
public abstract void disPlay(); // 鸭子属性
public void quack() {
System.out.println("嘎嘎嘎的叫");
}
public void swim() {
System.out.println("会游泳！！！");
}
public void fly() {
if (interfaceFly != null) {
interfaceFly.fly();
}
}
}
6.WildDuck
package com.pattern.设计模式.策略模式;
public class WildDuck extends Duck{
public WildDuck() {
interfaceFly = new GoodFly();
}
@Override
public void disPlay() {
System.out.println("这是野鸭");
}
}
7.ToysDuck
package com.pattern.设计模式.策略模式;
public class ToysDuck extends Duck{
public ToysDuck() {
interfaceFly = new NoFly();
}
@Override
public void disPlay() {
System.out.println("这是玩具鸭");
}
}
8.OrdinaryDuck
package com.pattern.设计模式.策略模式;
public class OrdinaryDuck extends Duck{
public OrdinaryDuck() {
interfaceFly = new NoFly();
}
@Override
public void disPlay() {
System.out.println("这是普通鸭");
}
}
9.Test
package com.pattern.设计模式.策略模式;
public class Test {
public static void main(String[] args) {
WildDuck wildDuck = new WildDuck();
wildDuck.fly();
OrdinaryDuck ordinaryDuck = new OrdinaryDuck();
ordinaryDuck.fly();
ToysDuck toysDuck = new ToysDuck();
toysDuck.fly();
}
}
5.职责链模式
5.1 职责链模式概述
(1)基本介绍
①职责链模式（Chain of Responsibility Pattern）, 又叫 责任链
模式，为请求创建了一个接收者对象的链(简单示意 图)。这种模式
对请求的发送者和接收者进行解耦。
②职责链模式通常每个接收者都包含对另一个接收者的引用。如果一
个对象不能处理该请求，那么它会把相同的 请求传给下一个接收者，
依此类推。
③它属于行为型模式
(2)原理类图
Handler : 抽象的处理者, 定义了一个处理请求的接口, 同时含义另外 Handler
ConcreteHandlerA , B： 是具体的处理者, 处理它自己负责的请求， 可以
问它的后继者(即下一个处理者), 如果 可以处理当前请求，则处理，否则
将该请求交个 后继者去处理，从而形成一个职责链
Request ： 含义很多属性，表示一个请求
(3)代码类图
PS：职责链模式在SpringMVC框架的HandlerExcutionChain类 中用到了
5.2 代码理解
package com.pattern.设计模式.职责链模式;
public abstract class AppRover {
AppRover appRover; // 下一个处理者
String name;
// 处理审批请求
public abstract void processRequest(PurchaseRequest purchaseRequest);
public AppRover(String name) {
this.name = name;
}
public AppRover getAppRover() {
return appRover;
}
public void setAppRover(AppRover appRover) {
this.appRover = appRover;
}
public String getName() {
return name;
}
public void setName(String name) {
this.name = name;
}
@Override
public String toString() {
return "AppRover{" +
"appRover=" + appRover +
", name='" + name + '\'' +
'}';
}
}
package com.pattern.设计模式.职责链模式;
public class DepartmentAppRover extends AppRover {
public DepartmentAppRover(String name) {
super(name);
}
@Override
public void processRequest(PurchaseRequest purchaseRequest) {
if (purchaseRequest.getPrice() <= 5000) {
System.out.println(purchaseRequest.getId() + "号被" + this.name + "处理了");
} else {
appRover.processRequest(purchaseRequest);
}
}
}
package com.pattern.设计模式.职责链模式;
public class College extends AppRover {
public College(String name) {
super(name);
}
@Override
public void processRequest(PurchaseRequest purchaseRequest) {
if (purchaseRequest.getPrice() > 5000 && purchaseRequest.getPrice() <= 10000) {
System.out.println(purchaseRequest.getId() + "被" + this.name + "处理了");
} else {
appRover.processRequest(purchaseRequest);
}
}
}
package com.pattern.设计模式.职责链模式;
public class SchoolOne extends AppRover {
public SchoolOne(String name) {
super(name);
}
@Override
public void processRequest(PurchaseRequest purchaseRequest) {
if (purchaseRequest.getPrice() > 30000) {
System.out.println(purchaseRequest.getId() + "被" + this.name + "处理了");
} else {
appRover.processRequest(purchaseRequest);
}
}
}
package com.pattern.设计模式.职责链模式;
public class ViceSchool extends AppRover{
public ViceSchool(String name) {
super(name);
}
@Override
public void processRequest(PurchaseRequest purchaseRequest) {
if (purchaseRequest.getPrice() > 10000 && purchaseRequest.getPrice() <= 30000) {
System.out.println(purchaseRequest.getId() + "被" + this.name + "处理了");
} else {
appRover.processRequest(purchaseRequest);
}
}
}
package com.pattern.设计模式.职责链模式;
public class PurchaseRequest {
private int type = 0;
private float price = 0.0f;
private int id = 0;
public PurchaseRequest(int type, float price, int id) {
this.type = type;
this.price = price;
this.id = id;
}
public int getType() {
return type;
}
public void setType(int type) {
this.type = type;
}
public float getPrice() {
return price;
}
public void setPrice(float price) {
this.price = price;
}
public int getId() {
return id;
}
public void setId(int id) {
this.id = id;
}
@Override
public String toString() {
return "PurchaseRequest{" +
"type=" + type +
", price=" + price +
", id=" + id +
'}';
}
}
7.Test
package com.pattern.设计模式.职责链模式;
public class Test {
public static void main(String[] args) {
PurchaseRequest purchaseRequest = new PurchaseRequest(1, 3000, 1);
// 创建相关的审批人
DepartmentAppRover departmentAppRover = new DepartmentAppRover("李主任");
College college = new College("王院长");
ViceSchool viceSchool = new ViceSchool("张副校");
SchoolOne schoolOne = new SchoolOne("刘校长");
// 将审批的下一个责任人set好(处理人形成一个环形)
departmentAppRover.setAppRover(college);
college.setAppRover(viceSchool);
viceSchool.setAppRover(schoolOne);
// 最大再把权利交给最小
schoolOne.setAppRover(departmentAppRover);
departmentAppRover.processRequest(purchaseRequest);
}
}
PS：到这里就结束了23种设计模式，这些个文章主要用于自己做个简单的笔记，当然也希望能帮到需要的人，23个模式的的总笔记可以下载我的资源，我上传了一个笔记资源。也希望大家可以之处问题。谢谢大家！！！
扫一扫
520
被折叠的 条评论
为什么被折叠?
到【灌水乐园】发言
