《设计模式》实验指导书
10学时
教 师: 张 凯
实验一 工厂模式的应用
【实验目的】
1) 掌握工厂模式(Factory)的特点
2) 分析具体问题,使用工厂模式进行设计。
【实验内容和要求】
有一个OEM制造商代理做HP笔记本电脑(Laptop),后来该制造商得到了更多的品牌笔记本电脑的订单Acer,Lenovo,Dell,该OEM商发现,如果一次同时做很多个牌子的本本,有些不利于管理。利用工厂模式改善设计,用C#控制台应用程序实现该OEM制造商的工厂模式。绘制该模式的UML图。
【模式UML图】
【模式代码(JAVA语言实现)】
publicclass FactoryMethod {
publicstaticvoid main(String[] args) {
Computer c;
Factory f=new DellFactory();
c=f.getComputerType();
c.ComputerType();
f=new LenovoFactory();
c=f.getComputerType();
c.ComputerType();
f=new AcerFactory();
c=f.getComputerType();
c.ComputerType();
}
}
interface Factory{
Computer getComputerType();
}
class DellFactory implements Factory{
@Override
public Computer getComputerType() {
returnnew Dell();
}
}
class AcerFactory implements Factory{
@Override
public Computer getComputerType() {
returnnew Acer();
}
}
class LenovoFactory implements Factory{
@Override
public Computer getComputerType() {
returnnew Lenovo();
}
}
/**
* 电脑品牌
*/
interface Computer{
publicvoid ComputerType();
}
class Dell implements Computer{
@Override
publicvoid ComputerType() {
// TODO Auto-generated method stub
System.out.println("Dell Computer");
}
}
class Acer implements Computer{
@Override
publicvoid ComputerType() {
System.out.println("Acer Computer");
}
}
class Lenovo implements Computer{
@Override
publicvoid ComputerType() {
// TODO Auto-generated method stub
System.out.println("Lenovo Computer");
}
}
【运行截图】
【实验小结】
通过本次实验,学会了使用工厂方法模式。工厂方法模式的适用性如下:
当一个类不知道它所必须创建的对象的类时。
当一个类希望由它的子类来指定它所创建的对象时。
当类将创建对象的职责委托给多个帮助子类中的某一个,并且希望将哪一个帮助子类是代理这一信息局部化时。
实验二 抽象工厂模式的应用
【实验目的】
1) 掌握抽象工厂模式(Abstract Factory)的特点
2) 分析具体问题,使用抽象工厂模式进行设计。
【实验内容和要求】
麦当劳(McDonalds)和肯德基(KFC)快餐店都经营汉堡(Hamburg)和可乐(Cola),用C#控制台应用程序实现这两个快餐店经营产品的抽象工厂模式。绘制该模式的UML图。
【模式UML图】
【模式代码】
publicclass AbstractFactoryTest {
publicstaticvoid main(String[] args) {
Hamburg h;
Cola c;
AbstractFactory af=new MDNFactory();
h=af.createHamburg();
c=af.createCola();
h.getHumburg();
c.getCola();
af=new KDJFactory();
h=af.createHamburg();
c=af.createCola();
h.getHumburg();
c.getCola();
}
}
interface AbstractFactory{
Hamburg createHamburg();
Cola createCola();
}
class MDNFactory implements AbstractFactory {
@Override
public Hamburg createHamburg() {
returnnew MDNHamburg();
}
@Override
public Cola createCola() {
returnnew MDNCola();
}
}
class KDJFactory implements AbstractFactory{
@Override
public Hamburg createHamburg() {
returnnew KDJHamburg();
}
@Override
public Cola createCola() {
returnnew KDJCola();
}
}
/**
* kDJ &MDN
*/
interface Hamburg{
void getHumburg();
}
class MDNHamburg implements Hamburg{
@Override
publicvoid getHumburg() {
System.out.println("MDNHamburg");
}
}
class KDJHamburg implements Hamburg{
@Override
publicvoid getHumburg() {
// TODO Auto-generated method stub
System.out.println("KDJHamburg");
}
}
interface Cola{
void getCola();
}
class MDNCola implements Cola{
@Override
publicvoid getCola() {
System.out.println("MDNCola");
}
}
class KDJCola implements Cola{
@Override
publicvoid getCola() {
System.out.println("KDJCola");
}
}
【运行截图】
【实验小结】
抽象工厂模式主要适用于以下情况:
一系列要独立于它的产品的创建、组合和表示时。、
一个系统要由多个产品系列中的一个来配置时。
当要强调一系列相关的产品对象的设计以便进行联合使用时。
当要提供一个产品类库,而只要显示它们的接口而不是实现时。
实验三 适配器模式的应用
【实验目的】
1) 掌握适配器模式(Adapter)的特点
2) 分析具体问题,使用适配器模式进行设计。
【实验内容和要求】
一个软件团队开发绘图系统,设计了圆对象(Circle)、矩形对象(Rectangle),线对象(Line)都支持Draw()函数,即可以通过Draw()函数绘制图形。为了加快项目进度,将角度对象(Angle)绘制功能交给了合作团队实现。但合作团队将角度对象绘制函数定为了DrawAngle()。绘图系统提供给用户后,用户不满意,希望能统一的调用,不用记太多命令。应用适配器模式,用C#控制台应用程序完善该设计。绘制该模式的UML图。
【模式UML图】
【模式代码】
publicclass AdapterTest {
publicstaticvoid main(String[] args) {
Paint a=new AngleAdapter();
a.draw();
}
}
interface Paint{
void draw();
}
class Circle implements Paint{
@Override
publicvoid draw() {
System.out.println("圆圆");
}
}
class Rectangle implements Paint{
@Override
publicvoid draw() {
System.out.println("方方");
}
}
class Line implements Paint{
@Override
publicvoid draw() {
System.out.println("线线");
}
}
class Angle{
publicvoid DrawAngle(){
System.out.println("角度");
}
}
class AngleAdapter implements Paint{
private Angle a=new Angle();
@Override
publicvoid draw() {
// TODO Auto-generated method stub
a.DrawAngle();
}
}
【运行截图】
【实验小结】
适配器模式主要适用于以下情况:
当想要使用一个已经存在的类,但是该类的接口不符合现有的需求时。
当需要创建一个可以被复用的类,该类能够与其他无关的类甚至无法预见的类协同工作时。
当需要使用一个已经存在的子类,但是不可能对所有的都进行子类化以匹配他们的接口时,对象适配器可以对其父类接口进行适配。
实验四 桥接模式的应用
【实验目的】
1) 掌握桥接模式(Bridge)的特点
2) 分析具体问题,使用桥接模式进行设计。
【实验内容和要求】
一个咖啡店可以提供大杯(JorumCoffee)、中杯(MediumCoffee)、小杯(SmallCoffee)的咖啡(Coffee),为了满足不同用户的口味,在咖啡中可以添加牛奶(Milk),或者糖(Sugar),或者柠檬(Lemon),提供给用户不同口味的组合,如大杯咖啡加牛奶,中杯咖啡加糖,小杯咖啡加柠檬,小杯咖啡加糖等。应用桥接模式,用C#控制台应用程序实现该设计。绘制该模式的UML图。
【模式类图】
【模式代码】
package Constructor;
publicclass BridgeTest {
publicstaticvoid main(String[] args) {
Bridge b;
b=new Sugar();
b.setCoffee(new JorumCoffee());
b.getCoffee();
b=new Milk();
b.setCoffee(new SmallCoffee());
b.getCoffee();
}
}
interface Coffee{
void getCoffee();
}
class JorumCoffee implements Coffee{
@Override
publicvoid getCoffee() {
// TODO Auto-generated method stub
System.out.print("大杯咖啡");
}
}
class MediumCoffee implements Coffee{
@Override
publicvoid getCoffee() {
// TODO Auto-generated method stub
System.out.print("中杯咖啡");
}
}
class SmallCoffee implements Coffee{
@Override
publicvoid getCoffee() {
// TODO Auto-generated method stub
System.out.print("小杯咖啡");
}
}
/**
* 配料
*/
abstractclass Bridge{
protected Coffee c;
void setCoffee(Coffee co){
c=co;
}
publicvoid getCoffee(){
c.getCoffee();
}
}
class Sugar extends Bridge{
@Override
publicvoid getCoffee(){
c.getCoffee();
System.out.println("加糖");
}
}
class Milk extends Bridge{
@Override
publicvoid getCoffee(){
c.getCoffee();
System.out.println("加牛奶");
}
}
class Lemon extends Bridge{
@Override
publicvoid getCoffee(){
c.getCoffee();
System.out.println("加柠檬");
}
}
【运行截图】
【实验小结】
桥接模式的适用情况有:
当不希望在抽象和它的实现之间有一个固定的绑定关系时。
当类的抽象以及它的实现都应该可以通过生成子类的方法加以扩充时。
当对一个抽象类的实现部分的修改应对客户不产生影响时。
实验五 装饰模式的应用
【实验目的】
1) 掌握装饰模式(Decorator)的特点
2) 分析具体问题,使用装饰模式进行设计。
【实验内容和要求】
“喜羊羊逃命”游戏:喜羊羊被灰太狼追,喜羊羊最多5条命,灰太狼每咬到喜羊羊一次,喜羊羊就要少一条命。在逃的过程中喜羊羊可以吃到三种苹果,吃“红苹果”可以给喜羊羊加上保护罩,吃“绿苹果”可以加快喜羊羊奔跑速度,吃“黄苹果”可以使喜羊羊趟着水跑。应用装饰模式,用C#控制台应用程序实现该设计。绘制该模式的UML图。
提示:这个例子如果用类的继承来实现的话那可就麻烦了,你需要为喜羊羊派生3*2*1=6个子类(有保护罩的喜羊羊,奔跑速度加快的喜羊羊,会趟水的喜羊羊,既有保护罩又会趟水的喜羊羊,奔跑速度快且会趟水的喜羊羊,有保护罩且奔跑速度快的喜羊羊,有保护罩、奔跑速度快且会趟水的喜羊羊),如果使用装饰模式的那就不用派生诸多子类了,当喜羊羊每吃到一个苹果,我们就用装饰模式给喜羊羊加一个动态增加一个新功能即可。
【模式类图】
【模式代码】
publicclass DecoratorTest01 {
publicstaticvoid 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();
}
}
interface XiYangyang{
publicvoid Operation();
}
class ConcreteXiYY implements XiYangyang{
@Override
publicvoid Operation() {
// TODO Auto-generated method stub
System.out.println("喜羊羊");
}
}
abstractclass Decorator implements XiYangyang{
protected XiYangyang xyy;
publicvoid setXiYangyang(XiYangyang xyy){
this.xyy=xyy;
}
@Override
publicvoid Operation() {
// TODO Auto-generated method stub
xyy.Operation();
}
}
class ProtectXiYangyang extends Decorator {
@Override
publicvoid Operation() {
// TODO Auto-generated method stub
System.out.print(" 有保护罩的");
super.Operation();
}
}
class FastXiYangyang extends Decorator {
@Override
publicvoid Operation() {
// TODO Auto-generated method stub
System.out.print(" 加速的");
super.Operation();
}
}
class SwimingXiYangyang extends Decorator {
@Override
publicvoid Operation() {
// TODO Auto-generated method stub
System.out.print(" 会游泳的");
super.Operation();
}
}
【运行截图】
【实验小结】
装饰模式的适用情况有:
当需要以不影响其他对象为前提实现动态、透明地给单个对象添加职责时。
当需要将对象的某些职责进行撤销操作时。
当不能用生成子类的方法进行当前系统的扩充时。
实验六 代理模式的应用
【实验目的】
1) 掌握代理模式(Proxy)的特点
2) 分析具体问题,使用代理模式进行设计。
【实验内容和要求】
生产商(Factory)需要销售商品(Product),网上商城(E-Shop)提供了一个平台,可以帮助销售这些商品,获得更大的销量。当顾客(Custom)从网上商城选购商品的时候,实际是从生产商获得的商品。应用代理模式,用C#控制台应用程序改进该设计。绘制该模式的UML图。
【模式UML图】
【实验代码】
publicclass ProxyTest01 {
publicstaticvoid main(String[] args) {
// TODO Auto-generated method stub
E_shop es=new E_shop();
es.product();
}
}
abstractclass Product{
publicabstractvoid product();
}
class Factory extends Product{
@Override
publicvoid product() {
// TODO Auto-generated method stub
System.out.println("商品正在促销中,满一百减50.");
}
}
class E_shop extends Product{
private Factory factory;
public E_shop(){
factory=new Factory();
}
@Override
publicvoid product() {
// TODO Auto-generated method stub
factory.product();
}
}
【运行截图】
【实验小结】
代理模式的有以下几种适用情况:
当需要为一个对象在不同的地址空间提供局部的代表时。
当需要创建开销非常大的对象时。
当需要控制原始对象的访问时。
当需要再访问对象时执行一些附加操作时,比如通过代理对象计算访问实际对象的次数。
实验七 观察者模式的应用
【实验目的】
1) 掌握外观模式(Observer)的特点
2) 分析具体问题,使用外观模式进行设计。
【实验内容和要求】
网上商店中如果商品(product)在名称(name)、价格(price)等方面有变化,系统能自动通知会员,将是网上商店区别传统商店的一大特色。如何设计实现? 说明你所选择的设计模式,画出类关系图并指明各个类的角色。应用外观模式,用C#控制台应用程序改进该设计。绘制该模式的UML图。
【模式UML图】
【模式代码】
import java.util.ArrayList;
publicclass ObeserverTest {
publicstaticvoid 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元");
cs.Notify();
}
}
abstractclass Observer{
publicabstractvoid update();
}
class ConcreteObserver extends Observer{
private String name;
private String state;
private ConcreteSubject cs;
public ConcreteSubject getConcreteSubject(){
return cs;
}
publicvoid setConcreteSubject(ConcreteSubject cs){
this.cs=cs;
}
public ConcreteObserver(ConcreteSubject cs,String name){
this.cs=cs;
this.name=name;
}
@Override
publicvoid update() {
// TODO Auto-generated method stub
state=cs.getState();
System.out.println(name+"观察到的状态是:"+state);
}
}
abstractclass Subject{
private ArrayList<Observer> observers=new ArrayList<Observer>();
publicvoid Attach(Observer o){
observers.add(o);
}
publicvoid Detach(Observer o){
observers.remove(o);
}
//通知
publicvoid Notify(){
for (int i = 0; i < observers.size(); i++) {
observers.get(i).update();
}
}
}
class ConcreteSubject extends Subject{
private String state;
publicvoid setState(String state){
this.state=state;
}
public String getState(){
return state;
}
}
【运行截图】
【实验小结】
观察者模式的适用情况有:
当一个抽象模型有两个方面,而其中一个方面必须依赖于另一个方面时。
当对一个对象的改变需要同时改变其他对象但是却不知道具体有多少个对象等到改变时。
当一个对象必须通知其他对象但是却不能与其他对象造成紧密耦合时。
实验八 职责链模式的应用
【实验目的】
1) 掌握职责链模式(Chain of Responsibility)的特点
2) 分析具体问题,使用职责链模式进行设计。
【实验内容和要求】
高校学生请假需要符合学校规定,假如班主任可以批准1天假,系主任可以批准7天假,各学院院长可以批准30天,学校校长可以批准1年。应用职责链模式,用C#控制台应用程序实现该设计。绘制该模式的UML图。
【模式UML图】
【模式代码】
publicclass StudentClient {
publicstaticvoid 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{
protected Handler successor;
publicvoid setSuccessor(Handler successor){
this.successor=successor;
}
publicabstractvoid handleRequest(int request);
}
class FuDaoYuan extends Handler{
@Override
publicvoid handleRequest(int request) {
// TODO Auto-generated method stub
if(request<=1){
System.out.println(this.getClass().getSimpleName()+"处理了请求"+request);
}else{
if(this.successor!=null){
System.out.println(this.getClass().getSimpleName()+"自身无法满足请求,转入下一个处理者");
this.successor.handleRequest(request);
}
}
}
}
class XiZhuRen extends Handler{
@Override
publicvoid handleRequest(int request) {
// TODO Auto-generated method stub
if(request<=7){
System.out.println(this.getClass().getSimpleName()+"处理了请求"+request);
}else{
if(this.successor!=null){
System.out.println(this.getClass().getSimpleName()+"自身无法满足请求,转入下一个处理者");
this.successor.handleRequest(request);
}
}
}
}
class XueYuan extends Handler{
@Override
publicvoid handleRequest(int request) {
// TODO Auto-generated method stub
if(request<=9){
System.out.println(this.getClass().getSimpleName()+"处理了请求"+request);
}else{
if(this.successor!=null){
System.out.println(this.getClass().getSimpleName()+"自身无法满足请求,转入下一个处理者");
this.successor.handleRequest(request);
}
}
}
}
class XueXiao extends Handler{
@Override
publicvoid handleRequest(int request) {
// TODO Auto-generated method stub
if(request<=15){
System.out.println(this.getClass().getSimpleName()+"处理了请求"+request);
}else{
System.out.println("该生请假时间太长,不能批准");
}
}
}
【运行截图】
FuDaoYuan处理了请求1
FuDaoYuan自身无法满足请求,转入下一个处理者
XiZhuRen处理了请求3
FuDaoYuan自身无法满足请求,转入下一个处理者
XiZhuRen处理了请求5
FuDaoYuan自身无法满足请求,转入下一个处理者
XiZhuRen处理了请求7
FuDaoYuan自身无法满足请求,转入下一个处理者
XiZhuRen自身无法满足请求,转入下一个处理者
XueYuan处理了请求9
FuDaoYuan自身无法满足请求,转入下一个处理者
XiZhuRen自身无法满足请求,转入下一个处理者
XueYuan自身无法满足请求,转入下一个处理者
XueXiao处理了请求11
FuDaoYuan自身无法满足请求,转入下一个处理者
XiZhuRen自身无法满足请求,转入下一个处理者
XueYuan自身无法满足请求,转入下一个处理者
XueXiao处理了请求13
FuDaoYuan自身无法满足请求,转入下一个处理者
XiZhuRen自身无法满足请求,转入下一个处理者
XueYuan自身无法满足请求,转入下一个处理者
XueXiao处理了请求15
FuDaoYuan自身无法满足请求,转入下一个处理者
XiZhuRen自身无法满足请求,转入下一个处理者
XueYuan自身无法满足请求,转入下一个处理者
该生请假时间太长,不能批准
FuDaoYuan自身无法满足请求,转入下一个处理者
XiZhuRen自身无法满足请求,转入下一个处理者
XueYuan自身无法满足请求,转入下一个处理者
该生请假时间太长,不能批准
【实验小结】
职责链模式主要适用于以下情况:
当有多个对象可以处理同一个请求,而具体哪个对象来处理这个请求在运行时刻需要自动判定时。
当需要在不明确接受者的情况下向多个对象中的某一个提交请求时。
当处理一个请求的对象集合应该动态地被确定时。
实验九 访问者模式的应用
【实验目的】
1) 掌握访问者模式(Visitor)的特点
2) 分析具体问题,使用访问者模式进行设计。
【实验内容和要求】
超市中有两类商品,苹果(Apple)和巧克力(Chocolate),顾客(Custom)将所选商品放在购物车中(Shopping Cart),然后到收银员(Cashier)处付款。在购物过程中,顾客需要对这些商品进行访问,以便确认这些商品的质量,之后收银员也需要访问购物车内的商品,以便计算价格。应用访问者模式,用C#控制台应用程序实现该设计。绘制该模式的UML图。
【模式UML图】
【模式代码】
import java.util.ArrayList;
import java.util.List;
public class ShoppingTest {
/**
* @param args
*/
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);
}
}
abstract class PersonVisitor{
public abstract void visitorApple(Apple apple);
public abstract void visitorChocolate(Chocolate chocolate);
}
class Customer extends PersonVisitor{
@Override
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());
}
}
class Cashier extends PersonVisitor{
@Override
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{
protected String name;
public Shop(String name){
this.name=name;
}
public abstract void accpet(PersonVisitor pv);
public String getName(){
return name;
}
}
class Apple extends Shop{
public Apple(String name) {
super(name);
// TODO Auto-generated constructor stub
}
@Override
public void accpet(PersonVisitor pv) {
// TODO Auto-generated method stub
pv.visitorApple(this);
}
}
class Chocolate extends Shop{
public Chocolate(String name) {
super(name);
// TODO Auto-generated constructor stub
}
@Override
public void accpet(PersonVisitor pv) {
// TODO Auto-generated method stub
pv.visitorChocolate(this);
}
}
class ShoppingCart{
List<Shop> shops=new ArrayList<Shop>();
public void Attach(Shop shop){
shops.add(shop);
}
public void Detach(Shop shop){
shops.remove(shop);
}
public void accept(PersonVisitor visitor){
for (int i = 0; i < shops.size(); i++) {
shops.get(i).accpet(visitor);
}
}
}
【运行截图】
【实验小结】
访问者模式主要有以下几种适用情况:
当一个对象结构包含有很多类对象,但是他们又不同的接口,并且开发人员希望对这些对象实施一些依赖于具体类的操作时。
当需要对一个对象结构中的对象进行很多不同的并且不相关的操作时。
当该对象结构被很多应用共享时。
实验十 备忘录模式的应用
【实验目的】
1) 掌握备忘录模式(Memento)的特点
2) 分析具体问题,使用备忘录模式进行设计。
【实验内容和要求】
Window系统可能会异常终止,设计一个系统备份程序。类WindowsSystem是发起人角色(Orignation),类Memento是备忘录角色(Memento),类User是备忘录管理角色(Caretaker)。应用备忘录模式,用C#控制台应用程序实现该设计。绘制该模式的UML图。
【模式UML图】
【模式代码】
publicclass WindowsMemento {
publicstaticvoid main(String[] args) {
// TODO Auto-generated method stub
WindowsSystem ws=new WindowsSystem();
ws.setState("开机正常工作");
ws.show();
User u=new User();
u.setMementoWindows(ws.createMementoWindows());
ws.setState("系统崩了啊!");
ws.show();
System.out.println("对系统进行恢复......10s");
ws.setMementoWindows(u.getMementoWindows());
ws.show();
}
}
//备忘录类
class MementoWindows{
private String state;
public MementoWindows(String state){
this.state=state;
}
//获取状态
public String getState(){
return state;
}
}
class WindowsSystem{
private String state;
//建立状态存储对象
public MementoWindows createMementoWindows() {
returnnew MementoWindows(state);
}
//设置状态存储对象
publicvoid setMementoWindows(MementoWindows mementoWindows){
state=mementoWindows.getState();
}
//展现状态
publicvoid show(){
System.out.println("状态为:"+state);
}
//获取状态
public String getState(){
return state;
}
//设置状态
publicvoid setState(String state){
this.state=state;
}
}
class User{
private MementoWindows mementoWindows;
//设定备忘
publicvoid setMementoWindows(MementoWindows mementoWindows){
this.mementoWindows=mementoWindows;
}
//获取备忘
public MementoWindows getMementoWindows(){
return mementoWindows;
}
}
【运行截图】
【实验小结】
备忘录模式有以下几种适用情况:
当必须保存一个对象在某一时刻的全部或部分状态以便在需要时可以将其回复到先前的状态时。
当使用接口让其他对象直接得到自己的状态会暴露对象的实现细节、继而破坏其封装性。