(完整word版)设计模式实验

来源：微智科技网

《代码重构与设计模式》课堂实验徐海蛟博士 2016.03

实验一工厂模式的应用

【实验目的】

1) 掌握工厂模式（Factory）的特点 2) 分析具体问题，使用工厂模式进行设计。

【实验内容和要求】

有一个 OEM 制造商代理做 HP 笔记本电脑(Laptop)，后来该制造商得到了更多的品牌笔记本电脑的订单 Acer、Lenovo、Dell，该 OEM 商发现，如果一次同时做很多个牌子的本本，有些不利于管理。利用工厂模式改善设计，用控制台应用程序实现该 OEM 制造商的工厂模式。该模式的 UML 图如下。

【模式UML图】

【模式代码（JAVA 语言实现）】

public class FactoryMethod {// 主类

public static void main(String[] args) {

Computer c;

Factory f = new DellFactory(); c = f.getComputerType(); c.ComputerType(); f = new LenovoFactory();

}

interface Factory{ }

class DellFactory implements Factory{ }

class AcerFactory implements Factory{ }

class LenovoFactory implements Factory{ } /** * 电脑品牌 */

interface Computer{

public void ComputerType(); }

class Dell implements Computer{

@Override

public void ComputerType() {

// TODO Auto‐generated method stub }

@Override

public Computer getComputerType() {

return new Lenovo(); }

@Override

public Computer getComputerType() {

return new Acer(); @Override

public Computer getComputerType() {

return new Dell(); }

Computer getComputerType(); }

《代码重构与设计模式》课堂实验徐海蛟博士 2016.03

c = f.getComputerType(); c.ComputerType(); f = new AcerFactory(); c = f.getComputerType(); c.ComputerType();

《代码重构与设计模式》课堂实验徐海蛟博士 2016.03

System.out.println(\"Dell Computer\"); } }

class Acer implements Computer{ }

class Lenovo implements Computer{

} }

@Override

public void ComputerType() {

// TODO Auto‐generated method stub System.out.println(\"Lenovo Computer\"); }

@Override

public void ComputerType() {

System.out.println(\"Acer Computer\");

【运行截图】

【实验小结】

通过本次实验，学会了使用工厂方法模式。工厂方法模式的适用性如下：

当一个类不知道它所必须创建的对象的类时。

当一个类希望由它的子类来指定它所创建的对象时。

当类将创建对象的职责委托给多个帮助子类中的某一个，并且希望将哪一个帮助子类是代理这一信息局部化时。

《代码重构与设计模式》课堂实验徐海蛟博士 2016.03

实验二抽象工厂模式的应用

【实验目的】

1) 掌握抽象工厂模式（Abstract Factory）的特点 2) 分析具体问题，使用抽象工厂模式进行设计。

【实验内容和要求】

麦当劳（McDonalds）和肯德基（KFC）快餐店都经营汉堡（Hamburg）和可乐（Cola），用 JAVA 控制台应用程序实现这两个快餐店经营产品的抽象工厂模式。该模式的 UML 图如下。

【模式 UML 图】

【模式代码】

public class AbstractFactoryTest {

public static void main(String[] args) {

Hamburg h; Cola c;

AbstractFactory af = new MDNFactory();

}

interface AbstractFactory{ }

Hamburg createHamburg(); Cola createCola(); }

af = new KDJFactory(); h = af.createHamburg(); c = af.createCola(); h.getHumburg(); c.getCola();

《代码重构与设计模式》课堂实验徐海蛟博士 2016.03

h = af.createHamburg(); c = af.createCola(); h.getHumburg(); c.getCola();

class MDNFactory implements AbstractFactory { }

class KDJFactory implements AbstractFactory{ } /**

* kDJ &ＭＤＮ */

interface Hamburg{

}

@Override

public Cola createCola() {

return new KDJCola(); } @Override

public Hamburg createHamburg() {

return new KDJHamburg(); }

@Override

public Cola createCola() {

return new MDNCola(); } @Override

public Hamburg createHamburg() {

return new MDNHamburg();

《代码重构与设计模式》课堂实验徐海蛟博士 2016.03

void getHumburg(); }

class MDNHamburg implements Hamburg{ }

class KDJHamburg implements Hamburg{ }

interface Cola{ }

class MDNCola implements Cola{ }

class KDJCola implements Cola{

} }

@Override

public void getCola() {

System.out.println(\"KDJCola\"); }

@Override

public void getCola() {

System.out.println(\"MDNCola\"); void getCola(); }

@Override

public void getHumburg() {

// TODO Auto‐generated method stub System.out.println(\"KDJHamburg\"); }

@Override

public void getHumburg() {

System.out.println(\"MDNHamburg\");

【运行截图】

《代码重构与设计模式》课堂实验徐海蛟博士 2016.03

【实验小结】

抽象工厂模式主要适用于以下情况：

一系列要于它的产品的创建、组合和表示时。、一个系统要由多个产品系列中的一个来配置时。

当要强调一系列相关的产品对象的设计以便进行联合使用时。当要提供一个产品类库，而只要显示它们的接口而不是实现时。

1) 掌握适配器模式（Adapter）的特点

《代码重构与设计模式》课堂实验徐海蛟博士 2016.03

实验三适配器模式的应用

【实验目的】

2) 分析具体问题，使用适配器模式进行设计。

【实验内容和要求】

public class AdapterTest {

public static void main(String[] args) { }

}

Paint a = new AngleAdapter(); a.draw();

一个软件团队开发绘图系统，设计了圆对象(Circle)、矩形对象(Rectangle)，线对象(Line)都支持 Draw()函数，即可以通过 Draw()函数绘制图形。为了加快项目进度，将角度对象(Angle)绘制功能交给了合作团队实现。但合作团队将角度对象绘制函数定为了 DrawAngle()。绘图系统提供给用户后，用户不满意，希望能统一的调用，不用记太多命令。应用适配器模式，用 JAVA 控制台应用程序完善该设计。该模式的 UML 图如下。

【模式UML图】

【模式代码】

《代码重构与设计模式》课堂实验徐海蛟博士 2016.03

interface Paint{ void draw(); }

class Circle implements Paint{ }

class Rectangle implements Paint{ }

class Line implements Paint{ }

class Angle{ }

class AngleAdapter implements Paint{

} }

private Angle a=new Angle(); @Override

public void draw() {

// TODO Auto‐generated method stub a.DrawAngle(); }

public void DrawAngle(){

System.out.println(\"角度\"); }

@Override

public void draw() {

System.out.println(\"线线\"); @Override

public void draw() {

System.out.println(\"方方\"); } }

@Override

public void draw() {

System.out.println(\"圆圆\");

【运行截图】

《代码重构与设计模式》课堂实验徐海蛟博士 2016.03

【实验小结】

适配器模式主要适用于以下情况：

当想要使用一个已经存在的类，但是该类的接口不符合现有的需求时。当需要创建一个可以被复用的类，该类能够与其他无关的类甚至无法预见的类协同工作时。

当需要使用一个已经存在的子类，但是不可能对所有的都进行子类化以匹配他们的接口时，对象适配器可以对其父类接口进行适配。

《代码重构与设计模式》课堂实验徐海蛟博士 2016.03

实验四桥接模式的应用

【实验目的】

1) 掌握桥接模式（Bridge）的特点

2) 分析具体问题，使用桥接模式进行设计。

【实验内容和要求】

一个咖啡店可以提供大杯 (JorumCoffee) 、中杯 (MediumCoffee) 、(SmallCoffee)的咖啡(Coffee)，为了满足不同用户的口味，在咖啡中可以添加牛奶 (Milk)，或者糖(Sugar)，或者柠檬(Lemon)，提供给用户不同口味的组合，如大杯咖啡加牛奶，中杯咖啡加糖，小杯咖啡加柠檬，小杯咖啡加糖等。应用桥接模式，用 JAVA 控制台应用程序实现该设计。该模式的 UML 图如下。

【模式类图】

【模式代码】

package Constructor;

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

Bridge b;

b=new Sugar();

杯

小

}

interface Coffee{ }

class JorumCoffee implements Coffee{ }

class MediumCoffee implements Coffee{ } }

class SmallCoffee implements Coffee{ @Override

public void getCoffee() { } /** * 配料 */

abstract class Bridge{ protected Coffee c; void setCoffee(Coffee co){

} }

}

public void getCoffee(){

c.getCoffee(); c=co; }

// TODO Auto‐generated method stub System.out.print(\"小杯咖啡\"); @Override

public void getCoffee() {

// TODO Auto‐generated method stub System.out.print(\"中杯咖啡\"); }

@Override

public void getCoffee() {

// TODO Auto‐generated method stub System.out.print(\"大杯咖啡\"); void getCoffee(); }

《代码重构与设计模式》课堂实验徐海蛟博士 2016.03

b.setCoffee(new JorumCoffee()); b.getCoffee(); b=new Milk();

b.setCoffee(new SmallCoffee()); b.getCoffee();

《代码重构与设计模式》课堂实验徐海蛟博士 2016.03

class Sugar extends Bridge{ }

class Milk extends Bridge{ }

class Lemon extends Bridge{ }

}

@Override

public void getCoffee(){

c.getCoffee();

System.out.println(\"加柠檬\"); }

@Override

public void getCoffee(){

c.getCoffee();

System.out.println(\"加牛奶\"); }

@Override

public void getCoffee(){

c.getCoffee();

System.out.println(\"加糖\");

【运行截图】

【实验小结】

桥接模式的适用情况有：

当不希望在抽象和它的实现之间有一个固定的绑定关系时。

当类的抽象以及它的实现都应该可以通过生成子类的方法加以扩充时。当对一个抽象类的实现部分的修改应对客户不产生影响时。

《代码重构与设计模式》课堂实验徐海蛟博士 2016.03

实验五装饰模式的应用

【实验目的】

1) 掌握装饰模式（Decorator）的特点 2) 分析具体问题，使用装饰模式进行设计。

【实验内容和要求】

“喜羊羊逃命”游戏：喜羊羊被灰太狼追，喜羊羊最多 5 条命，灰太狼每咬到喜羊羊一次，喜羊羊就要少一条命。在逃的过程中喜羊羊可以吃到三种苹果，吃 “红苹果”可以给喜羊羊加上保护罩，吃“绿苹果”可以加快喜羊羊奔跑速度，吃“黄苹果”可以使喜羊羊趟着水跑。应用装饰模式，用 JAVA 控制台应用程序实现该设计。绘制该模式的 UML 图。

提示：这个例子如果用类的继承来实现的话那可就麻烦了，你需要为喜羊羊派生 3*2*1=6 个子类（有保护罩的喜羊羊，奔跑速度加快的喜羊羊，会趟水的喜羊羊，既有保护罩又会趟水的喜羊羊，奔跑速度快且会趟水的喜羊羊，有保护罩且奔跑速度快的喜羊羊，有保护罩、奔跑速度快且会趟水的喜羊羊），如果使用装饰模式的那就不用派生诸多子类了，当喜羊羊每吃到一个苹果，我们就用装饰模式给喜羊羊加一个动态增加一个新功能即可。

【模式类图】

《代码重构与设计模式》课堂实验徐海蛟博士 2016.03

【模式代码】

public class DecoratorTest01 { }

interface XiYangyang{ }

class ConcreteXiYY implements XiYangyang{ }

abstract class Decorator implements XiYangyang{

}

@Override

public void Operation() {

// TODO Auto‐generated method stub xyy.Operation(); protected XiYangyang xyy;

public void setXiYangyang(XiYangyang xyy){

this.xyy=xyy; }

@Override

public void Operation() {

// TODO Auto‐generated method stub System.out.println(\"喜羊羊\"); public void Operation(); }

public static void main(String[] args) {

ConcreteXiYY cxyy=new ConcreteXiYY();

ProtectXiYangyang px=new ProtectXiYangyang(); FastXiYangyang fx=new FastXiYangyang(); SwimingXiYangyang sx=new SwimingXiYangyang(); px.setXiYangyang(cxyy); px.Operation(); fx.setXiYangyang(px); fx.Operation(); sx.setXiYangyang(fx); sx.Operation();

《代码重构与设计模式》课堂实验徐海蛟博士 2016.03

}

class ProtectXiYangyang extends Decorator { }

class FastXiYangyang extends Decorator { }

class SwimingXiYangyang extends Decorator { }

}

@Override

public void Operation() {

// TODO Auto‐generated method stub System.out.print(\" 会游泳的\"); super.Operation(); }

@Override

public void Operation() {

// TODO Auto‐generated method stub System.out.print(\" 加速的\"); super.Operation(); }

@Override

public void Operation() {

// TODO Auto‐generated method stub System.out.print(\" 有保护罩的\"); super.Operation();

【运行截图】

【实验小结】

装饰模式的适用情况有：

当需要以不影响其他对象为前提实现动态、透明地给单个对象添加职责时。当需要将对象的某些职责进行撤销操作时。

当不能用生成子类的方法进行当前系统的扩充时。

《代码重构与设计模式》课堂实验徐海蛟博士 2016.03

实验六代理模式的应用

【实验目的】

1) 掌握代理模式（Proxy）的特点

2) 分析具体问题，使用代理模式进行设计。

【实验内容和要求】

生产商(Factory)需要销售商品(Product)，网上商城(E-Shop)提供了一个平台，可以帮助销售这些商品，获得更大的销量。当顾客(Custom)从网上商城选购商品的时候，实际是从生产商获得的商品。应用代理模式，用 JAVA 控制台应用程序改进该设计。绘制该模式的 UML 图。

【模式UML图】

【实验代码】

public class ProxyTest01 {

《代码重构与设计模式》课堂实验徐海蛟博士 2016.03

public static void main(String[] args) { // TODO Auto‐generated method stub }

abstract class Product{ }

class Factory extends Product{ }

class E_shop extends Product{

} }

}

@Override

public void product() {

// TODO Auto‐generated method stub factory.product(); private Factory factory; public E_shop(){

factory=new Factory(); }

@Override

public void product() {

// TODO Auto‐generated method stub

System.out.println(\"商品正在促销中，满一百减 50.\"); public abstract void product(); }

E_shop es=new E_shop(); es.product();

【运行截图】

【实验小结】

代理模式的有以下几种适用情况：

当需要为一个对象在不同的地址空间提供局部的代表时。当需要创建开销非常大的对象时。当需要控制原始对象的访问时。

当需要再访问对象时执行一些附加操作时，比如通过代理对象计算访问实际对象的次数。

1) 掌握外观模式（Observer）的特点

《代码重构与设计模式》课堂实验徐海蛟博士 2016.03

实验七观察者模式的应用

【实验目的】

2) 分析具体问题，使用外观模式进行设计。

【实验内容和要求】

网上商店中如果商品（product）在名称（name）、价格（price）等方面有变化，系统能自动通知会员，将是网上商店区别传统商店的一大特色。如何设计实现？说明你所选择的设计模式，画出类关系图并指明各个类的角色。应用外观模式，用 JAVA 控制台应用程序改进该设计。绘制该模式的 UML 图。

【模式 UML 图】

【模式代码】

import java.util.ArrayList; public class ObeserverTest {

public static void main(String[] args) {

// TODO Auto‐generated method stub ConcreteSubject cs=new ConcreteSubject(); cs.Attach(new ConcreteObserver(cs, \"1 号会员\")); cs.Attach(new ConcreteObserver(cs, \"2 号会员\")); cs.Attach(new ConcreteObserver(cs, \"3 号会员\")); cs.Attach(new ConcreteObserver(cs, \"4 号会员\")); cs.setState(\"C++编程思想价钱下降 100 元\");

《代码重构与设计模式》课堂实验徐海蛟博士 2016.03

cs.Notify(); } }

abstract class Observer{ }

class ConcreteObserver extends Observer{ }

abstract class Subject{

private ArrayList observers=new ArrayList();

public void Attach(Observer o){ observers.add(o); }

public void Detach(Observer o){ observers.remove(o); } }

//通知

public void Notify(){

for (int i = 0; i < observers.size(); i++) { } }

observers.get(i).update();

} }

@Override

public void update() {

// TODO Auto‐generated method stub state=cs.getState();

System.out.println(name+\"观察到的状态是：\"+state); }

public ConcreteObserver(ConcreteSubject cs,String name){

this.cs=cs; this.name=name; }

public void setConcreteSubject(ConcreteSubject cs){

this.cs=cs; private String name; private String state; private ConcreteSubject cs;

public ConcreteSubject getConcreteSubject(){

return cs;

public abstract void update();

《代码重构与设计模式》课堂实验徐海蛟博士 2016.03

class ConcreteSubject extends Subject{ private String state;

public void setState(String state){ this.state=state; }

public String getState(){ return state; } }

【运行截图】

【实验小结】

观察者模式的适用情况有：

当一个抽象模型有两个方面，而其中一个方面必须依赖于另一个方面时。当对一个对象的改变需要同时改变其他对象但是却不知道具体有多少个对象等到改变时。

当一个对象必须通知其他对象但是却不能与其他对象造成紧密耦合时。

《代码重构与设计模式》课堂实验徐海蛟博士 2016.03

实验八职责链模式的应用

【实验目的】

1) 掌握职责链模式（Chain of Responsibility）的特点 2) 分析具体问题，使用职责链模式进行设计。

【实验内容和要求】

高校学生请假需要符合学校规定，假如班主任可以批准 1 天假，系主任可以批准 7 天假，各学院院长可以批准 30 天，学校校长可以批准 1 年。应用职责链模式，用 JAVA 控制台应用程序实现该设计。绘制该模式的 UML 图。

【模式UML图】

【模式代码】

public class StudentClient {

public static void main(String[] args) {

}

// TODO Auto‐generated method stub Handler fdy=new FuDaoYuan(); Handler xzr=new XiZhuRen(); Handler xy=new XueYuan(); Handler xx=new XueXiao(); fdy.setSuccessor(xzr); xzr.setSuccessor(xy); xy.setSuccessor(xx);

for (int i = 1; i < 20; i+=2) {

fdy.handleRequest(i);

}

//处理请求的接口

abstract class Handler{ }

class FuDaoYuan extends Handler{ }

class XiZhuRen extends Handler{

}

@Override }

}

} }else{

if(this.successor!=null){

@Override }

protected Handler successor;

}

《代码重构与设计模式》课堂实验徐海蛟博士 2016.03

public void setSuccessor(Handler successor){

this.successor=successor;

public abstract void handleRequest(int request);

public void handleRequest(int request) {

// TODO Auto‐generated method stub if(request<=1){

System.out.println(this.getClass().getSimpleName()+\"处理了请

求\"+request);

System.out.println(this.getClass().getSimpleName()+\"自身 this.successor.handleRequest(request);

无法满足请求，转入下一个处理者\");

public void handleRequest(int request) {

// TODO Auto‐generated method stub if(request<=7){

System.out.println(this.getClass().getSimpleName()+\"处理了请 }else{

if(this.successor!=null){

System.out.println(this.getClass().getSimpleName()+\"自身 this.successor.handleRequest(request);

求\"+request);

无法满足请求，转入下一个处理者\");

}

class XueYuan extends Handler{ }

class XueXiao extends Handler{ }

}

@Override }

}

@Override

《代码重构与设计模式》课堂实验徐海蛟博士 2016.03

public void handleRequest(int request) {

// TODO Auto‐generated method stub if(request<=9){

System.out.println(this.getClass().getSimpleName()+\"处理了请 }else{

if(this.successor!=null){

System.out.println(this.getClass().getSimpleName()+\"自身 this.successor.handleRequest(request);

求\"+request);

无法满足请求，转入下一个处理者\");

public void handleRequest(int request) {

// TODO Auto‐generated method stub if(request<=15){

System.out.println(this.getClass().getSimpleName()+\"处理了请 }else{

System.out.println(\"该生请假时间太长，不能批准\");

求\"+request);

【运行截图】

FuDaoYuan 处理了请求 1

FuDaoYuan 自身无法满足请求，转入下一个处理者 XiZhuRen 处理了请求 3

FuDaoYuan 自身无法满足请求，转入下一个处理者 XiZhuRen 处理了请求 5

FuDaoYuan 自身无法满足请求，转入下一个处理者 XiZhuRen 处理了请求 7

FuDaoYuan 自身无法满足请求，转入下一个处理者

《代码重构与设计模式》课堂实验徐海蛟博士 2016.03

XiZhuRen 自身无法满足请求，转入下一个处理者 XueYuan 处理了请求 9

FuDaoYuan 自身无法满足请求，转入下一个处理者 XiZhuRen 自身无法满足请求，转入下一个处理者 XueYuan 自身无法满足请求，转入下一个处理者 XueXiao 处理了请求 11

FuDaoYuan 自身无法满足请求，转入下一个处理者 XiZhuRen 自身无法满足请求，转入下一个处理者 XueYuan 自身无法满足请求，转入下一个处理者 XueXiao 处理了请求 13

FuDaoYuan 自身无法满足请求，转入下一个处理者 XiZhuRen 自身无法满足请求，转入下一个处理者 XueYuan 自身无法满足请求，转入下一个处理者 XueXiao 处理了请求 15

FuDaoYuan 自身无法满足请求，转入下一个处理者 XiZhuRen 自身无法满足请求，转入下一个处理者 XueYuan 自身无法满足请求，转入下一个处理者该生请假时间太长，不能批准

【实验小结】

职责链模式主要适用于以下情况：

当有多个对象可以处理同一个请求，而具体哪个对象来处理这个请求在运行时刻需要自动判定时。

当需要在不明确接受者的情况下向多个对象中的某一个提交请求时。当处理一个请求的对象集合应该动态地被确定时。

1) 掌握访问者模式（Visitor）的特点

《代码重构与设计模式》课堂实验徐海蛟博士 2016.03

实验九访问者模式的应用

【实验目的】

2) 分析具体问题，使用访问者模式进行设计。

【实验内容和要求】

超市中有两类商品，苹果(Apple)和巧克力(Chocolate)，顾客(Custom)将所选商品放在购物车中(Shopping Cart)，然后到收银员(Cashier)处付款。在购物过程中，顾客需要对这些商品进行访问，以便确认这些商品的质量，之后收银员也需要访问购物车内的商品，以便计算价格。应用访问者模式，用 JAVA 控制台应用程序实现该设计。绘制该模式的 UML 图。

【模式UML图】

《代码重构与设计模式》课堂实验徐海蛟博士 2016.03

【模式代码】

import java.util.ArrayList; import java.util.List; public class ShoppingTest {

/**

* @param args */ }

abstract class PersonVisitor{ }

class Customer extends PersonVisitor{ }

class Cashier extends PersonVisitor{

} }

@Override

public void visitorApple(Apple apple) {

// TODO Auto‐generated method stub

System.out.println(this.getClass().getSimpleName()+\" 选购 public abstract void visitorApple(Apple apple);

public abstract void visitorChocolate(Chocolate chocolate); }

public static void main(String[] args) {

// TODO Auto‐generated method stub ShoppingCart sc=new ShoppingCart(); sc.Attach(new Apple(\"Apple\"));

sc.Attach(new Chocolate(\"Chocolate\")); PersonVisitor pv=new Customer(); sc.accept(pv);

PersonVisitor ps=new Cashier(); sc.accept(ps);

\"+apple.getName());

@Override

public void visitorChocolate(Chocolate chocolate) {

// TODO Auto‐generated method stub

System.out.println(this.getClass().getSimpleName()+\" 选购

\"+chocolate.getName());

}

} }

@Override

《代码重构与设计模式》课堂实验徐海蛟博士 2016.03

public void visitorApple(Apple apple) {

// TODO Auto‐generated method stub

System.out.println(this.getClass().getSimpleName()+\" 对

\"+apple.getName()+\" 收银\");

@Override

public void visitorChocolate(Chocolate chocolate) {

// TODO Auto‐generated method stub

System.out.println(this.getClass().getSimpleName()+\" 对

\"+chocolate.getName()+\" 收银\");

abstract class Shop{ }

class Apple extends Shop{ }

}

class Chocolate extends Shop{

}

public Apple(String name) {

super(name);

// TODO Auto‐generated constructor stub } }

public abstract void aet(PersonVisitor pv); public String getName(){

return name; protected String name; public Shop(String name){

this.name=name;

@Override

public void aet(PersonVisitor pv) {

// TODO Auto‐generated method stub pv.visitorApple(this);

}

《代码重构与设计模式》课堂实验徐海蛟博士 2016.03

public Chocolate(String name) {

super(name);

// TODO Auto‐generated constructor stub

@Override

public void aet(PersonVisitor pv) {

// TODO Auto‐generated method stub pv.visitorChocolate(this);

class ShoppingCart{ }

}

} }

public void accept(PersonVisitor visitor){

for (int i = 0; i < shops.size(); i++) {

shops.get(i).aet(visitor);

}

public void Detach(Shop shop){

shops.remove(shop);

List shops=new ArrayList(); public void Attach(Shop shop){

shops.add(shop);

【运行截图】

【实验小结】

访问者模式主要有以下几种适用情况：

当一个对象结构包含有很多类对象，但是他们又不同的接口，并且开发人员希望对这些对象实施一些依赖于具体类的操作时。

当需要对一个对象结构中的对象进行很多不同的并且不相关的操作时。当该对象结构被很多应用共享时。

1) 掌握备忘录模式（Memento）的特点

《代码重构与设计模式》课堂实验徐海蛟博士 2016.03

实验十备忘录模式的应用

【实验目的】

2) 分析具体问题，使用备忘录模式进行设计。

【实验内容和要求】

Window 系统可能会异常终止，设计一个系统备份程序。类 WindowsSystem 是发起人角色(Orignation)，类 Memento 是备忘录角色(Memento)，类 User 是备忘录管理角色(Caretaker)。应用备忘录模式，用 JAVA 控制台应用程序实现该设计。绘制该模式的 UML 图。

【模式UML图】

【模式代码】

public class WindowsMemento {

public static void main(String[] args) {

// TODO Auto‐generated method stub WindowsSystem ws=new WindowsSystem(); ws.setState(\"开机正常工作\"); ws.show();

User u=new User();

u.setMementoWindows(ws.createMementoWindows());

} }

//备忘录类

class MementoWindows{ private String state;

public MementoWindows(String state){ }

class WindowsSystem{ }

class User{

}

private String state; //建立状态存储对象 } }

//获取状态

public String getState(){

return state; this.state=state;

《代码重构与设计模式》课堂实验徐海蛟博士 2016.03

ws.setState(\"系统崩了啊！\"); ws.show();

System.out.println(\"对系统进行恢复......10s\"); ws.setMementoWindows(u.getMementoWindows()); ws.show();

public MementoWindows createMementoWindows() { }

//设置状态存储对象

public void setMementoWindows(MementoWindows mementoWindows){ }

//展现状态

public void show(){ }

//获取状态

public String getState(){ }

//设置状态

public void setState(String state){

this.state=state; return state;

System.out.println(\"状态为：\"+state); state=mementoWindows.getState(); return new MementoWindows(state);

private MementoWindows mementoWindows;

}

《代码重构与设计模式》课堂实验徐海蛟博士 2016.03

//设定备忘

public void setMementoWindows(MementoWindows mementoWindows){ }

//获取备忘

public MementoWindows getMementoWindows(){ }

return mementoWindows;

this.mementoWindows=mementoWindows;

【运行截图】

【实验小结】

备忘录模式有以下几种适用情况：

当必须保存一个对象在某一时刻的全部或部分状态以便在需要时可以将其回复到先前的状态时。

当使用接口让其他对象直接得到自己的状态会暴露对象的实现细节、继而破坏其封装性。

因篇幅问题不能全部显示，请点此查看更多更全内容

查看全文