JAVA设计模式之行为型模式.docx
- 文档编号:3572324
- 上传时间:2022-11-24
- 格式:DOCX
- 页数:27
- 大小:23.21KB
JAVA设计模式之行为型模式.docx
《JAVA设计模式之行为型模式.docx》由会员分享,可在线阅读,更多相关《JAVA设计模式之行为型模式.docx(27页珍藏版)》请在冰豆网上搜索。
JAVA设计模式之行为型模式
JAVA设计模式之行为型模式
结构型模式包括责任链模式、命令模式、解释器模式、迭代器模式、中介者模式、备忘录模式、观察者模式、状态模式、策略模式、模版模式和访问者共11类
1、责任链模式
使多个对象都有机会处理请求,从而避免请求的发送者和接收者之间的耦合关系。
将这些对象连成一链,这条链传递该请求,直到有一个对象处理它为止。
这一模式的想法是,给多个对象处理一个请求的机会,从而解耦发送者和接受者。
适用条件:
1)有多个的对象可以处理一个请求,哪个对象处理该请求运行时刻自动确定。
2)你可在不明确指定接收者的情况下,向多个对象中的一个提交一个请求。
3)可处理一个请求的对象集合应被动态指定。
参与者:
1)Handler:
定义一个处理请求的接口。
(可选)实现后继链。
2)ConcreteHandler:
处理它所负责的请求。
可访问它的后继者。
如果可处理该请求,就处理它;否则将该请求转发给它的后继者。
3)Client:
向链上的具体处理者(ConcreteHandler)对象提交请求。
示例:
packagezantip.modules;
publicclassResponsibilityTest{
//测试
publicstaticvoidmain(String[]args){
RequestHandlereqHandlehr=newHRRequestHandle();
RequestHandlereqHandlepm=newPMRequestHanlde(reqHandlehr);
RequestHandlereqHandletl=newTLRequestHandle(reqHandlepm);
//teamleader处理离职请求
Requestrequest=newDimissionRequest();
reqHandletl.handleRequest(request);
System.out.println("============");
//teamleader处理加薪请求
request=newAddMoneyRequest();
reqHandletl.handleRequest(request);
System.out.println("=================");
//项目经理处理辞职请求
request=newDimissionRequest();
reqHandlepm.handleRequest(request);
}
}
//request
classRequest{
}
classDimissionRequestextendsRequest{
}
classAddMoneyRequestextendsRequest{
}
classLeaveRequestextendsRequest{
}
//Handler
interfaceRequestHandle{
publicvoidhandleRequest(Requestrequest);
}
//ConcreteHandler
classHRRequestHandleimplementsRequestHandle{
@Override
publicvoidhandleRequest(Requestrequest){
if(requestinstanceofDimissionRequest){
System.out.println("要离职,人事审批");
}
System.out.println("请求完成");
}
}
classPMRequestHanldeimplementsRequestHandle{
RequestHandlerequesthandle;
publicPMRequestHanlde(RequestHandlerh){
this.requesthandle=rh;
}
@Override
publicvoidhandleRequest(Requestrequest){
if(requestinstanceofAddMoneyRequest){
System.out.println("要加薪,项目经理审批");
}else{
requesthandle.handleRequest(request);
}
}
}
classTLRequestHandleimplementsRequestHandle{
RequestHandlerequesthandle;
publicTLRequestHandle(RequestHandlerh){
this.requesthandle=rh;
}
@Override
publicvoidhandleRequest(Requestrequest){
if(requestinstanceofLeaveRequest){
System.out.println("要请假,项目组长审批");
}else{
requesthandle.handleRequest(request);
}
}
}
输出结果:
要离职,人事审批
请求完成
============
要加薪,项目经理审批
=================
要离职,人事审批
请求完成
2、命令模式
将一个请求封装为一个对象,从而使你可用不同的请求对客户进行参数化;对请求排队或记录请求日志,以及支持可撤消的操作。
适用条件:
1)抽象出待执行的动作以参数化某对象。
2)在不同的时刻指定、排列和执行请求。
3)支持取消操作。
4)支持修改日志,这样当系统崩溃时,这*修改可以被重做一遍。
5)用构建在原语操作上的高层操作构造一个系统。
参与者:
1)Command:
声明执行操作的接口。
2)ConcreteCommand:
将一个接收者对象绑定于一个动作。
调用接收者相应的操作,以实现Execute。
3)Client:
创建一个具体命令对象并设定它的接收者。
4)Invoker:
要求该命令执行这个请求。
5)Receiver:
知道如何实现与执行一个请求相关的操作。
任何类都可能作为一个接收者。
示例:
packagezantip.modules;
publicclassCommandTest{
//测试
publicstaticvoidmain(String[]args){
Receiverrecv=newReceiver();
Commandcmd=newCommandImpl(recv);
Invokerinvok=newInvoker();
invok.setCommand(cmd);
invok.execute();
}
}
//Receiver
classReceiver{
publicReceiver(){
System.out.println("这是接收请求类");
}
}
//Command
abstractclassCommand{
protectedReceiverreceiver;
publicCommand(Receiverreceiver){
this.receiver=receiver;
}
publicabstractvoidexecute();
}
//ConcreteCommand
classCommandImplextendsCommand{
publicCommandImpl(Receiverreceiver){
super(receiver);
}
@Override
publicvoidexecute(){
System.out.println("执行命令");
}
}
//Invoker
classInvoker{
privateCommandcommand;
publicCommandgetCommand(){
returncommand;
}
publicvoidsetCommand(Commandcommand){
mand=command;
}
publicvoidexecute(){
System.out.println("Invoker的execute被调用,转向成员变量的execute");
mand.execute();
}
}
输出结果:
这是接收请求类
Invoker的execute被调用,转向成员变量的execute
执行命令
3、解释器模式
给定一个语言,定义它的文法的一种表示,并定义一个解释器,这个解释器使用该表示来解释语言中的句子。
适用条件:
当有一个语言需要解释执行,并且你可将该语言中的句子表示为一个抽象语法树时,可使用解释器模式。
而当存在以下情况时该模式效果最好:
1)该文法简单对于复杂的文法,文法的*层次变得庞大而无法管理。
2)效率不是一个关键问题最高效的解释器通常不是通过直接解释语法分析树实现的,而是首先将它们转换成另一种形式。
参与者:
1)AbstractExpression(抽象表达式):
声明一个抽象的解释操作,这个接口为抽象语法树中所有的节点所共享。
2)TerminalExpression(终结符表达式):
实现与文法中的终结符相关联的解释操作。
一个句子中的每个终结符需要该类的一个实例。
3)NonterminalExpression(非终结符表达式):
为文法中的非终结符实现解释(Interpret)操作。
4)Context(上下文):
包含解释器之外的一些全局信息。
5)Client(客户):
构建(或被给定)表示该文法定义的语言中某个特定的句子的抽象方法树。
该抽象语法树由NonterminalExpression和TerminalExpression的实例装配而成。
调用解释器操作。
示例:
packagezantip.modules;
importjava.util.ArrayList;
importjava.util.List;
//AbstractExpression
abstractclassExpression{
abstractvoidinterpret(Contextcontext);
}
//Context
classContext{
privateStringcontent;
privateList
publicStringgetContent(){
returncontent;
}
publicvoidsetContent(Stringcontent){
this.content=content;
}
publicList
returnlist;
}
publicvoidsetList(List
this.list=list;
}
publicvoidadd(Expressionex){
list.add(ex);
}
}
//Expression
classAdvanceExpressionextendsExpression{
@Override
voidinterpret(Contextcontext){
System.out.println("这是高级解析器--"+context.getContent());
}
}
classSimpleExpressionextendsExpression{
@Override
voidinterpret(Contextcontext){
System.out.println("这是简约解析器--"+context.getContent());
}
}
publicclassExpressionTest{
publicstaticvoidmain(String[]args){
Contextcontext=newContext();
context.setContent("解析器模型");
context.add(newSimpleExpression());
context.add(newAdvanceExpression());
context.add(newSimpleExpression());
for(Expressionex:
context.getList()){
ex.interpret(context);
}
}
}
输出结果:
这是简约解析器--解析器模型
这是高级解析器--解析器模型
这是简约解析器--解析器模型
4、迭代器模式
适用条件:
1)访问一个聚合对象的内容而无须暴露她的内部表示。
2)支持对聚合对象的多种遍历。
3)为遍历不同的聚合结构提供一个统一的接口(即:
支持多态迭代)。
参与者:
1)Iterator:
迭代器定义访问和遍历元素的接口。
2)ConcreteIterator:
具体迭代实现迭代器接口,对该聚合遍历时跟踪当前位置。
3)Aggregate:
聚合定义创建相应迭代器对象的接口。
4)ConcreteAggregate:
具体聚合实现创建相应迭代器的接口,该操作返回ConreteIterator的一个适当的实例。
示例:
packagezantip.modules;
//iterator
interfaceMyIterator{
Objectnext();
voidfirst();
voidlast();
booleanhasNext();
}
//concreteIterator
classMyIteratorImplimplementsMyIterator{
privateMyListlist;
privateintindex;
publicMyIteratorImpl(MyListlist){
index=0;
this.list=list;
}
publicvoidfirst(){
index=0;
}
publicvoidlast(){
index=this.list.getSize();
}
publicObjectnext(){
Objectobj=this.list.get(index);
index++;
returnobj;
}
publicbooleanhasNext(){
returnindex } } //Aggregate interfaceMyList{ MyIteratoriterator(); Objectget(intindex); intgetSize(); voidadd(Objectobj); } //ConcreteAggregate classMyListImplimplementsMyList{ privateObject[]list; privateintindex; privateintsize; publicMyListImpl(){ index=0; size=0; list=newObject[100]; } @Override publicMyIteratoriterator(){ returnnewMyIteratorImpl(this); } @Override publicObjectget(intindex){ returnthis.list[index]; } @Override publicintgetSize(){ returnthis.size; } @Override publicvoidadd(Objectobj){ list[index++]=obj; size++; } } publicclassIteratorTest{ publicstaticvoidmain(String[]args){ MyListlist=newMyListImpl(); list.add("aa"); list.add("bb"); list.add("cc"); //第一种迭代方式 MyIteratoriter=list.iterator(); while(iter.hasNext()){ System.out.println(iter.next()); } System.out.println("------------------"); //第二种迭代方式 for(inti=0;i System.out.println(list.get(i)); } } } 输出结果: aa bb cc ------------------ aa bb cc 5、中介者模式 适用条件: 参与者: 示例: packagezantip.modules; //Mediator abstractclassMediator{ abstractvoidnotice(Stringmsg); } //Fox interfaceFox{ voidaction(); } //实现两只狐狸 classBeautyFoximplementsFox{ @Override publicvoidaction(){ System.out.println("漂亮的狐狸"); } } classWellFoximplementsFox{ @Override publicvoidaction(){ System.out.println("优雅的狐狸"); } } //concreteMediator classConcreteMediatorextendsMediator{ privateBeautyFoxbeautyfox; privateWellFoxwellfox; publicConcreteMediator(){ beautyfox=newBeautyFox(); wellfox=newWellFox(); } @Override voidnotice(Stringmsg){ if(msg.equals("tiger")){ beautyfox.action(); } if(msg.equals("lion")){ wellfox.action(); } } } publicclassMediatorTest{ publicstaticvoidmain(String[]args){ Mediatormediator=newConcreteMediator(); mediator.notice("tiger"); mediator.notice("lion"); } } 输出结果: 漂亮的狐狸 优雅的狐狸 6、备忘录模式 适用条件: 参与者: 示例: packagezantip.modules; //Memento classMementor{ privateStringstate; publicMementor(Stringstate){ this.state=state; } publicStringgetState(){ returnstate; } publicvoidsetState(Stringstate){ this.state=state; } } //Orignator classOriginator{ privateStringstate; publicStringgetState(){ returnstate; } publicvoidsetState(Stringstate){ this.state=state; } publicMementorcreateMementor(){ returnnewMementor(this.state); } publicvoidsetMementor(Mementormementor){ state=mementor.getState(); } publicvoidshowState(){ System.out.println(this.state); } } //Caretaker classCaretaker{ privateMementormementor; publicMementorgetMementor(){ returnmementor; } publicvoidsetMementor(Mementormementor){ this.mementor=mementor; } } //测试 publicclassMemoryTest{ publicstaticvoidmain(String[]args){ Originatororg=newOriginator(); org.setState("正在开会呢"); Caretakertaker=newCaretaker(); taker.setMementor(org.createMementor()); org.setState("正在开车呢");
- 配套讲稿:
如PPT文件的首页显示word图标,表示该PPT已包含配套word讲稿。双击word图标可打开word文档。
- 特殊限制:
部分文档作品中含有的国旗、国徽等图片,仅作为作品整体效果示例展示,禁止商用。设计者仅对作品中独创性部分享有著作权。
- 关 键 词:
- JAVA 设计 模式 行为
![提示](https://static.bdocx.com/images/bang_tan.gif)