剑花 烟雨

   江南  好 风景旧曾谙 日出江花红胜火 春来江水绿如蓝 能不忆东北

理想中的建筑师应该是一个诗人、数学家、精通历史、精通心理学、熟悉音乐、了解医学、还要具备天文学和计算的基本知识。
                                                                                                                         ------------------公元前25年,罗马建筑学家Vitruvius
  博客园  :: 首页  :: 新随笔  :: 联系 :: 订阅 订阅  :: 管理

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

Posted on 2008-01-17 10:04  落花人独立  阅读(6774)  评论(2编辑  收藏  举报
  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;  
      }  
  }
count hit
欢迎您到紫阁阳光坐客