设计模式大类--行为模式(中)

四、Chain of
Responsibility(责任链)
描述:一系列类(classes)试图处理一个请求request,这些类之间是一个松散的耦合,唯一共同点是在他们之间传递request.
也就是说,来了一个请求,A类先处理,如果没有处理,就传递到B类处理,如果没有处理,就传递到C类处理,就这样象一个链条(chain)一样传递下去
好处:降低了类之间的耦合性

例子:
抽象处理者角色
public abstract class Handler {

/**
*
持有后继的责任对象
*/
protected Handler successor;
/**
*
示意处理请求的方法,虽然这个示意方法是没有传入参数的
* 但实际是可以传入参数的,根据具体需要来选择是否传递参数
*/
public
abstract void handleRequest();
/**
* 取值方法
*/
public Handler
getSuccessor() {
return successor;
}
/**
*
赋值方法,设置后继的责任对象
*/
public void setSuccessor(Handler successor) {

this.successor = successor;
}

}

  具体处理者角色
public class ConcreteHandler extends Handler {
/**

* 处理方法,调用此方法处理请求
*/
@Override
public void handleRequest()
{
/**
* 判断是否有后继的责任对象
* 如果有,就转发请求给后继的责任对象
*
如果没有,则处理请求
*/
if(getSuccessor() != null)
{

System.out.println("放过请求");
getSuccessor().handleRequest();

}else
{

System.out.println("处理请求");
}
}

}

  客户端类
public class Client {

public static void main(String[] args) {
//组装责任链
Handler
handler1 = new ConcreteHandler();
Handler handler2 = new
ConcreteHandler();
handler1.setSuccessor(handler2);

//提交请求
handler1.handleRequest();
}

}
  可以看出,客户端创建了两个处理者对象,并指定第一个处理者对象的下家是第二个处理者对象,而第二个处理者对象没有下家。然后客户端将请求传递给第一个处理者对象。
  由于本示例的传递逻辑非常简单:只要有下家,就传给下家处理;如果没有下家,就自行处理。因此,第一个处理者对象接到请求后,会将请求传递给第二个处理者对象。由于第二个处理者对象没有下家,于是自行处理请求。

五、Command(命令模式)
描述:对命令进行封装,将发出命令的责任和执行命令的责任分割开
好处:面向接口编程、能实现Undo功能。

例子:
典型的Command模式需要有一个接口.接口中有一个统一的方法,这就是"将命令/请求封装为对象":

public interface Command {
  public abstract void execute ( );
}

具体不同命令/请求代码是实现接口Command,下面有三个具体命令

public class Engineer implements Command {

  public void execute( ) {
    //do Engineer‘s command
  }
}

public class Programmer implements Command {

  public void execute( ) {
    //do programmer‘s command
  }
}

public class Politician implements Command {

  public void execute( ) {
    //do Politician‘s command
  }
}

按照通常做法,我们就可以直接调用这三个Command,但是使用Command模式,我们要将他们封装起来,扔到黑盒子List里去:

public class producer{
  public static List produceRequests()
{
    List queue = new ArrayList();
    queue.add( new DomesticEngineer()
);
    queue.add( new Politician() );
    queue.add( new Programmer()
);
    return queue;
  }

}

这三个命令进入List中后,已经失去了其外表特征,以后再取出,也可能无法分辨出谁是Engineer
谁是Programmer了,看下面如何调用Command模式:

public class TestCommand {
  public static void main(String[] args)
{
    
    List queue = Producer.produceRequests();
    for (Iterator
it = queue.iterator(); it.hasNext();
)
        //取出List中东东,其他特征都不能确定,只能保证一个特征是100%正确,
        //
他们至少是接口Command的"儿子".所以强制转换类型为接口Command

        ((Command)it.next()).execute();
  

  }
}

由此可见,调用者基本只和接口打交道,不合具体实现交互,这也体现了一个原则,面向接口编程,这样,以后增加第四个具体命令时,就不必修改调用者TestCommand中的代码了.

六、State(状态模式)
描述:不同的状态,不同的行为;或者说,每个状态有着相应的行为
优点:封装转换过程,也就是转换规则、枚举可能的状态,因此,需要事先确定状态种类。

例子:
请看下例:

public class Context{

  private Color state=null;

  public void push(){

    //如果当前red状态 就切换到blue
    if (state==Color.red) state=Color.blue;

    //如果当前blue状态 就切换到green
    else if (state==Color.blue)
state=Color.green;

    //如果当前black状态 就切换到red
    else if (state==Color.black)
state=Color.red;

    //如果当前green状态 就切换到black
    else if (state==Color.green)
state=Color.black;
    
    Sample sample=new
Sample(state);
    sample.operate();
  }

  public void pull(){

    //与push状态切换正好相反

    if (state==Color.green) state=Color.blue;
    else if
(state==Color.black) state=Color.green;
    else if (state==Color.blue)
state=Color.red;
    else if (state==Color.red) state=Color.black;

    Sample2 sample2=new Sample2(state);
    sample2.operate();
  }

}

在上例中,我们有两个动作push推和pull拉,这两个开关动作,改变了Context颜色,至此,我们就需要使用State模式优化它.

另外注意:但就上例,state的变化,只是简单的颜色赋值,这个具体行为是很简单的,State适合巨大的具体行为,因此在,就本例,实际使用中也不一定非要使用State模式,这会增加子类的数目,简单的变复杂.

例如: 银行帐户, 经常会在Open 状态和Close状态间转换.

例如: 经典的TcpConnection, Tcp的状态有创建 侦听 关闭三个,并且反复转换,其创建 侦听
关闭的具体行为不是简单一两句就能完成的,适合使用State

例如:信箱POP帐号, 会有四种状态, start HaveUsername Authorized
quit,每个状态对应的行为应该是比较大的.适合使用State

例如:在工具箱挑选不同工具,可以看成在不同工具中切换,适合使用State.如 具体绘图程序,用户可以选择不同工具绘制方框 直线
曲线,这种状态切换可以使用State.

如何使用
State需要两种类型实体参与:

1.state manager 状态管理器 ,就是开关 ,如上面例子的Context实际就是一个state manager, 在state
manager中有对状态的切换动作.
2.用抽象类或接口实现的父类,,不同状态就是继承这个父类的不同子类.

以上面的Context为例.我们要修改它,建立两个类型的实体.
第一步: 首先建立一个父类:

public abstract class State{

  public abstract void handlepush(Context c);
  public abstract void
handlepull(Context c);
  public abstract void getcolor();

}

父类中的方法要对应state manager中的开关行为,在state manager中
本例就是Context中,有两个开关动作push推和pull拉.那么在状态父类中就要有具体处理这两个动作:handlepush() handlepull();
同时还需要一个获取push或pull结果的方法getcolor()

下面是具体子类的实现:

public class BlueState extends State{

  public void handlepush(Context c){
     //根据push方法"如果是blue状态的切换到green"
;
     c.setState(new GreenState());

  }
  public void handlepull(Context c){

     //根据pull方法"如果是blue状态的切换到red" ;
    c.setState(new RedState());

  }

  public abstract void getcolor(){ return (Color.blue)}

}

同样 其他状态的子类实现如blue一样.

第二步: 要重新改写State manager 也就是本例的Context:

public class Context{

  private Sate state=null; //我们将原来的 Color state 改成了新建的State state;

  //setState是用来改变state的状态 使用setState实现状态的切换
  pulic void setState(State
state){

    this.state=state;

  }

  public void push(){

    //状态的切换的细节部分,在本例中是颜色的变化,已经封装在子类的handlepush中实现,这里无需关心
    state.handlepush(this);
    
    //因为sample要使用state中的一个切换结果,使用getColor()
    Sample
sample=new Sample(state.getColor());
    sample.operate();

  }

  public void pull(){

    state.handlepull(this);
    
    Sample2 sample2=new
Sample2(state.getColor());
    sample2.operate();

  }

}

至此,我们也就实现了State的refactorying过程

时间: 2024-10-11 10:42:04

设计模式大类--行为模式(中)的相关文章

设计模式大类--行为模式(上)

大概有10中行为模式,分为上中下三篇.一.Template(模板)描述:定义一些操作算法的骨架,将其实现延迟到其子类好处:扩展性强 例子:Java的抽象类本来就是Template模式,因此使用很普遍.而且很容易理解和使用,我们直接以示例开始: public abstract class Benchmark{ /** * 下面操作是我们希望在子类中完成 */ public abstract void benchmark(); /** * 重复执行benchmark次数 */ public fina

设计模式大类--结构模式(上)

大概有7中结构模式,分为上下两篇.一.Adapter(适配器)描述:将两个不兼容的类结合一起使用,一般需要用到其中某个类的若干方法好处:在两个类直接创建一个混合接口,而不必修改类里面的其他代码 例子:假设我们要打桩,有两种类:方形桩 圆形桩.public class SquarePeg{ public void insert(String str){ System.out.println("SquarePeg insert():"+str); } } public class Roun

设计模式大类--结构模式(下)

五.Decorate(装饰者)描述:动态的给一个对象添加额外的职责,比继承达到更好的灵活性好处:某些功能需要用户动态决定加入方式和时机,装饰者提供即插即用的模型 例子:举Adapter中的打桩示例,在Adapter中有两种类:方形桩 圆形桩,Adapter模式展示如何综合使用这两个类,在Decorator模式中,我们是要在打桩时增加一些额外功能,比如,挖坑 在桩上钉木板等,不关心如何使用两个不相关的类我们先建立一个接口:public interface Work{ public void ins

设计模式大类--行为模式(下)

七.Strategy(策略模式)描述:定义了一系列的算法,将每一种算法封装起来并可以相互替换使用,策略模式让算法独立于使用它的客户应用而独立变化.优点:各个部分之间是弱连接 的关系,弱连接的特性使软件具有更强的可扩展性 ,易于维护 :更重要的是,它大大提高了软件可重用性 . 例子:举例(TreeSet .TreeMap就是很好的例子 )public class Test { /*客户端*/ public static void main(String[] args) { //面向接口 Strat

[设计模式](转)Java中的24种设计模式与7大原则

*:first-child { margin-top: 0 !important; } body > *:last-child { margin-bottom: 0 !important; } a { color: #4183C4; text-decoration: none; } a.absent { color: #cc0000; } a.anchor { display: block; padding-left: 30px; margin-left: -30px; cursor: poin

设计模式 ( 十九 ) 模板方法模式Template method(类行为型)

1.概述 在面向对象开发过程中,通常我们会遇到这样的一个问题:我们知道一个算法所需的关键步骤,并确定了这些步骤的执行顺序.但是某些步骤的具体实现是未知的,或者说某些步骤的实现与具体的环境相关.例子1:银行业务办理流程在银行办理业务时,一般都包含几个基本固定步骤:取号排队->办理具体业务->对银行工作人员进行评分.取号取号排队和对银行工作人员进行评分业务逻辑是一样的.但是办理具体业务是个不相同的,具体业务可能取款.存款或者转账. 2.问题 如何保证架构逻辑的正常执行,而不被子类破坏 ? 3.解决

设计模式在实际业务应用中的介绍之1——抽象工厂模式实现对数据库访问组件的封装

设计模式在实际业务应用中的介绍之1--抽象工厂模式实现对数据库访问组件的封装 基于C#打造的通用数据库访问组件 基于C#打造的通用数据库访问组件,完全支持开闭原则,设计上支持可扩展支持任意主流数据库,目前组件只实现了Oracle.MS SQL.MySQL三种库. 该组件实现简单.架构清晰,目前组件只包括5个类文件,兼容了三种数据库,组件实现采用了单例模式.工厂模式. 获取组件源码请入QQ群706224870,在群文件中下载.入群验证信息:codefc 下面简单描述下实现思路: 5个类文件如下:D

Spring中的设计模式:工厂方法模式

导读 工厂方法模式是所有设计模式中比较常用的一种模式,但是真正能搞懂用好的少之又少,Spring底层大量的使用该设计模式来进行封装,以致开发者阅读源代码的时候晕头转向. 文章首发于微信公众号[码猿技术专栏],原创不易,谢谢支持!!! 今天陈某分别从以下五个方面详细讲述一下工厂方法模式: 「从什么是工厂方法模式」 「通用框架实现」 「工厂方法模式的优点」 「工厂方法模式的升级」 「Spring底层如何使用工厂方法模式」 什么是工厂方法模式? 定义:定义一个用于创建对象的 接口,让子类决定实例化哪一

设计模式4 结构型模式

设计模式4  结构型模式 目录 代理模式 装饰器 外观模式 适配器模式 代理模式,美国,韩国代理购物 [email protected]:~$ cat main.cpp  #include<iostream> using namespace std; class Item //商品 { public: Item(string kind ,bool fact) { this->kind = kind; this->fact = fact; } string getKind() { r