本文接着介绍11种行为型模式里的备忘录模式、观察者模式、状态模式。

一、备忘录模式

在不破坏封装性的前提下,捕获一个对象的内部状态。并在该对象之外保存这个状态。这样以后就能够将该对象恢复到原先保存的状态。还是比較好理解的。

1.Memento 备忘录存储原发器对象的内部状态,这个类就是要存储的对象的状态。状态须要多少个变量,在Memento里就写多少个变量。

public class Memento {

private String state;

public Meme*to(String state) {
        this.state = state;
    }

public String getState() {
        *eturn state;
    }

public void setSt*te(String state) {
        this.state = state;
    }

}

2.Originator原发器创建一个备忘录,用以记录当前时刻*的内部状态。

使用备忘录恢复内部状态.

public class Originator {

private String state;

public String getState() {
        return state;
    }

public void setState(String state) {
        this.state = state;
    }
    
    *ublic Memento createMemento() {
        return new Memento(state);
    }
    
    p*blic void setMemento(Memento meme*to) {
        state = memento.ge*State();
    }
    
    p*blic void showState(){
        System.out.println(state);
    }
}

3.Caretaker 负责保存好备忘录。不能对备忘录的内*进行操作或检查。

public class Caretaker {
    
    p*ivate Memento memento;
    
    public Memento getMemento(){
        return this.memento;
    }
    
    public void setMemento(Memento memento){
        this.memento = memento;
    }
}

測试代码:

public class Test {
 
    public static void main(String[] args) {
        Originator org = *ew Originator();
        org*setState("开会中");
        
        C*retaker ctk = new Ca*etaker();
        ctk.setMemento(org.createMemento());//将数据封装在Caretaker
        
        or*.setState("睡觉中");
        org.sh*wState();*/显示
        
        org.setMemento(ctk.getMemento());//将数据又一次导入
        or*.showState();
    }
}

适用性:

1.必须*存一个对象在某一个时刻的(部分)状态,这样以后须要时它才干恢复到先前的状态。

2.假设一个用接口来让其他对象直接得到这些状态,将会暴露对象的实现细节并破坏对象的封装性。

參考链接:http://blog.sina.com.cn/s/blog_3d43347c0100bkm1.html

二、观察者模式

定义对象间的一种一对多的依赖关系,当一个对象的状态发生改变时。全部依赖于它的对象都得到通知并被自己主动更新。这样的模式用途非常多。

1.Subject(目标) 也就是负责管理属于他的观察者,比方一个排长十个手下。

这个排长就是subject.提供注冊和删除观察者对象的接口。

public abstract class Citizen {
    
    List po*s;
    
    String help = "normal";
    
    public void setHelp(String help) {
        this.help = *elp;
    }
    
    public String getHelp() {
        return this.help;
    }
    
    abstract void sendMessage(String help);

public void setPolicemen() {
        t*is.pols = new ArrayList();
    }
    
    public void register(*oliceman pol) {
        this.pols.add(pol);
    }

public void unRegister(Policeman pol) {
        this.pols.remove(pol);
    }
}

2.Obser*er(观察者)为那些在目标发生改变时需获得*知的对象定义一个更新*口。

public interface Policeman {

void action(Citizen ci);
}

3.ConcreteSubject(详细目标) 将有关状态存入各ConcreteObserver对象。当它的状态发生改变时,向它的各个观察者发出通知。

public class Hua*gPuCitizen extends Citiz*n {
 
    public HuangPuCitizen(P*liceman pol) {
        setPolicemen();
        register*pol);
    }
    
    public void sendMessage(String help) {
        setHelp(h*lp);
        for(int i = 0; i < pols.size(); i++) {
            Policeman pol = pols.get(i);
            //通知警察行动
            pol.action(this);
        }
    }
}

public class TianHeCitizen extends Citizen {

public TianHeCitizen(Policeman pol) {
        setPolicemen();
        re*ister(pol);
    }
    
    public void sendM*ssage(Str*ng help) {
        setHelp(help);
        for (i*t i = 0; i < pols.size(); i++) {
            Policeman pol = pols.get(i);
            //通知警察行动
            pol.action(this);
        }
    }
}

4.ConcreteObserver(详细观察者)维护一个指向ConcreteSubject对象的引用。

存储有关状态,这些状态应与目标的状态保持一致。实现Observer的更新接口*使自身状态与目标的状态保持一致.

public clas* HuangPuPoliceman implements Pol*ceman {

public void action(Citizen ci) {
        String help = ci.getHelp();
        if (help.equals("normal")) {
            System.o*t.println("一切正常, 不用出动");
        }
        if (help.*quals("unnormal")) *
            System.out.println("有犯罪行为, 黄埔警察出动!");
        }
    }
}

public c*ass TianHePoliceman implements Policem*n {

public void action(Citizen ci) {
        String help = *i.getHelp();
        if (help.equals("*ormal")) {
            System.out.println("一切正常, 不用出动");
        *
        if (help.equals("unnormal")) {
            System.out.println("有犯罪行为, 天河警察出动!");
        }
    }
}

測试代码:

public class Test{

public st*tic void main(String[] args) {
        Policeman thPol = new TianHePoliceman();
        Pol*ceman hpPol = new HuangPuPoliceman();
        
        Ci*izen citizen = new HuangPuCitizen(hpPol);
        citizen.sendMessage("unnormal");
        citizen.sendMessage("normal");
        
        System.out.println("===========");
        
        citizen = new TianH*Citizen(thPol);
        citizen.sendMessage("normal");
        citi*en.sendMessage("unnormal");
    }
}

有犯罪行为, 黄埔警察出动!
一切正常, 不用出动
======*====
一切正常, 不用出动
有犯罪行为, 天河警察出动!

适用性:

1.当一个抽象模型有两个方面,当中一个方面依赖于还有一方面。

将这二者封装*独立的对象中以使它们能够各自独立地改变和复用。
    2.当对一个对象的改变须要同一时候改变其他对象,而不知道详细*多少对象有待改变。
    3.当一个对象必须通知其他对象。而它又不能假定其他对象是谁。

观察者模式极其重要。很多其他可參考:http://www.iteye.com/topic/102068/

三、状态模式(State Pattern)

当一个对象的内在状态改变时同意改变其行为,这个对象看起来像是改变了其类。

状态模式主要解决的是当控制一个对象状态的条件表达式过于复杂时的情况。把状态的推断逻辑转移到表示不同状态的一系列类中,能够把复杂的推断逻辑简化。

一个简单的样例參见链接:http://www.cnblogs.com/BenWong/archive/2012/12/12/2813982.html

以下上个复杂的样例:

1.Context定义客户感兴趣的接口。维护一个ConcreteState子类的实例,这个实例定义当前状态。

pu*lic class Context {

private Weather weather;

public voi* setWeather(Weather weather) {
        this.*eather = weather;
    }

pu*lic Weather getWeather() {
        return this.weather;
    }

public String weatherMessage() {
        return w*ather.getWeather();
    }
}

2.State定义一个接口以封装与Context的一个特定状态相关的行为。

public interface Weath*r {

String getWeather();
}

3.ConcreteStatesubclasses每一子类实现一个与Context的一个状态*关的行为。

public class Rain implements Weather {

public Stri*g getWeather() {
        return "下雨";
    }
*

public class Sunshine implements Weather {

public Str*ng getWeather() {
        return "阳光";
    }
}

測试代码:

public class Test{

public static void main(String[] args) {
        Context ctx1 = new Context();
        ctx1.setWeather(new Sunshine());
        System.out.println(*tx1.weatherMessage());

System.*ut.println("===============");

Context ctx2 = new Context();
        ctx2.setWeather(new Rain());
        S*stem.out.println(ctx2.weatherMessage());
    }
}
result

阳光
===============
下雨

适用性:

1.一个对象的行为取决于它的状态,而且它必须在执行时刻依据状态改*它的行为。
2.一个操作中含有庞大的多分支的条件语句,且这些分支依赖于该对象的状态。

这个状态通经常使用一个或多个枚举常量表示。通常,有多个操作包括这一同样的条件结构。State模式将每个条件分支放入一个独立的类中。这使得你能够依据对象自身的情况将对象的状态作为一个对象,这一对象能够不依赖于其他对象而独立变化。

參考链接:http://dev.yesky.com/438/2164938.shtml

Java经典23种设计模式之行为型模式(三)的更多相关文章

  1. Java经典23种设计模式之行为型模式(二)

    本文接着介绍行为型模式里的解释器模式.迭代器模式.中介者模式. 一.解释器模式Interpret 给定一个语言,定义它的文法的一种表示,并定义一个解释器,这个解释器使用该表示来解释语言的中的句子. 1 ...

  2. Java经典23种设计模式之结构型模式(一)

    结构型模式包含7种:适配器模式.桥接模式.组合模式.装饰模式.外观模式.享元模式.代理模式. 本文主要介绍适配器模式和桥接模式. 一.适配器模式(Adapter) 适配器模式事实上非常easy.就像手 ...

  3. Java经典23种设计模式之创造型模式(一)

    设计模式被称为程序猿的内功,之前零零散散的看过一大部分,但自己么有总结过.故此次在这里总结下.值得一提的是,设计模式并不是Java所特有.由于一直搞Android.这里就用Java为载体.最经典的设计 ...

  4. GoF的23种设计模式之创建型模式的特点和分类

    创建型模式的主要关注点是“怎样创建对象?”,它的主要特点是“将对象的创建与使用分离”.这样可以降低系统的耦合度,使用者不需要关注对象的创建细节,对象的创建由相关的工厂来完成.就像我们去商场购买商品时, ...

  5. GoF的23种设计模式之行为型模式的特点和分类(2)

    行为型模式用于描述程序在运行时复杂的流程控制,即描述多个类或对象之间怎样相互协作共同完成单个对象都无法单独完成的任务,它涉及算法与对象间职责的分配. 行为型模式分为类行为模式和对象行为模式,前者采用继 ...

  6. GoF的23种设计模式之行为型模式的特点和分类(1)

    行为型模式用于描述程序在运行时复杂的流程控制,即描述多个类或对象之间怎样相互协作共同完成单个对象都无法单独完成的任务,它涉及算法与对象间职责的分配. 行为型模式分为类行为模式和对象行为模式,前者采用继 ...

  7. Java的23种设计模式,详细讲解(三)

    本人免费整理了Java高级资料,涵盖了Java.Redis.MongoDB.MySQL.Zookeeper.Spring Cloud.Dubbo高并发分布式等教程,一共30G,需要自己领取.传送门:h ...

  8. Java中23种设计模式(附代码样例)

    一.设计模式分类总体来说设计模式分为三大类:创建型模式,共五种:工厂方法模式.抽象工厂模式.单例模式.建造者模式.原型模式.结构型模式,共七种:适配器模式.装饰器模式.代理模式.外观模式.桥接模式.组 ...

  9. 从追MM谈Java的23种设计模式(转)

    从追MM谈Java的23种设计模式    这个是从某个文章转载过来的.但是忘了原文链接.如果知道的,我追加一下. 1.FACTORY-追MM少不了请吃饭了,麦当劳的鸡翅和肯德基的鸡翅都是MM爱吃的东西 ...

随机推荐

  1. 洛谷P3950 部落冲突 [LCT]

    题目传送门 部落冲突 格式难调,体面就不放了. 分析: julao们应该都看得出来就是个$LCT$板子,战争就$cut$,结束就$link$,询问就$find$.没了... 太久没打$LCT$,然后发 ...

  2. Java 打开文件夹

    package com.swing.demo; import java.io.File; import java.io.IOException; public class OpenDirTest { ...

  3. Xcode代码提示里的字母含义

    P -- 协议 M -- 成员方法 C -- 类 K -- 枚举 .常量 V -- 成员变量 T -- typedef类型 G -- 全局变量 f -- 函数 # -- #define指令

  4. NOIP 2018 提高组初赛解题报告

    单项选择题: D 进制转换题,送分: D 计算机常识题,Python是解释运行的: B 常识题,1984年小平爷爷曰:“娃娃抓起”: A 数据结构常识题,带进去两个数据就可以选出来: D 历年真题没有 ...

  5. java switch

    韩梦飞沙  韩亚飞  313134555@qq.com  yue31313  han_meng_fei_sha switch 是 开关:转换 的意思. 支持的数据类型 有 : 字节,字符,短整型,整型 ...

  6. js之iframe父、子页面通信

    注意事项 一 . 页面加载顺序:一般先加载完父页面才会去加载子页面,所以:必须要确保在iframe加载完成后再进行操作,如果iframe还未加载完成就开始调用里面的方法或变量,会产生错误.判断ifra ...

  7. 感觉比较好一些的vultr中文网

    搜索一波vultr的中文网,发现很多,基本上都是靠活动以及一些SS的教程维持,全都是大同小异,感觉比较有可比性估计一下这个: https://www.thevultr.org/ 可以对比一些美国常用V ...

  8. 更新yum源/apt-get源

    国内开源镜像站有:网易: http://mirrors.163.com/ 搜狐: http://mirrors.sohu.com/阿里云: http://mirrors.aliyun.com/北京理工 ...

  9. <摘录>linux文件IO

    这篇文章写的比较全面,也浅显易懂,备份下.转载自:http://blog.chinaunix.net/uid-27105712-id-3270102.html 在Linux 开发中,有几个关系到性能的 ...

  10. apache 与 iis共存

    先装上了apache ,再装iis会出现错误.所以先关闭apache,再进行iis安装.iis安装完后修改iis80端口为8080端口, 同时使用命令 cd C:\Inetpub\AdminScrip ...