java23种设计模式（代码版转）

   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;
      }
  }
// **********结构型模式**********

   // 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
   // 空
// **********行为型模式*************

   // 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)   {
  }
  }

java23种设计模式（代码版转）

你可能感兴趣的:(java23种设计模式（代码版转）)