23设计模式

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;   
      }   
  }
分类: 技术随笔, Java
绿色通道：好文要顶关注我收藏该文与我联系 
落花人独立
关注 - 0
粉丝 - 4
+加关注
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)   {   
  }   
  }