23种设计模式的代码版(Java)
packagelq.test;
importjava.io.*;
importjava.util.*;
//*********创建型模式***************
//factorymethod1
//1具体的构造算法，和2构造出的具体产品由子类实现
interfaceproduct{
}
//或者我也提供一个工厂的接口，由这个抽象类来继承它
abstractclassfactory{
abstractpublicproductfmd();
//我认为这个方方法的存在是，是对factorymethod方法的补充
//例如可以为生成的对象赋值，计算为生成对象应付何值，前后的日值
//且这些都是公用的，生成产品的最主要算法还是在factorymethod中，
//这个方法只是起辅助作用，这也是一种思维方法，将具体的算法实现在一个方法中
//而我不直接调用此方法，而使用另外的一个方法封装它，等到了更灵活的效果，而
//子类需实现的内容是factorymethod
//此方法是一个templatemethod
publicproductcreat(){
productpd=null;
system.out.println("beforeoperation");
pd=fmd();
system.out.println("endoperation");
returnpd;
}
}
classproduct1implementsproduct{
}
classfactory1extendsfactory{
publicproductfmd(){
productpd=newproduct1();
returnpd;
}
}
//factroymethod2
//这种方式简单实用
interfaceproducta{
}
interfacefactorya{
productacreate();
}
classproducta1implementsproducta{}
classfactorya1implementsfactorya{
publicproductacreate(){
productapda=null;
pda=newproducta1();
returnpda;
}
}
//abstractfactory
//abstractfactory与factorymethod的不同在于abstractfactory创建多个产品
//感觉此模式没有什么大用
//当然可以还有更多的接口
interfaceapda{}
interfaceapdb{}
interfaceafactory{
apdacreatea();
apdbcreateb();
}
classapda1implementsapda{}
classapdb1implementsapdb{}
//有几个接口就有几个对应的方法
classafactory1implementsafactory{
publicapdacreatea(){
apdaapda=null;
apda=newapda1();
returnapda;
}
publicapdbcreateb(){
apdbapdb=null;
apdb=newapdb1();
returnapdb;
}
}
//builder
//一个产品的生成分为生成部件和组装部件，不同的产品每个部件生成的方式不同
//而组装的方式相同，部件的生成抽象成接口方法，而组装的方法使用一个templatemethod方法
interfacecpda{}
classcpda1implementscpda{}
interfacebuilderi{
voidbuildpart1();
voidbuildpart2();
voidinitpd();
cpdagetpd();
}
abstractclassbuilderaimplementsbuilderi{
cpdacpda;
publiccpdagetpd(){
initpd();
//对对象的内容进行设置
buildpart1();
buildpart2();
returncpda;
}
}
classbuilderextendsbuildera{
publicvoidbuildpart1(){
system.out.println(cpda);
}
publicvoidbuildpart2(){
system.out.println(cpda);
}
publicvoidinitpd(){
cpda=newcpda1();
}
}
//一个简单的生成产品的实现
//1
abstractclassfy{
publicabstractvoidmed1();
staticclassfy1extendsfy{
publicvoidmed1(){
}
}
publicstaticfygetinstance(){
fyfy=newfy1();
returnfy;
//fyfy=newfy1(){//这种匿名内部类是静态的！！
//publicvoidmed1(){
//}
//};
//returnfy
}
}
//2
interfacepdd{}
classpdd1implementspdd{}
abstractclassfya{
publicstaticpddgetpd(){
pddpdd=newpdd1();
returnpdd;
}
}
//prototype在java中就是clone，又包含深拷贝和浅拷贝
classcloneobja{
publiccloneobjamyclone(){
returnnewcloneobja();
}
}
classcloneobjb{
publiccloneobjbmyclone()throwsthrowable{
cloneobjbcobj=null;
cobj=(cloneobjb)pcl(this);
returncobj;
}
/深度拷贝算法
privateobjectpcl(objectobj)throwsthrowable{
bytearrayoutputstreambao=newbytearrayoutputstream(1000);
objectoutputstreamobjo=newobjectoutputstream(bao);
objo.writeobject(obj);
bytearrayinputstreambai=newbytearrayinputstream(bao.tobytearray());
objectinputstreamobji=newobjectinputstream(bai);
objectobjr=obji.readobject();
returnobjr;
}
}
//singleton
//一个类只有一个对象，例如一个线程池，一个cache
classsingleton1{
publicstaticsingleton1instance=newsingleton1();
privatesingleton1(){
}
publicstaticsingleton1getinstance(){
returninstance;
}
}
classsingleton2{
publicstaticsingleton2instance;
privatesingleton2(){
}
//publicstaticsingleton2getinstance(){
//if(instance==null){
//instance=newsingleton2();
//}
//
//returninstance;
//}
publicstaticsingleton2getinstance(){
synchronized(singleton2.class){
if(instance==null){
instance=newsingleton2();
}
}
returninstance;
}
}
落花人独立
关注-0
粉丝-0
关注博主
0 0(请您对文章做出评价)
«上一篇：常用的40个网站制作技巧（转）
»下一篇：状态对象：数据库的替代者
feedback
#1楼[楼主]回复引用查看
2008-01-1710:07by落花人独立
//**********结构型模式**********
//adapter
//基本方法有两种，一种是使用引用一种使用继承
//将不符合标准的接口转成符合标准的接口，接口的修改主要是参数的增减，
//返回值类型,当然还有方法名
//感觉这就是封装的另一种表示形式，封装有用方法封装(在方法中调用功能方法)，
//用类封装(先传入功能方法所在的类的对象，通过调用此对象的功能方法)
//使用引用的形式
classadapteea{
publicvoidkk(){}
}
interfacetargeta{
stringvv(inti,intk);
}
classadapteraimplementstargeta{
adapteeaade;
publicadaptera(adapteeaade){
this.ade=ade;
}
publicstringvv(inti,intk){
//具体的业务方法实现在adaptee中，这个方法
//只起到了接口转换的作用
//调用此方法是通过引用
ade.kk();
returnnull;
}
}
//使用继承形式的
classadapteeb{
publicvoidkk(){}
}
interfacetargetb{
stringvv(inti,intk);
}
classadapterbextendsadapteebimplementstargetb{
publicstringvv(inti,intk){
//调用此方法是通过继承
kk();
returnnull;
}
}
//proxy
interfacesubject{
voidrequest();
}
classrealsubjectimplementssubject{
publicvoidrequest(){
//dotherealbusiness
}
}
classproxyimplementssubject{
subjectsubject;
publicproxy(subjectsubject){
this.subject=subject;
}
publicvoidrequest(){
system.out.println("dosomething");
subject.request();
system.out.println("dosomething");
}
}
//bridge
//感觉就是多态的实现
interfaceimp{
voidoperation();
}
classcimp1implementsimp{
publicvoidoperation(){
system.out.println("1");
}
}
classcimp2implementsimp{
publicvoidoperation(){
system.out.println("2");
}
}
classinvoker{
impimp=newcimp1();
publicvoidinvoke(){
imp.operation();
}
}
//composite
interfacecomponent{
voidoperation();
voidadd(componentcomponent);
voidremove(componentcomponent);
}
classleafimplementscomponent{
publicvoidoperation(){
system.out.println("anoperation");
}
publicvoidadd(componentcomponent){
thrownewunsupportedoperationexception();
}
publicvoidremove(componentcomponent){
thrownewunsupportedoperationexception();
}
}
classcompositeimplementscomponent{
listcomponents=newarraylist();
publicvoidoperation(){
componentcomponent=null;
iteratorit=components.iterator();
while(it.hasnext()){
//不知道此component对象是leaf还是composite，
//如果是leaf则直接实现操作，如果是composite则继续递归调用
component=(component)it.next();
component.operation();
}
}
publicvoidadd(componentcomponent){
components.add(component);
}
publicvoidremove(componentcomponent){
components.remove(component);
}
}
//decorator
//对一个类的功能进行扩展时，我可以使用继承，但是不够灵活，所以选用了
//另外的一种形式,引用与继承都可活得对对象的一定的使用能力，而使用引用将更灵活
//我们要保证是对原功能的追加而不是修改，否则只能重写方法，或使用新的方法
//注意concrete的可以直接new出来，
//而decorator的则需要用一个另外的decorator对象才能生成对象
//使用对象封装，和公用接口
//decorator链上可以有多个元素
interfacecomponenta{
voidoperation();
}
classconcretecomponentimplementscomponenta{
publicvoidoperation(){
system.out.println("dosomething");
}
}
classdecoratorimplementscomponenta{
privatecomponentacomponent;
publicdecorator(componentacomponent){
this.component=component;
}
publicvoidoperation(){
//dosomethingbefore
component.operation();
//dosomethingafter
}
}
//facade
//非常实用的一种设计模式，我可以为外部提供感兴趣的接口
classobj1{
publicvoidope1(){}
publicvoidope2(){}
}
classobj2{
publicvoidope1(){}
publicvoidope2(){}
}
classfacade{
//我得到了一个简洁清晰的接口
publicvoidfdmethod(){
obj1obj1=newobj1();
obj2obj2=newobj2();
obj1.ope1();
obj2.ope2();
}
}
//flyweight
//空
#2楼[楼主]回复引用查看
2008-01-1710:11by落花人独立
//**********行为型模式*************
//chainofresponsibility
//与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;
//}
//}
//strategy
//跟bridge相类似，就是一种多态的表示
//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);
}
}
//iteraotr
//使用迭代器对一个类的数据结构进行顺序迭代
interfacestructure{
interfaceiteratora{
voidfirst();
booleanhaselement();
objectnext();
}
}
classstructure1implementsstructure{
object[]objs=newobject[100];
//使用内部类是为了对struture1的数据结构有完全的访问权
classiteratora1implementsiteratora{
intindex=0;
publicvoidfirst(){
index=0;
}
publicbooleanhaselement(){
returnindex<100;
}
publicobjectnext(){
objectobj=null;
if(haselement()){
obj=objs[index];
index++;
}
returnobj;
}
}
}
//meditor
classa1{
publicvoidoperation1(){}
publicvoidoperation2(){}
}
classa2{
publicvoidoperation1(){}
publicvoidoperation2(){}
}
classmediator{
a1a1;
a2a2;
publicmediator(a1a1,a2a2){
this.a1=a1;
this.a2=a2;
}
//如果我想实现这个功能我可能会把他放在a1中
//但是这样耦合大，我不想在a1中出现a2对象的引用，
//所以我使用了mediator作为中介
publicvoidmmed1(){
a1.operation1();
a2.operation2();
}
publicvoidmmed2(){
a2.operation1();
a1.operation2();
}
}
//command
//我认为就是将方法转换成了类
classreceiver{
publicvoidaction1(){}
publicvoidaction2(){}
}
interfacecommand{
voidexecute();
}
classccommand1implementscommand{
privatereceiverreceiver;
publicccommand1(receiverreceiver){
this.receiver=receiver;
}
publicvoidexecute(){
receiver.action1();
}
}
classccommand2implementscommand{
privatereceiverreceiver;
publicccommand2(receiverreceiver){
this.receiver=receiver;
}
publicvoidexecute(){
receiver.action2();
}
}
//observer
//在这里看似乎这个模式没有什么用
//但是如果我有一个线程监控subject，如果subject的状态
//发生了变化，则更改observer的状态，并出发一些操作，这样就有实际的意义了
//observer与visitor有相似的地方，都存在双向引用
//subject可以注册很多observer
interfacesubjectb{
voidattach(observerobserver);
voiddetach(observerobserver);
voidmynotify();
intgetstate();
voidsetstate(intstate);
}
classsubjectb1implementssubjectb{
listobservers=newarraylist();
intstate;
publicvoidattach(observerobserver){
observers.add(observer);
}
publicvoiddetach(observerobserver){
observers.remove(observer);
}
publicvoidmynotify(){
observerobserver=null;
iteratorit=observers.iterator();
while(it.hasnext()){
observer=(observer)it.next();
observer.update();
}
}
publicintgetstate(){
returnstate;
}
publicvoidsetstate(intstate){
this.state=state;
}
}
interfaceobserver{
voidupdate();
}
classobserver1implementsobserver{
subjectbsubject;
intstate;
publicobserver1(subjectbsubject){
this.subject=subject;
}
publicvoidupdate(){
this.state=subject.getstate();
}
publicvoidoperation(){
//一些基于state的操作
}
}
//memento
//感觉此模式没有什么大用
classmemento{
intstate;
publicintgetstate(){
returnstate;
}
publicvoidsetstate(intstate){
this.state=state;
}
}
classoriginator{
intstate;
publicvoidsetmemento(mementomemento){
state=memento.getstate();
}
publicmementocreatememento(){
mementomemento=newmemento();
memento.setstate(1);
returnmemento;
}
publicintgetstate(){
returnstate;
}
publicvoidsetstate(intstate){
this.state=state;
}
}
classcaretaker{
mementomemento;
publicvoidsavermemento(mementomemento){
this.memento=memento;
}
publicmementoretrievememento(){
returnmemento;
}
}
//程序最终还是顺序执行的，是由不通部分的操作拼接起来的
//将不同类的代码拼接起来是通过引用实现的，有了引用我就
//相当于有了一定访问数据结构和方法的能力，这与写在类内部
//差不多，例如我想将一个类中的一个方法抽离出去，因为这个方法依赖与此类的数据和其他方法
//直接将代码移走是不行的，但如果我们拥有了此类对象的引用，则与写在此类
//内部无异，所以我们拥有了引用就可以将此方法移出
publicclasstt1{
publicstaticvoidmain(string[]args){
}
}