行为型模式,共十一种:策略模式、模板方法模式、观察者模式、迭代子模式、责任链模式、命令模式、备忘录模式、状态模式、访问者模式、中介者模式、解释器模式。

看看这11中模式的关系,大致可分为四类:(1) 通过父类与子类的关系进行实现。(2) 两个类之间。(3) 类的状态。(4) 通过中间类。

  

C1、父类子类关系

C1.1、策略模式(strategy)

  该模式它定义了算法家族,分别封装起来,让它们之间可以互相替换,此模式让算法的变化,不会影响到使用算法的客户。

  

  [1] 定义 Strategy 抽象类,定义所有支持的算法的公共接口。

    public abstract class Strategy
{
public abstract void Algorithmlnterface();
}

  [2] ConcreteStrategy ,封装了具体的算法或行为,继承于Strategy。

    public class ConcreteStrategyA:Strategy
{
public override void Algorithmlnterface()
{
Console.WriteLine("算法A实现!");
}
} public class ConcreteStrategyB:Strategy
{
public override void Algorithmlnterface()
{
Console.WriteLine("算法B实现!");
}
}

  [3]Context,用一个 ConcreteStrategy 来配置,维护一个对 Strategy 对象的引用。

    public class Context
{
Strategy strategy; public Context(Strategy strategy)
{
this.strategy = strategy;
} public void ContextInterface()
{
strategy.Algorithmlnterface();
}
}

  [4] 客户端调用

        static void Main(string[] args)
{
Context context;
context = new Context(new ConcreteStrategyA());
context.ContextInterface(); context = new Context(new ConcreteStrategyB());
context.ContextInterface(); Console.Read();
}

  策略模式的决定权在用户,系统本身提供不同算法的实现,新增或者删除算法,对各种算法做封装。因此,策略模式多用在算法决策系统中,外部用户只需要决定用哪个算法即可。

C1.2、模板方法模式(Template Method)

  定义一个操作中的算法的骨架,而将一些步骤延迟到子类中。模板方法使得 子类可以不改变一个算法的结构即可重定义该算法的某些特定步骤。

  解释:一个抽象类中,有一个主方法,再定义1...n个方法,可以是抽象的,也可以是实际的方法,定义一个类,继承该抽象类,重写抽象方法,通过调用抽象类,实现对子类的调用,先看个关系图:

就是在AbstractCalculator类中定义一个主方法calculate,calculate()调用spilt()等,Plus和Minus分别继承AbstractCalculator类,通过对AbstractCalculator的调用实现对子类的调用,看下面的例子:

  1. public abstract class AbstractCalculator {
  2. /*主方法,实现对本类其它方法的调用*/
  3. public final int calculate(String exp,String opt){
  4. int array[] = split(exp,opt);
  5. return calculate(array[0],array[1]);
  6. }
  7. /*被子类重写的方法*/
  8. abstract public int calculate(int num1,int num2);
  9. public int[] split(String exp,String opt){
  10. String array[] = exp.split(opt);
  11. int arrayInt[] = new int[2];
  12. arrayInt[0] = Integer.parseInt(array[0]);
  13. arrayInt[1] = Integer.parseInt(array[1]);
  14. return arrayInt;
  15. }
  16. }
  1. public class Plus extends AbstractCalculator {
  2. @Override
  3. public int calculate(int num1,int num2) {
  4. return num1 + num2;
  5. }
  6. }

测试类:

  1. public class StrategyTest {
  2. public static void main(String[] args) {
  3. String exp = "8+8";
  4. AbstractCalculator cal = new Plus();
  5. int result = cal.calculate(exp, "\\+");
  6. System.out.println(result);
  7. }
  8. }

我跟踪下这个小程序的执行过程:首先将exp和"\\+"做参数,调用AbstractCalculator类里的calculate(String,String)方法,在calculate(String,String)里调用同类的split(),之后再调用calculate(int ,int)方法,从这个方法进入到子类中,执行完return num1 + num2后,将值返回到AbstractCalculator类,赋给result,打印出来。正好验证了我们开头的思路。

C2、类之间的关系

C2.1、观察者模式(Observer)

观察者模式又叫做发布-订阅(Publish/Subscribe)模式。定义了一种一对多的依赖关系,让多个观察者对象同时监听某一个主题对象。这个主题对象在状态发生变化时, 会通知所有观察者对象,使它们能够自动更新自己。

  

观察者模式是类和类之间的关系,不涉及到继承。可以如下理解,类似于邮件订阅和RSS订阅,当我们浏览一些博客时,经常会看到RSS图标,就这的意思是,当你订阅了该文章,如果后续有更新,会及时通知你。其实,简单来讲就一句话:当一个对象变化时,其它依赖该对象的对象都会收到通知,并且随着变化!对象之间是一种一对多的关系。

  接下来逐个分析每个类的实现:

(1)Subject类:可译为主题或抽象通知者,一般用一个抽象类或者一个接口实现。

    //抽象主题、目标或者通知者
public abstract class Subject {
private IList<Observer> observers = new List<Observer>();
//增加观察者
public void Attach(Observer observer)
{
observers.Add(observer);
} //移除观察者
public void Detach(Observer observer)
{
observers.Remove(observer);
} //通知
public void Notify()
{
foreach (Observer o in observers)
{
o.Update();
}
}
}

(2)Observer类:抽象观察者,这个接口叫做更新接口。抽象观察者一般用一个抽象类或者一个接口实现。更新接口通常包含一个Update()方法,这个方法叫做更新方法。

    //抽象观察者
public abstract class Observer
{
public abstract void Update();//更新方法
}

(3)ConcreteSubject类:叫做具体主题或具体通知者。具体主题角色通常用一个具体子类实现。

    //具体被观察者或主题、目标
public class ConcreteSubject:Subject
{
//具体被观察者状态
public string subjectState { get; set; }
}

 (4)ConcreteObserver类:具体观察者,具体观察者角色可以保存一个指向具体主题对象的引用。通常用一 个具体子类实现。

    //具体观察者
public class ConcreteObserver:Observer
{
private string name;
private string observerState;
private ConcreteSubject suject;
//根据具体被观察对象构造具体观察者
public ConcreteObserver(ConcreteSubject suject, string name )
{
this.name = name;
this.suject = suject;
} public override void Update()
{
observerState = this.suject.subjectState;
Console.WriteLine("观察者{0}的新状态是{1}", name, observerState);
}
}

(5)客户端代码

        ConcreteSubject cSubject = new ConcreteSubject();
cSubject.Add(new ConcreteObserver(cSubject, "张扬")); cSubject.subjectState = "老板了,关闭股票窗口!"; cSubject.Notify();
Console.Read();

C2.2、迭代子模式(Iterator)

顾名思义,迭代器模式就是顺序访问聚集中的对象,一般来说,集合中非常常见,如果对集合类比较熟悉的话,理解本模式会十分轻松。这句话包含两层意思:一是需要遍历的对象,即聚集对象,二是迭代器对象,用于对聚集对象进行遍历访问。我们看下关系图:

这个思路和我们常用的一模一样,MyCollection中定义了集合的一些操作,MyIterator中定义了一系列迭代操作,且持有Collection实例,我们来看看实现代码:

两个接口:

  1. public interface Collection {
  2. public Iterator iterator();
  3. /*取得集合元素*/
  4. public Object get(int i);
  5. /*取得集合大小*/
  6. public int size();
  7. }
  1. public interface Iterator {
  2. //前移
  3. public Object previous();
  4. //后移
  5. public Object next();
  6. public boolean hasNext();
  7. //取得第一个元素
  8. public Object first();
  9. }

两个实现:

  1. public class MyCollection implements Collection {
  2. public String string[] = {"A","B","C","D","E"};
  3. @Override
  4. public Iterator iterator() {
  5. return new MyIterator(this);
  6. }
  7. @Override
  8. public Object get(int i) {
  9. return string[i];
  10. }
  11. @Override
  12. public int size() {
  13. return string.length;
  14. }
  15. }
  1. public class MyIterator implements Iterator {
  2. private Collection collection;
  3. private int pos = -1;
  4. public MyIterator(Collection collection){
  5. this.collection = collection;
  6. }
  7. @Override
  8. public Object previous() {
  9. if(pos > 0){
  10. pos--;
  11. }
  12. return collection.get(pos);
  13. }
  14. @Override
  15. public Object next() {
  16. if(pos<collection.size()-1){
  17. pos++;
  18. }
  19. return collection.get(pos);
  20. }
  21. @Override
  22. public boolean hasNext() {
  23. if(pos<collection.size()-1){
  24. return true;
  25. }else{
  26. return false;
  27. }
  28. }
  29. @Override
  30. public Object first() {
  31. pos = 0;
  32. return collection.get(pos);
  33. }
  34. }

测试类:

  1. public class Test {
  2. public static void main(String[] args) {
  3. Collection collection = new MyCollection();
  4. Iterator it = collection.iterator();
  5. while(it.hasNext()){
  6. System.out.println(it.next());
  7. }
  8. }
  9. }

输出:A B C D E

此处我们貌似模拟了一个集合类的过程,感觉是不是很爽?其实JDK中各个类也都是这些基本的东西,加一些设计模式,再加一些优化放到一起的,只要我们把这些东西学会了,掌握好了,我们也可以写出自己的集合类,甚至框架!

C2.3、责任链模式(Chain of Responsibility)

接下来我们将要谈谈责任链模式,有多个对象,每个对象持有对下一个对象的引用,这样就会形成一条链,请求在这条链上传递,直到某一对象决定处理该请求。但是发出者并不清楚到底最终那个对象会处理该请求,所以,责任链模式可以实现,在隐瞒客户端的情况下,对系统进行动态的调整。先看看关系图:

Abstracthandler类提供了get和set方法,方便MyHandle类设置和修改引用对象,MyHandle类是核心,实例化后生成一系列相互持有的对象,构成一条链。

  1. public interface Handler {
  2. public void operator();
  3. }
  1. public abstract class AbstractHandler {
  2. private Handler handler;
  3. public Handler getHandler() {
  4. return handler;
  5. }
  6. public void setHandler(Handler handler) {
  7. this.handler = handler;
  8. }
  9. }
  1. public class MyHandler extends AbstractHandler implements Handler {
  2. private String name;
  3. public MyHandler(String name) {
  4. this.name = name;
  5. }
  6. @Override
  7. public void operator() {
  8. System.out.println(name+"deal!");
  9. if(getHandler()!=null){
  10. getHandler().operator();
  11. }
  12. }
  13. }
  1. public class Test {
  2. public static void main(String[] args) {
  3. MyHandler h1 = new MyHandler("h1");
  4. MyHandler h2 = new MyHandler("h2");
  5. MyHandler h3 = new MyHandler("h3");
  6. h1.setHandler(h2);
  7. h2.setHandler(h3);
  8. h1.operator();
  9. }
  10. }

输出:

h1deal! h2deal! h3deal!

此处强调一点就是,链接上的请求可以是一条链,可以是一个树,还可以是一个环,模式本身不约束这个,需要我们自己去实现,同时,在一个时刻,命令只允许由一个对象传给另一个对象,而不允许传给多个对象。

C2.4、命令模式(Command)

  将一个请求封装为一个对象,从而使你可用不同的请求对客户进行参数化;对请求排队或记录请求日志,以及支持可撤销的操作。

  

命令模式很好理解,举个例子,司令员下令让士兵去干件事情,从整个事情的角度来考虑,司令员的作用是,发出口令,口令经过传递,传到了士兵耳朵里,士兵去执行。这个过程好在,三者相互解耦,任何一方都不用去依赖其他人,只需要做好自己的事儿就行,司令员要的是结果,不会去关注到底士兵是怎么实现的。我们看看关系图:

Invoker是调用者(司令员),Receiver是被调用者(士兵),MyCommand是命令,实现了Command接口,持有接收对象,看实现代码:

  1. public interface Command {
  2. public void exe();
  3. }
  1. public class MyCommand implements Command {
  2. private Receiver receiver;
  3. public MyCommand(Receiver receiver) {
  4. this.receiver = receiver;
  5. }
  6. @Override
  7. public void exe() {
  8. receiver.action();
  9. }
  10. }
  1. public class Receiver {
  2. public void action(){
  3. System.out.println("command received!");
  4. }
  5. }
  1. public class Invoker {
  2. private Command command;
  3. public Invoker(Command command) {
  4. this.command = command;
  5. }
  6. public void action(){
  7. command.exe();
  8. }
  9. }
  1. public class Test {
  2. public static void main(String[] args) {
  3. Receiver receiver = new Receiver();
  4. Command cmd = new MyCommand(receiver);
  5. Invoker invoker = new Invoker(cmd);
  6. invoker.action();
  7. }
  8. }

输出:command received!

这个很哈理解,命令模式的目的就是达到命令的发出者和执行者之间解耦,实现请求和执行分开,熟悉Struts的同学应该知道,Struts其实就是一种将请求和呈现分离的技术,其中必然涉及命令模式的思想!

其实每个设计模式都是很重要的一种思想,看上去很熟,其实是因为我们在学到的东西中都有涉及,尽管有时我们并不知道,其实在Java本身的设计之中处处都有体现,像AWT、JDBC、集合类、IO管道或者是Web框架,里面设计模式无处不在。因为我们篇幅有限,很难讲每一个设计模式都讲的很详细,不过我会尽我所能,尽量在有限的空间和篇幅内,把意思写清楚了,更好让大家明白。本章不出意外的话,应该是设计模式最后一讲了,首先还是上一下上篇开头的那个图:本章讲讲第三类和第四类。 C3类的状态

C3.1、备忘录模式(Memento)

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

    public class Originator
{
private string state;
public string State
{
get { return state; }
set { state = value; }
} public Memento CreateMemento()
{
return (new Memento(state));
} public void SetMemento(Memento memento)
{
state = memento.State;
}
public void Show()
{
Console.WriteLine("State=" + state);
}
}
public class Memento
{
private string state;
public Memento(string state)
{
this.state = state;
}
public string State
{
get { return state; }
}
}
public class Caretaker
{
private Memento memento;
public Memento Memento
{
get { return memento; }
set { memento = value; }
}
}
class Program
{
static void Main(string[] args)
{
Originator o = new Originator();
o.State = "On";
o.Show(); Caretaker c = new Caretaker();
c.Memento = o.CreateMemento();
o.State = "off";
o.Show(); o.SetMemento(c.Memento);
o.Show(); Console.Read();
}
}

  主要目的是保存一个对象的某个状态,以便在适当的时候恢复对象,个人觉得叫备份模式更形象些,通俗的讲下:假设有原始类A,A中有各种属性,A可以决定需要备份的属性,备忘录类B是用来存储A的一些内部状态,类C呢,就是一个用来存储备忘录的,且只能存储,不能修改等操作。做个图来分析一下:Original类是原始类,里面有需要保存的属性value及创建一个备忘录类,用来保存value值。Memento类是备忘录类,Storage类是存储备忘录的类,持有Memento类的实例,该模式很好理解。直接看源码:

  1. public class Original {
  2. private String value;
  3. public String getValue() {
  4. return value;
  5. }
  6. public void setValue(String value) {
  7. this.value = value;
  8. }
  9. public Original(String value) {
  10. this.value = value;
  11. }
  12. public Memento createMemento(){
  13. return new Memento(value);
  14. }
  15. public void restoreMemento(Memento memento){
  16. this.value = memento.getValue();
  17. }
  18. }
  1. public class Memento {
  2. private String value;
  3. public Memento(String value) {
  4. this.value = value;
  5. }
  6. public String getValue() {
  7. return value;
  8. }
  9. public void setValue(String value) {
  10. this.value = value;
  11. }
  12. }
  1. public class Storage {
  2. private Memento memento;
  3. public Storage(Memento memento) {
  4. this.memento = memento;
  5. }
  6. public Memento getMemento() {
  7. return memento;
  8. }
  9. public void setMemento(Memento memento) {
  10. this.memento = memento;
  11. }
  12. }

测试类:

  1. public class Test {
  2. public static void main(String[] args) {
  3. // 创建原始类
  4. Original origi = new Original("egg");
  5. // 创建备忘录
  6. Storage storage = new Storage(origi.createMemento());
  7. // 修改原始类的状态
  8. System.out.println("初始化状态为:" + origi.getValue());
  9. origi.setValue("niu");
  10. System.out.println("修改后的状态为:" + origi.getValue());
  11. // 回复原始类的状态
  12. origi.restoreMemento(storage.getMemento());
  13. System.out.println("恢复后的状态为:" + origi.getValue());
  14. }
  15. }

输出:初始化状态为:egg 修改后的状态为:niu 恢复后的状态为:egg简单描述下:新建原始类时,value被初始化为egg,后经过修改,将value的值置为niu,最后倒数第二行进行恢复状态,结果成功恢复了。其实我觉得这个模式叫“备份-恢复”模式最形象。

C3.2、状态模式(State)

  当一个对象的内在状态改变时允许改变其行为,这个对象看起来像是改变了其类。  核心思想就是:当对象的状态改变时,同时改变其行为,很好理解!就拿QQ来说,有几种状态,在线、隐身、忙碌等,每个状态对应不同的操作,而且你的好友也能看到你的状态,所以,状态模式就两点:1、可以通过改变状态来获得不同的行为。2、你的好友能同时看到你的变化。看图:State类是个状态类,Context类可以实现切换,我们来看看代码:

  1. package com.xtfggef.dp.state;
  2. /**
  3. * 状态类的核心类
  4. * 2012-12-1
  5. * @author erqing
  6. *
  7. */
  8. public class State {
  9. private String value;
  10. public String getValue() {
  11. return value;
  12. }
  13. public void setValue(String value) {
  14. this.value = value;
  15. }
  16. public void method1(){
  17. System.out.println("execute the first opt!");
  18. }
  19. public void method2(){
  20. System.out.println("execute the second opt!");
  21. }
  22. }
  1. package com.xtfggef.dp.state;
  2. /**
  3. * 状态模式的切换类   2012-12-1
  4. * @author erqing
  5. *
  6. */
  7. public class Context {
  8. private State state;
  9. public Context(State state) {
  10. this.state = state;
  11. }
  12. public State getState() {
  13. return state;
  14. }
  15. public void setState(State state) {
  16. this.state = state;
  17. }
  18. public void method() {
  19. if (state.getValue().equals("state1")) {
  20. state.method1();
  21. else if (state.getValue().equals("state2")) {
  22. state.method2();
  23. }
  24. }
  25. }

测试类:

  1. public class Test {
  2. public static void main(String[] args) {
  3. State state = new State();
  4. Context context = new Context(state);
  5. //设置第一种状态
  6. state.setValue("state1");
  7. context.method();
  8. //设置第二种状态
  9. state.setValue("state2");
  10. context.method();
  11. }
  12. }

输出: execute the first opt! execute the second opt!根据这个特性,状态模式在日常开发中用的挺多的,尤其是做网站的时候,我们有时希望根据对象的某一属性,区别开他们的一些功能,比如说简单的权限控制等。

C3通过中间类

C3.1、访问者模式(Visitor)

  表示一个作用于某对象结构中的各元素的操作。它使你可以在不改变各元素的类的前提下定义作用于这些元素的新操作。类结构图如下图:    访问者模式把数据结构和作用于结构上的操作解耦合,使得操作集合可相对自由地演化。访问者模式适用于数据结构相对稳定算法又易变化的系统。因为访问者模式使得算法操作增加变得容易。若系统数据结构对象易于变化,经常有新的数据对象增加进来,则不适合使用访问者模式。访问者模式的优点是增加操作很容易,因为增加操作意味着增加新的访问者。访问者模式将有关行为集中到一个访问者对象中,其改变不影响系统数据结构。其缺点就是增加新的数据结构很困难。—— From 百科简单来说,访问者模式就是一种分离对象数据结构与行为的方法,通过这种分离,可达到为一个被访问者动态添加新的操作而无需做其它的修改的效果。简单关系图:来看看原码:一个Visitor类,存放要访问的对象,

  1. public interface Visitor {
  2. public void visit(Subject sub);
  3. }
  1. public class MyVisitor implements Visitor {
  2. @Override
  3. public void visit(Subject sub) {
  4. System.out.println("visit the subject:"+sub.getSubject());
  5. }
  6. }

Subject类,accept方法,接受将要访问它的对象,getSubject()获取将要被访问的属性,

  1. public interface Subject {
  2. public void accept(Visitor visitor);
  3. public String getSubject();
  4. }
  1. public class MySubject implements Subject {
  2. @Override
  3. public void accept(Visitor visitor) {
  4. visitor.visit(this);
  5. }
  6. @Override
  7. public String getSubject() {
  8. return "love";
  9. }
  10. }

测试:

  1. public class Test {
  2. public static void main(String[] args) {
  3. Visitor visitor = new MyVisitor();
  4. Subject sub = new MySubject();
  5. sub.accept(visitor);
  6. }
  7. }

输出:visit the subject:love 该模式适用场景:如果我们想为一个现有的类增加新功能,不得不考虑几个事情:1、新功能会不会与现有功能出现兼容性问题?2、以后会不会再需要添加?3、如果类不允许修改代码怎么办?面对这些问题,最好的解决方法就是使用访问者模式,访问者模式适用于数据结构相对稳定的系统,把数据结构和算法解耦,

C4.3、中介者模式(Mediator)

  用一个中介对象来封装一系列的对象交互。中介者使各对象不需要显式地相互引用,从而使其耦合松散,而且可以独立地改变 它们之间的交互。 中介者模式也是用来降低类类之间的耦合的,因为如果类类之间有依赖关系的话,不利于功能的拓展和维护,因为只要修改一个对象,其它关联的对象都得进行修改。如果使用中介者模式,只需关心和Mediator类的关系,具体类类之间的关系及调度交给Mediator就行,这有点像spring容器的作用。先看看图:User类统一接口,User1和User2分别是不同的对象,二者之间有关联,如果不采用中介者模式,则需要二者相互持有引用,这样二者的耦合度很高,为了解耦,引入了Mediator类,提供统一接口,MyMediator为其实现类,里面持有User1和User2的实例,用来实现对User1和User2的控制。这样User1和User2两个对象相互独立,他们只需要保持好和Mediator之间的关系就行,剩下的全由MyMediator类来维护!基本实现:

  1. public interface Mediator {
  2. public void createMediator();
  3. public void workAll();
  4. }
  1. public class MyMediator implements Mediator {
  2. private User user1;
  3. private User user2;
  4. public User getUser1() {
  5. return user1;
  6. }
  7. public User getUser2() {
  8. return user2;
  9. }
  10. @Override
  11. public void createMediator() {
  12. user1 = new User1(this);
  13. user2 = new User2(this);
  14. }
  15. @Override
  16. public void workAll() {
  17. user1.work();
  18. user2.work();
  19. }
  20. }
  1. public abstract class User {
  2. private Mediator mediator;
  3. public Mediator getMediator(){
  4. return mediator;
  5. }
  6. public User(Mediator mediator) {
  7. this.mediator = mediator;
  8. }
  9. public abstract void work();
  10. }
  1. public class User1 extends User {
  2. public User1(Mediator mediator){
  3. super(mediator);
  4. }
  5. @Override
  6. public void work() {
  7. System.out.println("user1 exe!");
  8. }
  9. }
  1. public class User2 extends User {
  2. public User2(Mediator mediator){
  3. super(mediator);
  4. }
  5. @Override
  6. public void work() {
  7. System.out.println("user2 exe!");
  8. }
  9. }

测试类:

  1. public class Test {
  2. public static void main(String[] args) {
  3. Mediator mediator = new MyMediator();
  4. mediator.createMediator();
  5. mediator.workAll();
  6. }
  7. }

输出:user1 exe! user2 exe! C4.3、解释器模式(Interpreter)

  给定一个语言,定义它的文法的一种表示, 并定义一个解释器,这个解释器使用该表示来解释语言中的句子。

  一般主要应用在OOP开发中的编译器的开发中,所以适用面比较窄。 Context类是一个上下文环境类,Plus和Minus分别是用来计算的实现,代码如下:

  1. public interface Expression {
  2. public int interpret(Context context);
  3. }
  1. public class Plus implements Expression {
  2. @Override
  3. public int interpret(Context context) {
  4. return context.getNum1()+context.getNum2();
  5. }
  6. }
  1. public class Minus implements Expression {
  2. @Override
  3. public int interpret(Context context) {
  4. return context.getNum1()-context.getNum2();
  5. }
  6. }
  1. public class Context {
  2. private int num1;
  3. private int num2;
  4. public Context(int num1, int num2) {
  5. this.num1 = num1;
  6. this.num2 = num2;
  7. }
  8. public int getNum1() {
  9. return num1;
  10. }
  11. public void setNum1(int num1) {
  12. this.num1 = num1;
  13. }
  14. public int getNum2() {
  15. return num2;
  16. }
  17. public void setNum2(int num2) {
  18. this.num2 = num2;
  19. }
  20. }
  1. public class Test {
  2. public static void main(String[] args) {
  3. // 计算9+2-8的值
  4. int result = new Minus().interpret((new Context(new Plus()
  5. .interpret(new Context(9, 2)), 8)));
  6. System.out.println(result);
  7. }
  8. }

最后输出正确的结果:3。基本就这样,解释器模式用来做各种各样的解释器,如正则表达式等的解释器等等!

Design Mode 之 行为模式的更多相关文章

  1. 用户登录(Material Design + Data-Binding + MVP架构模式)实现

    转载请注明出处: http://www.cnblogs.com/cnwutianhao/p/6772759.html MVP架构模式 大家都不陌生,Google 也给出过相应的参考 Sample, 但 ...

  2. ✡ leetcode 170. Two Sum III - Data structure design 设计two sum模式 --------- java

    Design and implement a TwoSum class. It should support the following operations: add and find. add - ...

  3. Design pattern---观察者模式

    观察者模式:发布/订阅模式,当某对象(被观察者)状态发生改变时所有订阅该对象的观察者对象(观察者)都将更新自己 成员(4种): 1.抽象被观察者:将所有的观察者对象的引用存入一个集合,并且定义了添加 ...

  4. Design Mode 之 结构模式

    这里我们主要介绍7种结构型模式:适配器模式.装饰模式.代理模式.外观模式.桥接模式.组合模式.享元模式.其中对象的适配器模式是各种模式的起源,我们看下面的图: B1.适配器模式(Adapter) 模式 ...

  5. Design Mode 之 创建模式

    A.创建模式 首先,简单工厂模式不属于24种涉及模式. A0.简单工厂模式 简单工厂模式,分为三种:普通简单工厂.多方法简单工厂.静态方法简单工厂. A01.普通 就是建立一个工厂类,对实现了同一接口 ...

  6. Design Pattern Singleton 单一模式

    单一模式的几个注意点: 一) 设计单一模式,首先须要把构造函数给私有化了,不让外界訪问,那么外界仅仅能通过提供的函数获取一个新的类. 二) C++的单一模式,记得要在类外初始化一个类,否则或内存出错的 ...

  7. 【Design Patterns】监听器模式

    监听器模式 监听器模式其实是观察者模式中的一种,两者都有关于回调的设计. 与观察者模式不同的是,观察者模式中存在的角色为观察者(Observer)和被观察者(Observable) 而监听器模式中存在 ...

  8. UML系列,使用UML实现GOF Design patterns,常用模式类图解读

    1.单例:Singleton, DirectedAssociation

  9. 【design pattern】代理模式

    前言 设计模式分为三大类: 创建型模式:工厂方法模式.抽象工厂模式.单例模式.建造者模式.原型模式: 结构型模式:适配器模式.装饰器模式.代理模式.外观模式.桥接模式.组合模式.享元模式: 行为型模式 ...

随机推荐

  1. 第三百二十九天 how can I 坚持

    今天莫名其妙的烦,,都是上午搞电脑搞的,好乱,心情很差,又感觉有那么多事. 希望周六不要加班啊.很烦,不想加班. 貌似事情也不是很多.但是为什么会感觉乱七八糟的呢,力不从心的感觉,是能力不行吗. 晚上 ...

  2. DataTrigger的几个用法

    1.用在textbox等输入控件上,验证输入是否合法. <Window.Resources> <Style TargetType="TextBox"> &l ...

  3. [转]模拟HttpContext 实现ASP.NET MVC 的单元测试

    众所周知 ASP.NET MVC 的一个显著优势即可以很方便的实现单元测试,但在我们测试过程中经常要用到HttpContext,而默认情况下单元测试框架是不提供HttpContext的模拟的,本文通过 ...

  4. 【125】固定IP的电脑配置无线路由

    标题所提到的情况即为有些电脑是用静态IP上网的,与普通的宽带连接稍微有些不同,例如我的电脑的静态IP设置是这样的: 只有按照上面的设置才可以正常上网,因此在配置无线路由器的时候也要用到上面的内容,废话 ...

  5. 什么是IntelAMT

    IntelAMT 全称为INTEL主动管理技术,该技术允许IT经理们远程管理和修复联网的计算机系统,而且实施过程是对于服务对象完全透明的,从而节省了用户的时间和计 算机维护成本.释放出来的iAMT构架 ...

  6. HDU2227Find the nondecreasing subsequences(树状数组+DP)

    题目大意就是说帮你给出一个序列a,让你求出它的非递减序列有多少个. 设dp[i]表示以a[i]结尾的非递减子序列的个数,由题意我们可以写出状态转移方程: dp[i] = sum{dp[j] | 1&l ...

  7. java 对excel操作 读取、写入、修改数据;导出数据库数据到excel

    ============前提加入jar包jxl.jar========================= // 从数据库导出数据到excel public List<Xskh> outPu ...

  8. XSLT模糊查询函数contains不区分大小写,for-each排序

    代码如下: <xsl:for-each select="//NewDataSet/map/area[contains(translate(@alt, 'ABCDEFGHIJKLMNOP ...

  9. sql server 2005全角与半角字符转换

    CREATE FUNCTION D_ByteExchangeS_Byte(@str NVARCHAR(4000), --要转换的字符串@flag bit              --转换标志,0转换 ...

  10. (剑指Offer)面试题25:二叉树中和为某一值的路径

    题目: 输入一颗二叉树和一个整数,打印出二叉树中结点值的和为输入整数的所有路径.路径定义为从树的根结点开始往下一直到叶结点所经过的结点形成一条路径. 二叉树结点的定义: struct TreeNode ...