Java中的23种设计模式—代码
http://www.cnblogs.com/luohuarenduli/archive/2008/01/17/1042425.html
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(){//这种匿名内部类是静态的！！
}
//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;
}
}
//**********结构型模式**********
//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
//空
//**********行为型模式*************
//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();
}
}
//publicvoidmed1(){
//}
//};
//returnfy
}