行为型模式

Chain of Responsibility

//与Decorator的实现形式相类似，
//Decorator是在原来的方法之上进行添加功能，而
//Chain则是判断信号如果不是当前处理的则转交个下一个节点处理
//我可以使用if分支来实现相同的效果，但是不够灵活，链上的每个节点是可以替换增加的，相对
//比较灵活，我们可以设计接口实现对节点的增删操作，而实现更方便的效果
//这个是一个链状的结构，有没有想过使用环状结构

interfaceHandler...{
voidhandRequest(intsignal);
}

classCHandler1implementsHandler...{
privateHandlerhandler;

publicCHandler1(Handlerhandler)...{
this.handler=handler;
}

publicvoidhandRequest(intsignal)...{
if(signal==1)...{
System.out.println("handlesignal1");
}
else...{
handler.handRequest(signal);
}
}
}

classCHandler2implementsHandler...{
privateHandlerhandler;

publicCHandler2(Handlerhandler)...{
this.handler=handler;
}

publicvoidhandRequest(intsignal)...{
if(signal==2)...{
System.out.println("handlesignal2");
}
else...{
handler.handRequest(signal);
}
}
}

classCHandler3implementsHandler...{
publicvoidhandRequest(intsignal)...{
if(signal==3)...{
System.out.println("handlesignal3");
}
else...{
thrownewError("can'thandlesignal");
}
}
}

classChainClient...{
publicstaticvoidmain(String[]args)...{
Handlerh3=newCHandler3();
Handlerh2=newCHandler2(h3);
Handlerh1=newCHandler1(h2);

h1.handRequest(2);
}
}

Interpreter

//感觉跟Composite很类似，只不过他分文终结符和非终结符

//TemplateMethod

abstractclassTemplateMethod...{
abstractvoidamd1();

abstractvoidamd2();

//此方法为一个TemplateMethod方法
publicvoidtmd()...{
amd1();
amd2();
}
}

State

//标准型
//状态和操作不应该耦合在一起
classContexta...{
privateStatest;

publicContexta(intnst)...{
changeStfromNum(nst);
}

publicvoidchangeStfromNum(intnst)...{
if(nst==1)...{
st=newCStatea1();
}
elseif(nst==2)...{
st=newCStatea2();
}

thrownewError("badstate");
}

voidrequest()...{
st.handle(this);
}
}

interfaceState...{
voidhandle(Contextacontext);
}

classCStatea1implementsState...{
publicvoidhandle(Contextacontext)...{
System.out.println("state1");
//也许在一个状态的处理过程中要改变状态，例如打开之后立即关闭这种效果
//context.changeStfromNum(2);
}
}

classCStatea2implementsState...{
publicvoidhandle(Contextacontext)...{
System.out.println("state2");
}
}

//工厂型
//根据状态不通生成不同的state

classStateFactory...{
publicstaticStategetStateInstance(intnum)...{
Statest=null;

if(num==1)...{
st=newCStatea1();
}
elseif(num==2)...{
st=newCStatea2();
}

returnst;
}
}

Visitor

//双向引用，使用另外的一个类调用自己的方法,访问自己的数据结构
interfaceVisitor...{
voidvisitElement(Elementdelement);
}

classCVisitorimplementsVisitor...{
publicvoidvisitElement(Elementdelement)...{
element.operation();
}
}

interfaceElementd...{
voidaccept(Visitorvisitor);

voidoperation();
}

classCElementdimplementsElementd...{
publicvoidaccept(Visitorvisitor)...{
visitor.visitElement(this);
}

publicvoidoperation()...{
//实际的操作在这里
}
}

classClientd...{
publicstaticvoidmain()...{
Elementdelm=newCElementd();
Visitorvis=newCVisitor();

vis.visitElement(elm);
}
}

Iteretor

interfaceStructure...{
interfaceIteratora...{
voidfirst();

booleanhasElement();

Objectnext();

}
}

classStructure1implementsStructure...{
Object[]objs=newObject[100];

//使用内部类是为了对Struture1的数据结构有完全的访问权
classIteratora1implementsIteratora...{
intindex=0;

publicvoidfirst()...{
index=0;
}