23种设计模式的代码版(Java)

    package   lq.test;  
   
  import   java.io.*;  
  import   java.util.*;  
   
  //*********创建型模式***************  
   
  //factory   method   1  
  //1具体的构造算法，和2构造出的具体产品由子类实现  
  interface   product   {  
  }  
   
  //或者我也提供一个工厂的接口，由这个抽象类来继承它  
   
  abstract   class   factory   {  
      abstract   public   product   fmd();  
   
      //我认为这个方方法的存在是，是对factorymethod方法的补充  
      //例如可以为生成的对象赋值，计算为生成对象应付何值，前后的日值  
      //且这些都是公用的，生成产品的最主要算法还是在factorymethod中，  
      //这个方法只是起辅助作用，这也是一种思维方法，将具体的算法实现在一个方法中  
      //而我不直接调用此方法，而使用另外的一个方法封装它，等到了更灵活的效果，而  
      //子类需实现的内容是factorymethod  
      //此方法是一个templatemethod  
      public   product   creat()   {  
          product   pd   =   null;  
          system.out.println("before   operation");  
          pd   =   fmd();  
          system.out.println("end   operation");  
          return   pd;  
      }  
  }  
   
  class   product1   implements   product   {  
  }  
   
  class   factory1   extends   factory   {  
  public   product   fmd()   {  
  product   pd   =   new   product1();  
  return   pd;  
  }  
  }  
   
  //factroymethod   2  
  //这种方式简单实用  
  interface   producta   {  
  }  
   
  interface   factorya   {  
  producta   create();  
  }  
   
  class   producta1   implements   producta   {}  
   
  class   factorya1   implements   factorya   {  
      public   producta   create()   {  
          producta   pda   =   null;  
          pda   =   new   producta1();  
          return   pda;  
      }    
  }  
   
  //abstractfactory  
  //abstractfactory与factorymethod的不同在于abstractfactory创建多个产品  
  //感觉此模式没有什么大用  
   
  //当然可以还有更多的接口  
  interface   apda   {}  
  interface   apdb   {}   
  interface   afactory   {  
      apda   createa();  
      apdb   createb();  
  }  
   
  class   apda1   implements   apda   {}  
  class   apdb1   implements   apdb   {}  
   
  //有几个接口就有几个对应的方法  
  class   afactory1   implements   afactory   {  
      public   apda   createa()   {  
          apda   apda   =   null;  
          apda   =   new   apda1();  
          return   apda;  
      }  
   
      public   apdb   createb()   {  
          apdb   apdb   =   null;  
          apdb   =   new   apdb1();  
          return   apdb;  
      }  
  }  
   
  //builder  
  //一个产品的生成分为生成部件和组装部件，不同的产品每个部件生成的方式不同  
  //而组装的方式相同，部件的生成抽象成接口方法，而组装的方法使用一个templatemethod方法  
  interface   cpda   {}  
  class   cpda1   implements   cpda   {}  

  interface   builderi   {  
      void   buildpart1();  
      void   buildpart2();  
 
      void   initpd();  
      cpda   getpd();  
  }  
   
  abstract   class   buildera   implements   builderi   {  
      cpda   cpda;  
   
      public   cpda   getpd()   {  
      initpd();  
   
      //对对象的内容进行设置  
      buildpart1();  
      buildpart2();  
   
      return   cpda;  
      }  
  }  
   
  class   builder   extends   buildera   {  
      public   void   buildpart1()   {  
      system.out.println(cpda);  
      }  
   
      public   void   buildpart2()   {  
      system.out.println(cpda);  
      }  
   
      public   void   initpd()   {  
          cpda   =   new   cpda1();  
      }  
  }  
   
  //一个简单的生成产品的实现  
  //1  
  abstract   class   fy   {  
      public   abstract   void   med1();    
   
      static   class   fy1   extends   fy   {  
          public   void   med1()   {  
          }  
      }  
   
      public   static   fy   getinstance()   {  
          fy   fy   =   new   fy1();  
          return   fy;  
   
          // fy   fy   =   new   fy1()   {//这种匿名内部类是静态的！！  
  // public   void   med1()   {  
  // }  
  // };  
  // return   fy
}  
      }  
   
      //2  
      interface   pdd   {}  
   
      class   pdd1   implements   pdd   {}  
   
      abstract   class   fya   {  
          public   static   pdd   getpd()   {  
          pdd   pdd   =   new   pdd1();  
          return   pdd;  
      }  
  }  
   
  //prototype   在java中就是clone，又包含深拷贝和浅拷贝  
  class   cloneobja   {  
      public   cloneobja   myclone()   {  
              return   new   cloneobja();  
      }  
  }  
   
  class   cloneobjb   {  
      public   cloneobjb   myclone()   throws   throwable   {  
          cloneobjb   cobj   =   null;  
          cobj   =   (cloneobjb)   pcl(this);  
          return   cobj;  
      }  
   
      /深度拷贝算法  
      private   object   pcl(object   obj)   throws   throwable   {  
      bytearrayoutputstream   bao   =   new   bytearrayoutputstream(1000);  
      objectoutputstream   objo   =   new   objectoutputstream(bao);  
      objo.writeobject(obj);  
   
      bytearrayinputstream   bai   =   new   bytearrayinputstream(bao.tobytearray());  
      objectinputstream   obji   =   new   objectinputstream(bai);  
   
      object   objr   =   obji.readobject();  
      return   objr;  
      }    
  }  
   
  //singleton  
  //一个类只有一个对象，例如一个线程池，一个cache  
  class   singleton1   {  
      public   static   singleton1   instance   =   new   singleton1();  
   
     private   singleton1()   {  
      }  
   
      public   static   singleton1   getinstance()   {  
          return   instance;  
      }  
  }  
   
  class   singleton2   {  
      public   static   singleton2   instance;  
   
      private   singleton2()   {  
      }  
   
  // public   static   singleton2   getinstance()   {  
  // if   (instance   ==   null)   {  
  // instance   =   new   singleton2();  
  // }  
  //  
  // return   instance;  
  // }  
   
      public   static   singleton2   getinstance()   {  
          synchronized(singleton2.class)   {  
              if   (instance   ==   null)   {  
              instance   =   new   singleton2();  
              }  
          }  
   
           return   instance;  
      }  
  }
落花人独立
关注 - 0
粉丝 - 0
关注博主
0
0
(请您对文章做出评价)
« 上一篇：常用的40个网站制作技巧 （转）
» 下一篇：状态对象：数据库的替代者
feedback
#1楼[楼主]   回复  引用  查看    
2008-01-17 10:07 by 落花人独立      
//**********结构型模式**********  
   
  //adapter  
  //基本方法有两种，一种是使用引用一种使用继承  
  //将不符合标准的接口转成符合标准的接口，接口的修改主要是参数的增减，  
  //返回值类型,当然还有方法名  
  //感觉这就是封装的另一种表示形式，封装有用方法封装(在方法中调用功能方法)，  
  //用类封装(先传入功能方法所在的类的对象，通过调用此对象的功能方法)  
   
  //使用引用的形式  
  class   adapteea   {  
  public   void   kk()   {}  
  }  
   
  interface   targeta   {  
  string   vv(int   i,   int   k);  
  }  
   
  class   adaptera   implements   targeta{  
  adapteea   ade;  
   
  public   adaptera(adapteea   ade)   {  
  this.ade   =   ade;  
  }  
   
  public   string   vv(int   i,   int   k)   {  
  //具体的业务方法实现在adaptee中，这个方法  
  //只起到了接口转换的作用  
  //调用此方法是通过引用  
  ade.kk();  
  return   null;  
  }  
  }  
   
  //使用继承形式的  
  class   adapteeb   {  
  public   void   kk()   {}  
  }  
   
  interface   targetb   {  
  string   vv(int   i,   int   k);  
  }  
   
  class   adapterb   extends   adapteeb   implements   targetb   {  
  public   string   vv(int   i,   int   k)   {  
  //调用此方法是通过继承  
  kk();  
  return   null;  
  }  
  }  
   
  //proxy  
  interface   subject   {  
  void   request();  
  }    
   
  class   realsubject   implements   subject   {  
  public   void   request()   {  
  //do   the   real   business  
  }  
  }  
   
  class   proxy   implements   subject   {  
  subject   subject;  
   
  public   proxy(subject   subject)   {  
  this.subject   =   subject;  
  }  
   
  public   void   request()   {  
  system.out.println("do   something");  
   
  subject.request();  
   
  system.out.println("do   something");  
  }  
  }  
   
  //bridge  
  //感觉就是多态的实现  
   
  interface   imp   {  
  void   operation();  
  }  
   
  class   cimp1   implements   imp   {  
  public   void   operation()   {  
  system.out.println("1");  
  }  
  }  
   
  class   cimp2   implements   imp   {  
  public   void   operation()   {  
  system.out.println("2");  
  }  
  }  
   
  class   invoker   {  
  imp   imp   =   new   cimp1();  
   
  public   void   invoke()   {  
  imp.operation();  
  }  
  }  
   
  //composite  
   
  interface   component   {  
  void   operation();  
   
  void   add(component   component);  
   
  void   remove(component   component);  
  }  
   
  class   leaf   implements   component   {  
  public   void   operation()   {  
  system.out.println("an   operation");  
  }  
   
  public   void   add(component   component)   {  
  throw   new   unsupportedoperationexception();  
  }  
   
  public   void   remove(component   component)   {  
  throw   new   unsupportedoperationexception();  
  }  
  }  
   
  class   composite   implements   component   {  
  list   components   =   new   arraylist();  
   
  public   void   operation()   {  
  component   component   =   null;  
   
  iterator   it   =   components.iterator();  
  while   (it.hasnext())   {  
  //不知道此component对象是leaf还是composite，  
  //如果是leaf则直接实现操作，如果是composite则继续递归调用  
  component   =   (component)   it.next();  
  component.operation();  
  }  
  }  
   
  public   void   add(component   component)   {  
  components.add(component);  
  }  
   
  public   void   remove(component   component)   {  
  components.remove(component);  
  }  
  }  
   
  //decorator  
  //对一个类的功能进行扩展时，我可以使用继承，但是不够灵活，所以选用了  
  //另外的一种形式,引用与继承都可活得对对象的一定的使用能力，而使用引用将更灵活  
  //我们要保证是对原功能的追加而不是修改，否则只能重写方法，或使用新的方法  
  //注意concrete的可以直接new出来，  
  //而decorator的则需要用一个另外的decorator对象才能生成对象  
  //使用对象封装，和公用接口  
  //decorator链上可以有多个元素  
   
  interface   componenta   {  
  void   operation();  
  }  
   
  class   concretecomponent   implements   componenta   {  
  public   void   operation()   {  
  system.out.println("do   something");  
  }  
  }  
   
  class   decorator   implements   componenta   {  
  private   componenta   component;  
   
  public   decorator(componenta   component)   {  
  this.component   =   component;  
  }  
   
  public   void   operation()   {  
  //do   something   before  
   
  component.operation();  
   
  //do   something   after  
  }  
  }  
   
  //facade  
  //非常实用的一种设计模式，我可以为外部提供感兴趣的接口  
   
  class   obj1   {  
  public   void   ope1()   {}  
  public   void   ope2()   {}  
  }  
   
  class   obj2   {  
  public   void   ope1()   {}  
  public   void   ope2()   {}  
  }  
   
  class   facade   {  
  //我得到了一个简洁清晰的接口  
  public   void   fdmethod()   {  
  obj1   obj1   =   new   obj1();  
  obj2   obj2   =   new   obj2();  
   
  obj1.ope1();  
  obj2.ope2();  
    }  
  }  
   
  //flyweight  
  //空
#2楼[楼主]   回复  引用  查看    
2008-01-17 10:11 by 落花人独立      
//**********行为型模式*************  
   
  //chain   of   responsibility  
  //与decorator的实现形式相类似，  
  //decorator是在原来的方法之上进行添加功能，而  
  //chain则是判断信号如果不是当前处理的则转交个下一个节点处理  
  //我可以使用if分支来实现相同的效果，但是不够灵活，链上的每个节点是可以替换增加的，相对  
  //比较灵活，我们可以设计接口实现对节点的增删操作，而实现更方便的效果  
  //这个是一个链状的结构，有没有想过使用环状结构  
   
  interface   handler   {  
  void   handrequest(int   signal);  
  }  
   
  class   chandler1   implements   handler   {  
  private   handler   handler;  
   
  public   chandler1(handler   handler)   {  
  this.handler   =   handler;  
  }  
   
  public   void   handrequest(int   signal)   {  
  if   (signal   ==   1)   {  
  system.out.println("handle   signal   1");  
  }  
  else   {  
  handler.handrequest(signal);  
  }  
  }    
  }  
   
  class   chandler2   implements   handler   {  
  private   handler   handler;  
   
  public   chandler2(handler   handler)   {  
  this.handler   =   handler;  
  }  
   
  public   void   handrequest(int   signal)   {  
  if   (signal   ==   2)   {  
  system.out.println("handle   signal   2");  
  }  
  else   {  
  handler.handrequest(signal);  
  }  
  }    
  }  
   
  class   chandler3   implements   handler   {  
  public   void   handrequest(int   signal)   {  
  if   (signal   ==   3)   {  
  system.out.println("handle   signal   3");  
  }  
  else   {  
  throw   new   error("can't   handle   signal");  
  }  
  }    
  }  
   
  class   chainclient   {  
  public   static   void   main(string[]   args)   {  
  handler   h3   =   new   chandler3();  
  handler   h2   =   new   chandler2(h3);  
  handler   h1   =   new   chandler1(h2);  
   
  h1.handrequest(2);  
  }  
  }  
   
  //interpreter  
  //感觉跟composite很类似，只不过他分文终结符和非终结符  
   
  //template   method  
   
  abstract   class   templatemethod   {  
  abstract   void   amd1();  
   
  abstract   void   amd2();  
   
  //此方法为一个template   method方法  
  public   void   tmd()   {  
  amd1();  
  amd2();  
  }  
  }  
   
  //state  
   
  //标准型  
  //状态和操作不应该耦合在一起  
  class   contexta   {  
  private   state   st;  
   
  public   contexta(int   nst)   {  
  changestfromnum(nst);  
  }  
   
  public   void   changestfromnum(int   nst)   {  
  if   (nst   ==   1)   {  
  st   =   new   cstatea1();  
  }  
  else   if   (nst   ==   2)   {  
  st   =   new   cstatea2();  
  }  
   
  throw   new   error("bad   state");  
  }  
   
  void   request()   {  
  st.handle(this);  
  }  
  }  
   
  interface   state   {  
  void   handle(contexta   context);  
  }  
   
  class   cstatea1   implements   state   {  
  public   void   handle(contexta   context)   {  
  system.out.println("state   1");  
  //也许在一个状态的处理过程中要改变状态，例如打开之后立即关闭这种效果  
  //context.changestfromnum(2);  
  }  
  }  
   
  class   cstatea2   implements   state   {  
  public   void   handle(contexta   context)   {  
  system.out.println("state   2");  
  }  
  }  
   
  //工厂型  
  //根据状态不通生成不同的state  
   
  //class   statefactory   {  
  // public   static   state   getstateinstance(int   num)   {  
  // state   st   =   null;  
  //  
  // if   (num   ==   1)   {  
  // st   =   new   cstatea1();  
  // }  
  // else   if   (num   ==   2)   {  
  // st   =   new   cstatea2();  
  // }  
  //  
  // return   st;  
  // }  
  //}  
   
  //strategy  
  //跟bridge相类似，就是一种多态的表示  
   
  //visitor  
  //双向引用，使用另外的一个类调用自己的方法,访问自己的数据结构  
  interface   visitor   {  
  void   visitelement(elementd   element);  
  }  
   
  class   cvisitor   implements   visitor   {  
  public   void   visitelement(elementd   element)   {  
  element.operation();  
  }  
  }  
   
  interface   elementd   {  
  void   accept(visitor   visitor);  
   
  void   operation();  
  }  
   
  class   celementd   implements   elementd   {  
  public   void   accept(visitor   visitor)   {  
  visitor.visitelement(this);  
  }  
   
  public   void   operation()   {  
  //实际的操作在这里  
  }  
  }  
   
  class   clientd   {  
  public   static   void   main()   {  
  elementd   elm   =   new   celementd();  
  visitor   vis   =   new   cvisitor();  
   
  vis.visitelement(elm);  
  }  
  }  
   
  //iteraotr  
  //使用迭代器对一个类的数据结构进行顺序迭代  
   
  interface   structure   {  
  interface   iteratora   {  
  void   first();  
   
  boolean   haselement();  
   
  object   next();  
   
  }  
  }  
   
  class   structure1   implements   structure   {  
  object[]   objs   =   new   object[100];  
   
  //使用内部类是为了对struture1的数据结构有完全的访问权  
  class   iteratora1   implements   iteratora   {  
  int   index   =   0;  
   
  public   void   first()   {  
  index   =   0;  
  }  
   
  public   boolean   haselement()   {  
  return   index   <   100;  
  }    
   
  public   object   next()   {  
  object   obj   =   null;  
   
  if   (haselement())   {  
  obj   =   objs[index];  
  index++;  
  }  
   
  return   obj;  
  }  
  }  
  }  
   
  //meditor  
   
  class   a1   {  
  public   void   operation1()   {}  
  public   void   operation2()   {}  
  }  
   
  class   a2   {  
  public   void   operation1()   {}  
  public   void   operation2()   {}  
  }  
   
  class   mediator   {  
  a1   a1;  
  a2   a2;  
   
  public   mediator(a1   a1,   a2   a2)   {  
  this.a1   =   a1;  
  this.a2   =   a2;  
   
  }  
   
  //如果我想实现这个功能我可能会把他放在a1中  
  //但是这样耦合大，我不想在a1中出现a2对象的引用，  
  //所以我使用了mediator作为中介  
  public   void   mmed1()   {  
  a1.operation1();  
  a2.operation2();  
  }  
   
  public   void   mmed2()   {  
  a2.operation1();  
  a1.operation2();  
  }  
  }  
   
  //command  
  //我认为就是将方法转换成了类  
   
  class   receiver   {  
  public   void   action1()   {}  
   
  public   void   action2()   {}  
  }  
   
  interface   command   {  
  void   execute();  
  }  
   
  class   ccommand1   implements   command   {  
  private   receiver   receiver;  
   
  public   ccommand1(receiver   receiver)   {  
  this.receiver   =   receiver;  
  }  
   
  public   void   execute()   {  
  receiver.action1();  
  }  
  }  
   
  class   ccommand2   implements   command   {  
  private   receiver   receiver;  
   
  public   ccommand2(receiver   receiver)   {  
  this.receiver   =   receiver;  
  }  
   
  public   void   execute()   {  
  receiver.action2();  
  }  
  }  
   
  //observer  
  //在这里看似乎这个模式没有什么用  
  //但是如果我有一个线程监控subject，如果subject的状态  
  //发生了变化，则更改observer的状态，并出发一些操作，这样就有实际的意义了  
  //observer与visitor有相似的地方，都存在双向引用  
  //subject可以注册很多observer  
   
  interface   subjectb   {  
  void   attach(observer   observer);  
   
  void   detach(observer   observer);  
   
  void   mynotify();  
   
  int   getstate();  
   
  void   setstate(int   state);  
  }  
   
  class   subjectb1   implements   subjectb   {  
  list   observers   =   new   arraylist();  
  int   state;  
   
  public   void   attach(observer   observer)   {  
  observers.add(observer);  
  }  
   
  public   void   detach(observer   observer)   {  
  observers.remove(observer);  
  }  
   
  public   void   mynotify()   {  
  observer   observer   =   null;  
  iterator   it   =   observers.iterator();  
   
  while   (it.hasnext())   {  
  observer   =   (observer)   it.next();  
  observer.update();  
  }  
  }  
   
  public   int   getstate()   {  
  return   state;  
  }  
   
  public   void   setstate(int   state)   {  
  this.state   =   state;  
  }  
  }  
   
  interface   observer   {  
  void   update();  
  }  
   
  class   observer1   implements   observer   {  
  subjectb   subject;  
  int   state;  
   
  public   observer1(subjectb   subject)   {  
  this.subject   =   subject;  
  }  
   
  public   void   update()   {  
  this.state   =   subject.getstate();  
  }  
   
  public   void   operation()   {  
  //一些基于state的操作  
  }  
  }  
   
  //memento  
  //感觉此模式没有什么大用  
   
  class   memento   {  
  int   state;  
   
  public   int   getstate()   {  
  return   state;  
  }  
   
  public   void   setstate(int   state)   {  
  this.state   =   state;  
  }  
  }  
   
  class   originator   {  
  int   state;  
   
  public   void   setmemento(memento   memento)   {  
  state   =   memento.getstate();  
  }  
   
  public   memento   creatememento()   {  
  memento   memento   =   new   memento();  
  memento.setstate(1);  
  return   memento;  
  }  
   
  public   int   getstate()   {  
  return   state;  
  }  
   
  public   void   setstate(int   state)   {  
  this.state   =   state;  
  }  
  }  
   
  class   caretaker   {  
  memento   memento;  
   
  public   void   savermemento(memento   memento)   {  
  this.memento   =   memento;  
  }  
   
  public   memento   retrievememento()   {  
  return   memento;  
  }  
  }  
   
  //程序最终还是顺序执行的，是由不通部分的操作拼接起来的  
  //将不同类的代码拼接起来是通过引用实现的，有了引用我就  
  //相当于有了一定访问数据结构和方法的能力，这与写在类内部  
  //差不多，例如我想将一个类中的一个方法抽离出去，因为这个方法依赖与此类的数据和其他方法  
  //直接将代码移走是不行的，但如果我们拥有了此类对象的引用，则与写在此类  
  //内部无异，所以我们拥有了引用就可以将此方法移出  
  public   class   tt1   {  
  public   static   void   main(string[]   args)   {  
  }  
  }