//**********結(jié)構(gòu)型模式**********  
   
  //Adapter  
  //基本方法有兩種，一種是使用引用一種使用繼承  
  //將不符合標(biāo)準(zhǔn)的接口轉(zhuǎn)成符合標(biāo)準(zhǔn)的接口，接口的修改主要是參數(shù)的增減，  
  //返回值類型,當(dāng)然還有方法名  
  //感覺這就是封裝的另一種表示形式，封裝有用方法封裝(在方法中調(diào)用功能方法)，  
  //用類封裝(先傳入功能方法所在的類的對象，通過調(diào)用此對象的功能方法)  
   
  //使用引用的形式  
  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)   {  
  //具體的業(yè)務(wù)方法實(shí)現(xiàn)在Adaptee中，這個(gè)方法  
  //只起到了接口轉(zhuǎn)換的作用  
  //調(diào)用此方法是通過引用  
  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)   {  
  //調(diào)用此方法是通過繼承  
  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  
  //感覺就是多態(tài)的實(shí)現(xiàn)  
   
  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則直接實(shí)現(xiàn)操作，如果是composite則繼續(xù)遞歸調(diào)用  
  component   =   (Component)   it.next();  
  component.operation();  
  }  
  }  
   
  public   void   add(Component   component)   {  
  components.add(component);  
  }  
   
  public   void   remove(Component   component)   {  
  components.remove(component);  
  }  
  }  
   
  //Decorator  
  //對一個(gè)類的功能進(jìn)行擴(kuò)展時(shí)，我可以使用繼承，但是不夠靈活，所以選用了  
  //另外的一種形式,引用與繼承都可活得對對象的一定的使用能力，而使用引用將更靈活  
  //我們要保證是對原功能的追加而不是修改，否則只能重寫方法，或使用新的方法  
  //注意concrete的可以直接new出來，  
  //而decorator的則需要用一個(gè)另外的decorator對象才能生成對象  
  //使用對象封裝，和公用接口  
  //Decorator鏈上可以有多個(gè)元素  
   
  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  
  //非常實(shí)用的一種設(shè)計(jì)模式，我可以為外部提供感興趣的接口  
   
  class   Obj1   {  
  public   void   ope1()   {}  
  public   void   ope2()   {}  
  }  
   
  class   Obj2   {  
  public   void   ope1()   {}  
  public   void   ope2()   {}  
  }  
   
  class   Facade   {  
  //我得到了一個(gè)簡潔清晰的接口  
  public   void   fdMethod()   {  
  Obj1   obj1   =   new   Obj1();  
  Obj2   obj2   =   new   Obj2();  
   
  obj1.ope1();  
  obj2.ope2();  
    }  
  }  
   
  //Flyweight  
  //空

//**********行為型模式*************  
   
  //Chain   of   Responsibility  
  //與Decorator的實(shí)現(xiàn)形式相類似，  
  //Decorator是在原來的方法之上進(jìn)行添加功能，而  
  //Chain則是判斷信號如果不是當(dāng)前處理的則轉(zhuǎn)交個(gè)下一個(gè)節(jié)點(diǎn)處理  
  //我可以使用if分支來實(shí)現(xiàn)相同的效果，但是不夠靈活，鏈上的每個(gè)節(jié)點(diǎn)是可以替換增加的，相對  
  //比較靈活，我們可以設(shè)計(jì)接口實(shí)現(xiàn)對節(jié)點(diǎn)的增刪操作，而實(shí)現(xiàn)更方便的效果  
  //這個(gè)是一個(gè)鏈狀的結(jié)構(gòu)，有沒有想過使用環(huán)狀結(jié)構(gòu)  
   
  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很類似，只不過他分文終結(jié)符和非終結(jié)符  
   
  //Template   Method  
   
  abstract   class   TemplateMethod   {  
  abstract   void   amd1();  
   
  abstract   void   amd2();  
   
  //此方法為一個(gè)Template   Method方法  
  public   void   tmd()   {  
  amd1();  
  amd2();  
  }  
  }  
   
  //State  
   
  //標(biāo)準(zhǔn)型  
  //狀態(tài)和操作不應(yīng)該耦合在一起  
  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");  
  //也許在一個(gè)狀態(tài)的處理過程中要改變狀態(tài)，例如打開之后立即關(guān)閉這種效果  
  //context.changeStfromNum(2);  
  }  
  }  
   
  class   CStatea2   implements   State   {  
  public   void   handle(Contexta   context)   {  
  System.out.println("state   2");  
  }  
  }  
   
  //工廠型  
  //根據(jù)狀態(tài)不通生成不同的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相類似，就是一種多態(tài)的表示  
   
  //Visitor  
  //雙向引用，使用另外的一個(gè)類調(diào)用自己的方法,訪問自己的數(shù)據(jù)結(jié)構(gòu)  
  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()   {  
  //實(shí)際的操作在這里  
  }  
  }  
   
  class   Clientd   {  
  public   static   void   main()   {  
  Elementd   elm   =   new   CElementd();  
  Visitor   vis   =   new   CVisitor();  
   
  vis.visitElement(elm);  
  }  
  }  
   
  //Iteraotr  
  //使用迭代器對一個(gè)類的數(shù)據(jù)結(jié)構(gòu)進(jìn)行順序迭代  
   
  interface   Structure   {  
  interface   Iteratora   {  
  void   first();  
   
  boolean   hasElement();  
   
  Object   next();  
   
  }  
  }  
   
  class   Structure1   implements   Structure   {  
  Object[]   objs   =   new   Object[100];  
   
  //使用內(nèi)部類是為了對Struture1的數(shù)據(jù)結(jié)構(gòu)有完全的訪問權(quán)  
  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;  
   
  }  
   
  //如果我想實(shí)現(xiàn)這個(gè)功能我可能會把他放在A1中  
  //但是這樣耦合大，我不想在A1中出現(xiàn)A2對象的引用，  
  //所以我使用了Mediator作為中介  
  public   void   mmed1()   {  
  a1.operation1();  
  a2.operation2();  
  }  
   
  public   void   mmed2()   {  
  a2.operation1();  
  a1.operation2();  
  }  
  }  
   
  //Command  
  //我認(rèn)為就是將方法轉(zhuǎn)換成了類  
   
  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  
  //在這里看似乎這個(gè)模式?jīng)]有什么用  
  //但是如果我有一個(gè)線程監(jiān)控Subject，如果Subject的狀態(tài)  
  //發(fā)生了變化，則更改Observer的狀態(tài)，并出發(fā)一些操作，這樣就有實(shí)際的意義了  
  //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  
  //感覺此模式?jīng)]有什么大用  
   
  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;  
  }  
  }  
   
  //程序最終還是順序執(zhí)行的，是由不通部分的操作拼接起來的  
  //將不同類的代碼拼接起來是通過引用實(shí)現(xiàn)的，有了引用我就  
  //相當(dāng)于有了一定訪問數(shù)據(jù)結(jié)構(gòu)和方法的能力，這與寫在類內(nèi)部  
  //差不多，例如我想將一個(gè)類中的一個(gè)方法抽離出去，因?yàn)檫@個(gè)方法依賴與此類的數(shù)據(jù)和其他方法  
  //直接將代碼移走是不行的，但如果我們擁有了此類對象的引用，則與寫在此類  
  //內(nèi)部無異，所以我們擁有了引用就可以將此方法移出  
  public   class   tt1   {  
  public   static   void   main(String[]   args)   {  
  }  
  }