JAVA设计模式之行为型模式.doc

《JAVA设计模式之行为型模式.doc》由会员分享，可在线阅读，更多相关《JAVA设计模式之行为型模式.doc（22页珍藏版）》请在沃文网上搜索。

1、JAVA设计模式之行为型模式结构型模式包括责任链模式、命令模式、解释器模式、迭代器模式、中介者模式、备忘录模式、观察者模式、状态模式、策略模式、模版模式和访问者共11类1、责任链模式使多个对象都有机会处理请求，从而避免请求的发送者和接收者之间的耦合关系。将这些对象连成一链，这条链传递该请求，直到有一个对象处理它为止。这一模式的想法是，给多个对象处理一个请求的机会，从而解耦发送者和接受者。适用条件：1）有多个的对象可以处理一个请求，哪个对象处理该请求运行时刻自动确定。2）你可在不明确指定接收者的情况下，向多个对象中的一个提交一个请求。3）可处理一个请求的对象集合应被动态指定。参与者：1）Hand

2、ler：定义一个处理请求的接口。（可选）实现后继链。2）ConcreteHandler：处理它所负责的请求。可访问它的后继者。如果可处理该请求，就处理它；否则将该请求转发给它的后继者。3）Client：向链上的具体处理者(ConcreteHandler)对象提交请求。示例：package zantip.modules;public class ResponsibilityTest / 测试public static void main(String args) RequestHandle reqHandlehr = new HRRequestHandle();RequestHandle req

3、Handlepm = new PMRequestHanlde(reqHandlehr);RequestHandle reqHandletl = new TLRequestHandle(reqHandlepm);/ team leader处理离职请求Request request = new DimissionRequest();reqHandletl.handleRequest(request);System.out.println(=);/ team leader处理加薪请求request = new AddMoneyRequest();reqHandletl.handleRequest(r

4、equest);System.out.println(=);/ 项目经理处理辞职请求request = new DimissionRequest();reqHandlepm.handleRequest(request);/ requestclass Request class DimissionRequest extends Request class AddMoneyRequest extends Request class LeaveRequest extends Request / Handlerinterface RequestHandle public void handleRequ

5、est(Request request);/ ConcreteHandlerclass HRRequestHandle implements RequestHandle Overridepublic void handleRequest(Request request) if (request instanceof DimissionRequest) System.out.println(要离职，人事审批);System.out.println(请求完成);class PMRequestHanlde implements RequestHandle RequestHandle requesth

6、andle;public PMRequestHanlde(RequestHandle rh) this.requesthandle = rh;Overridepublic void handleRequest(Request request) if (request instanceof AddMoneyRequest) System.out.println(要加薪，项目经理审批); else requesthandle.handleRequest(request);class TLRequestHandle implements RequestHandle RequestHandle req

7、uesthandle;public TLRequestHandle(RequestHandle rh) this.requesthandle = rh;Overridepublic void handleRequest(Request request) if (request instanceof LeaveRequest) System.out.println(要请假，项目组长审批); else requesthandle.handleRequest(request);输出结果：要离职，人事审批请求完成=要加薪，项目经理审批=要离职，人事审批请求完成2、命令模式将一个请求封装为一个对象，从而

8、使你可用不同的请求对客户进行参数化；对请求排队或记录请求日志，以及支持可撤消的操作。适用条件：1）抽象出待执行的动作以参数化某对象。2）在不同的时刻指定、排列和执行请求。3）支持取消操作。4）支持修改日志，这样当系统崩溃时，这*修改可以被重做一遍。5）用构建在原语操作上的高层操作构造一个系统。参与者：1）Command：声明执行操作的接口。2）ConcreteCommand：将一个接收者对象绑定于一个动作。调用接收者相应的操作，以实现Execute。3）Client：创建一个具体命令对象并设定它的接收者。4）Invoker：要求该命令执行这个请求。5）Receiver：知道如何实现与执行一个请

9、求相关的操作。任何类都可能作为一个接收者。示例：package zantip.modules;public class CommandTest / 测试public static void main(String args) Receiver recv = new Receiver();Command cmd = new CommandImpl(recv);Invoker invok = new Invoker();invok.setCommand(cmd);invok.execute();/ Receiverclass Receiver public Receiver() System.ou

10、t.println(这是接收请求类);/ Commandabstract class Command protected Receiver receiver;public Command(Receiver receiver) this.receiver = receiver;public abstract void execute();/ ConcreteCommandclass CommandImpl extends Command public CommandImpl(Receiver receiver) super(receiver);Overridepublic void execut

11、e() System.out.println(执行命令);/ Invokerclass Invoker private Command command;public Command getCommand() return command;public void setCommand(Command command) mand = command;public void execute() System.out.println(Invoker的execute被调用，转向成员变量的execute);mand.execute();输出结果：这是接收请求类Invoker的execute被调用，转向成员

12、变量的execute执行命令3、解释器模式给定一个语言，定义它的文法的一种表示，并定义一个解释器，这个解释器使用该表示来解释语言中的句子。适用条件：当有一个语言需要解释执行,并且你可将该语言中的句子表示为一个抽象语法树时，可使用解释器模式。而当存在以下情况时该模式效果最好：1）该文法简单对于复杂的文法,文法的*层次变得庞大而无法管理。2）效率不是一个关键问题最高效的解释器通常不是通过直接解释语法分析树实现的,而是首先将它们转换成另一种形式。参与者：1）AbstractExpression(抽象表达式)：声明一个抽象的解释操作，这个接口为抽象语法树中所有的节点所共享。2）TerminalExpr

13、ession(终结符表达式)：实现与文法中的终结符相关联的解释操作。一个句子中的每个终结符需要该类的一个实例。3）NonterminalExpression(非终结符表达式)：为文法中的非终结符实现解释(Interpret)操作。4）Context（上下文）：包含解释器之外的一些全局信息。5）Client（客户）：构建(或被给定)表示该文法定义的语言中某个特定的句子的抽象方法树。该抽象语法树由NonterminalExpression和TerminalExpression的实例装配而成。调用解释器操作。示例：package zantip.modules;import java.util.Arr

14、ayList;import java.util.List;/AbstractExpressionabstract class Expression abstract void interpret(Context context);/ Contextclass Context private String content;private List list = new ArrayList();public String getContent() return content;public void setContent(String content) this.content = content

15、;public List getList() return list;public void setList(List list) this.list = list;public void add(Expression ex) list.add(ex);/ Expressionclass AdvanceExpression extends Expression Overridevoid interpret(Context context) System.out.println(这是高级解析器 - + context.getContent();class SimpleExpression ext

16、ends Expression Overridevoid interpret(Context context) System.out.println(这是简约解析器 - + context.getContent();public class ExpressionTest public static void main(String args) Context context = new Context();context.setContent(解析器模型);context.add(new SimpleExpression();context.add(new AdvanceExpression(

17、);context.add(new SimpleExpression();for (Expression ex : context.getList() ex.interpret(context);输出结果：这是简约解析器 - 解析器模型这是高级解析器 - 解析器模型这是简约解析器 - 解析器模型4、迭代器模式适用条件：1）访问一个聚合对象的内容而无须暴露她的内部表示。2）支持对聚合对象的多种遍历。3）为遍历不同的聚合结构提供一个统一的接口（即：支持多态迭代）。参与者：1）Iterator：迭代器定义访问和遍历元素的接口。2）ConcreteIterator：具体迭代实现迭代器接口，对该聚合遍历

18、时跟踪当前位置。3）Aggregate：聚合定义创建相应迭代器对象的接口。4）ConcreteAggregate：具体聚合实现创建相应迭代器的接口，该操作返回ConreteIterator的一个适当的实例。示例：package zantip.modules;/iteratorinterface MyIterator Object next();void first();void last();boolean hasNext();/ concreteIteratorclass MyIteratorImpl implements MyIterator private MyList list;pri

19、vate int index;public MyIteratorImpl(MyList list) index = 0;this.list = list;public void first() index = 0;public void last() index = this.list.getSize();public Object next() Object obj = this.list.get(index);index+;return obj;public boolean hasNext() return index this.list.getSize();/ Aggregateinte

20、rface MyList MyIterator iterator();Object get(int index);int getSize();void add(Object obj);/ ConcreteAggregateclass MyListImpl implements MyList private Object list;private int index;private int size;public MyListImpl() index = 0;size = 0;list = new Object100;Overridepublic MyIterator iterator() re

21、turn new MyIteratorImpl(this);Overridepublic Object get(int index) return this.listindex;Overridepublic int getSize() return this.size;Overridepublic void add(Object obj) listindex+ = obj;size+;public class IteratorTest public static void main(String args) MyList list = new MyListImpl();list.add(aa)

22、;list.add(bb);list.add(cc);/ 第一种迭代方式MyIterator iter = list.iterator();while (iter.hasNext() System.out.println(iter.next();System.out.println(-);/ 第二种迭代方式for (int i = 0; i list.getSize(); i+) System.out.println(list.get(i);输出结果：aabbcc-aabbcc5、中介者模式适用条件：参与者：示例：package zantip.modules;/Mediatorabstract

23、 class Mediatorabstract void notice(String msg);/Foxinterface Foxvoid action();/实现两只狐狸class BeautyFox implements FoxOverridepublic void action() System.out.println(漂亮的狐狸);class WellFox implements FoxOverridepublic void action() System.out.println(优雅的狐狸);/concreteMediatorclass ConcreteMediator extend

24、s Mediatorprivate BeautyFox beautyfox;private WellFox wellfox;public ConcreteMediator()beautyfox=new BeautyFox();wellfox=new WellFox();Overridevoid notice(String msg) if (msg.equals(tiger) beautyfox.action();if(msg.equals(lion)wellfox.action();public class MediatorTest public static void main(String

25、 args) Mediator mediator=new ConcreteMediator();mediator.notice(tiger);mediator.notice(lion);输出结果：漂亮的狐狸优雅的狐狸6、备忘录模式适用条件：参与者：示例：package zantip.modules;/Mementoclass Mementor private String state;public Mementor(String state) this.state = state;public String getState() return state;public void setStat

26、e(String state) this.state = state;/ Orignatorclass Originator private String state;public String getState() return state;public void setState(String state) this.state = state;public Mementor createMementor() return new Mementor(this.state);public void setMementor(Mementor mementor) state = mementor

27、.getState();public void showState() System.out.println(this.state);/ Caretakerclass Caretaker private Mementor mementor;public Mementor getMementor() return mementor;public void setMementor(Mementor mementor) this.mementor = mementor;/ 测试public class MemoryTest public static void main(String args) O

28、riginator org = new Originator();org.setState(正在开会呢);Caretaker taker = new Caretaker();taker.setMementor(org.createMementor();org.setState(正在开车呢);org.showState();org.setMementor(taker.getMementor();org.showState();输出结果：正在开车呢正在开会呢7、观察者模式适用条件：参与者：示例：package zantip.modules;import java.util.ArrayList;im

29、port java.util.List;interface Watcher public void update(String str);interface Watched public void addWatcher(Watcher watcher);public void removeWatcher(Watcher watcher);public void notifyWatchers(String str);class ConcreteWatcher implements Watcher Overridepublic void update(String str) System.out.

30、println(str);class ConcreteWatched implements Watched / 存放观察者private List list = new ArrayList();Overridepublic void addWatcher(Watcher watcher) list.add(watcher);Overridepublic void removeWatcher(Watcher watcher) list.remove(watcher);Overridepublic void notifyWatchers(String str) for (Watcher watch

31、er : list) watcher.update(str);public class ObserverTest public static void main(String args) Watched girl = new ConcreteWatched();/ 类似按钮Watcher watcher1 = new ConcreteWatcher();/ 类似监听器Watcher watcher2 = new ConcreteWatcher();/ 类似监听器Watcher watcher3 = new ConcreteWatcher();/ 类似监听器Watcher watcher4 =

32、new ConcreteWatcher();/ 类似监听器girl.addWatcher(watcher1);/ 注册监听器girl.addWatcher(watcher2);/ 注册监听器girl.addWatcher(watcher3);/ 注册监听器girl.addWatcher(watcher4);/ 注册监听器girl.notifyWatchers(我很开心);/ 相当于点击按钮事件girl.removeWatcher(watcher2);/ 注销监听器girl.notifyWatchers(我有点烦有点烦);/ 相当于点击按钮事件输出结果：我很开心我很开心我很开心我有点烦有点烦我有

33、点烦有点烦我有点烦有点烦8、状态模式适用条件：参与者：示例：package zantip.modules;/stateinterface Weather String getWeatherMsg();/ messageclass Msg private Weather weather;public Weather getWeather() return weather;public void setWeather(Weather weather) this.weather = weather;public String weatherMsg() return this.weather.getW

34、eatherMsg();/ concrete state messageclass Rain implements Weather Overridepublic String getWeatherMsg() return 下雨;class Sunshine implements Weather Overridepublic String getWeatherMsg() return 阳光;public class StateTest public static void main(String args) Msg msg = new Msg();msg.setWeather(new Sunsh

35、ine();System.out.println(msg.weatherMsg();System.out.println(=);Msg msg2 = new Msg();msg2.setWeather(new Rain();System.out.println(msg2.weatherMsg();输出结果：阳光=下雨9、策略模式定义一系列的算法,把它们一个个封装起来,并且使它们可相互替换。本模式使得算法可独立于使用它的客户而变化。适用条件：1）许多相关的类仅仅是行为有异。“策略”提供了一种用多个行为中的一个行为来配置一个类的方法。2）需要使用一个算法的不同变体。3）算法使用客户不应该知道的数据

36、。可使用策略模式以避免暴露复杂的、与算法相关的数据结构。4）一个类定义了多种行为,并且这些行为在这个类的操作中以一个条件语句的形式出现。将相关的条件分支移入它们各自的Strategy类中以代替这些条件语句。参与者：1）Strategy：2）ConcreteStrategy：3）Environment：示例：package zantip.modules;interface Strategy public int calculate(int a, int b);class AddStrategy implements Strategy Overridepublic int calculate(in

37、t a, int b) return a + b;class SubStrategy implements Strategy Overridepublic int calculate(int a, int b) return a - b;class MulStrategy implements Strategy Overridepublic int calculate(int a, int b) return a * b;class DivStrategy implements Strategy Overridepublic int calculate(int a, int b) return

38、 a / b;class Environment private Strategy strategy;public Environment(Strategy strategy) this.strategy = strategy;public Strategy getStrategy() return strategy;public void setStrategy(Strategy strategy) this.strategy = strategy;public int calculate(int a, int b) return strategy.calculate(a, b);publi

39、c class StrategyTest public static void main(String args) Strategy strategy = new AddStrategy();Environment environment = new Environment(strategy);System.out.println(environment.calculate(20, 30);environment.setStrategy(new SubStrategy();System.out.println(environment.calculate(30, 100);输出结果：50-701

40、0、模版模式定义一个操作中的算法的骨架，并将一些步骤延迟到子类中。TemplateMethod使得子类可以不改变一个算法的结构即可重定义该算法的某些特定步骤。适用条件：1）一次性实现一个算法的不变的部分，并将可变的留给子类来实现。2）各子类中公共的行为应被提取出来并集中到一个公共父类中以避免代码重复。首先识别现有代码中的不同之处，并且将不同之处分离为新的操作。最后，用一个调用这些新的操作的模板方法来替换这些不同的代码。3）控制子类扩展。参与者：1）AbstractClass：定义抽象的原语操作（primitiveoperation），具体的子类将重定义它们以实现一个算法的各步骤。实现一个模板方法,定义一个算法的骨架。该模板方法不仅调用原语操作，也调用定义在AbstractClass或其他对象中的操作。2）ConcreteClass：实现语操作以完成算法中与特定子类相关的步骤。示例：package zantip.modules;/抽象模版abstract class MyTemplate abstract void show();public void update() System.out.println(开始显示);for (int i = 0; i 10; i+