设计模式

  1. package lq.test;   
  2.   
  3. import java.io.*;   
  4. import java.util.*;   
  5.   
  6. //*********创建型模式***************   
  7.   
  8. //factory method 1   
  9. //1具体的构造算法,和2构造出的具体产品由子类实现     
  10. interface Product {   
  11. }   
  12.   
  13. //或者我也提供一个工厂的接口,由这个抽象类来继承它   
  14.   
  15. abstract class Factory {   
  16.     abstract public Product fmd();;   
  17.        
  18.     //我认为这个方方法的存在是,是对FactoryMethod方法的补充   
  19.     //例如可以为生成的对象赋值,计算为生成对象应付何值,前后的日值   
  20.     //且这些都是公用的,生成产品的最主要算法还是在FactoryMethod中,   
  21.     //这个方法只是起辅助作用,这也是一种思维方法,将具体的算法实现在一个方法中   
  22.     //而我不直接调用此方法,而使用另外的一个方法封装它,等到了更灵活的效果,而   
  23.     //子类需实现的内容是FactoryMethod   
  24.     //此方法是一个TemplateMethod   
  25.     public Product creat(); {   
  26.         Product pd = null;   
  27.            
  28.         System.out.println("before operation");;   
  29.            
  30.         pd = fmd();;   
  31.            
  32.         System.out.println("end operation");;   
  33.        
  34.         return pd;   
  35.     }   
  36. }   
  37.   
  38. class Product1 implements Product {   
  39. }   
  40.   
  41. class Factory1 extends Factory {   
  42.     public Product fmd(); {   
  43.         Product pd = new Product1();;   
  44.         return pd;   
  45.     }   
  46. }   
  47.   
  48. //FactroyMethod 2   
  49. //这种方式简单实用   
  50. interface Producta {   
  51. }   
  52.   
  53. interface Factorya {   
  54.     Producta create();;   
  55. }   
  56.   
  57. class Producta1 implements Producta {}   
  58.   
  59. class Factorya1 implements Factorya {   
  60.     public Producta create(); {   
  61.         Producta pda = null;   
  62.         pda = new Producta1();;   
  63.         return pda;   
  64.     }    
  65. }   
  66.   
  67. //AbstractFactory   
  68. //AbstractFactory与FactoryMethod的不同在于AbstractFactory创建多个产品   
  69. //感觉此模式没有什么大用   
  70.   
  71. //当然可以还有更多的接口   
  72. interface Apda {}   
  73.   
  74. interface Apdb {}   
  75.   
  76. interface Afactory {   
  77.     Apda createA();;   
  78.     Apdb createB();;   
  79. }   
  80.   
  81. class Apda1 implements Apda {}   
  82.   
  83. class Apdb1 implements Apdb {}   
  84.   
  85. //有几个接口就有几个对应的方法   
  86. class Afactory1 implements Afactory {   
  87.     public Apda createA(); {   
  88.         Apda apda = null;   
  89.         apda = new Apda1();;   
  90.         return apda;   
  91.     }   
  92.        
  93.     public Apdb createB(); {   
  94.         Apdb apdb = null;   
  95.         apdb = new Apdb1();;   
  96.         return apdb;           
  97.     }   
  98. }   
  99.   
  100. //Builder   
  101. //一个产品的生成分为生成部件和组装部件,不同的产品每个部件生成的方式不同   
  102. //而组装的方式相同,部件的生成抽象成接口方法,而组装的方法使用一个TemplateMethod方法   
  103.   
  104. interface Cpda {}   
  105.   
  106. class Cpda1 implements Cpda {}   
  107.   
  108. interface BuilderI {   
  109.     void buildPart1();;   
  110.     void buildPart2();;   
  111.        
  112.     void initPd();;   
  113.     Cpda getPd();;   
  114. }   
  115.   
  116. abstract class BuilderA implements BuilderI {   
  117.     Cpda cpda;   
  118.        
  119.     public Cpda getPd(); {   
  120.         initPd();;   
  121.            
  122.         //对对象的内容进行设置   
  123.         buildPart1();;   
  124.         buildPart2();;   
  125.            
  126.         return cpda;   
  127.     }   
  128. }   
  129.   
  130. class Builder extends BuilderA {   
  131.     public void buildPart1(); {   
  132.         System.out.println(cpda);;   
  133.     }   
  134.        
  135.     public void buildPart2(); {   
  136.         System.out.println(cpda);;   
  137.     }   
  138.        
  139.     public void initPd(); {   
  140.         cpda = new Cpda1();;   
  141.     }      
  142. }   
  143.   
  144. //一个简单的生成产品的实现   
  145. //1   
  146. abstract class Fy {   
  147.     public abstract void med1();;    
  148.        
  149.     static class Fy1 extends Fy {   
  150.         public void med1(); {   
  151.         }   
  152.     }   
  153.        
  154.     public static Fy getInstance(); {   
  155.         Fy fy = new Fy1();;   
  156.         return fy;   
  157.            
  158. //      Fy fy = new Fy1(); {//这种匿名内部类是静态的!!   
  159. //          public void med1(); {   
  160. //          }   
  161. //      };         
  162. //      return fy;   
  163.     }   
  164. }   
  165.   
  166. //2   
  167. interface Pdd {}   
  168.   
  169. class Pdd1 implements Pdd {}   
  170.   
  171. abstract class Fya {   
  172.     public static Pdd getPd(); {   
  173.         Pdd pdd = new Pdd1();;   
  174.         return pdd;   
  175.     }   
  176. }   
  177.   
  178. //Prototype 在java中就是clone,又包含深拷贝和浅拷贝   
  179. class CloneObja {   
  180.     public CloneObja MyClone(); {   
  181.         return new CloneObja();;   
  182.     }   
  183. }   
  184.   
  185. class CloneObjb {   
  186.     public CloneObjb MyClone(); throws Throwable {   
  187.         CloneObjb cobj = null;   
  188.         cobj = (CloneObjb); pcl(this);;   
  189.         return cobj;   
  190.     }      
  191.        
  192.     //深度拷贝算法   
  193.     private Object pcl(Object obj); throws Throwable {   
  194.         ByteArrayOutputStream bao = new ByteArrayOutputStream(1000);;   
  195.         ObjectOutputStream objo = new ObjectOutputStream(bao);;   
  196.         objo.writeObject(obj);;   
  197.            
  198.         ByteArrayInputStream bai = new ByteArrayInputStream(bao.toByteArray(););;   
  199.         ObjectInputStream obji = new ObjectInputStream(bai);;   
  200.            
  201.         Object objr = obji.readObject();;   
  202.         return objr;   
  203.     }    
  204. }   
  205.   
  206. //Singleton   
  207. //一个类只有一个对象,例如一个线程池,一个cache   
  208. class Singleton1 {   
  209.     public static Singleton1 instance = new Singleton1();;     
  210.        
  211.     private Singleton1(); {        
  212.     }   
  213.        
  214.     public static Singleton1 getInstance(); {   
  215.         return instance;   
  216.     }   
  217. }   
  218.   
  219. class Singleton2 {   
  220.     public static Singleton2 instance;   
  221.        
  222.     private Singleton2(); {   
  223.     }   
  224.        
  225. //  public static Singleton2 getInstance(); {          
  226. //      if (instance == null); {   
  227. //          instance = new Singleton2();;   
  228. //      }   
  229. //         
  230. //      return instance;   
  231. //  }   
  232.        
  233.     public static Singleton2 getInstance(); {   
  234.         synchronized(Singleton2.class); {   
  235.             if (instance == null); {   
  236.                 instance = new Singleton2();;   
  237.             }   
  238.         }   
  239.            
  240.         return instance;   
  241.     }   
  242. }   
  243.   
  244. //**********结构型模式**********   
  245.   
  246. //Adapter   
  247. //基本方法有两种,一种是使用引用一种使用继承   
  248. //将不符合标准的接口转成符合标准的接口,接口的修改主要是参数的增减,   
  249. //返回值类型,当然还有方法名   
  250. //感觉这就是封装的另一种表示形式,封装有用方法封装(在方法中调用功能方法);,   
  251. //用类封装(先传入功能方法所在的类的对象,通过调用此对象的功能方法);   
  252.   
  253. //使用引用的形式   
  254. class Adapteea {   
  255.     public void kk(); {}   
  256. }   
  257.   
  258. interface Targeta {   
  259.     String vv(int i, int k);;   
  260. }   
  261.   
  262. class Adaptera implements Targeta{   
  263.     Adapteea ade;   
  264.        
  265.     public Adaptera(Adapteea ade); {   
  266.         this.ade = ade;   
  267.     }   
  268.        
  269.     public String vv(int i, int k); {   
  270.         //具体的业务方法实现在Adaptee中,这个方法   
  271.         //只起到了接口转换的作用   
  272.         //调用此方法是通过引用   
  273.         ade.kk();;   
  274.         return null;   
  275.     }   
  276. }   
  277.   
  278. //使用继承形式的   
  279. class Adapteeb {   
  280.     public void kk(); {}   
  281. }   
  282.   
  283. interface Targetb {   
  284.     String vv(int i, int k);;   
  285. }   
  286.   
  287. class Adapterb extends Adapteeb implements Targetb {   
  288.     public String vv(int i, int k); {   
  289.         //调用此方法是通过继承   
  290.         kk();;   
  291.         return null;   
  292.     }   
  293. }   
  294.   
  295. //Proxy   
  296. interface Subject {   
  297.     void request();;   
  298. }    
  299.   
  300. class realSubject implements Subject {   
  301.     public void request(); {           
  302.         //do the real business   
  303.     }   
  304. }   
  305.   
  306. class Proxy implements Subject {   
  307.     Subject subject;   
  308.        
  309.     public Proxy(Subject subject); {   
  310.         this.subject = subject;   
  311.     }   
  312.        
  313.     public void request(); {   
  314.         System.out.println("do something");;   
  315.            
  316.         subject.request();;   
  317.            
  318.         System.out.println("do something");;   
  319.     }   
  320. }   
  321.   
  322. //Bridge   
  323. //感觉就是多态的实现   
  324.   
  325. interface Imp {   
  326.     void operation();;   
  327. }   
  328.   
  329. class Cimp1 implements Imp {   
  330.     public void operation(); {   
  331.         System.out.println("1");;   
  332.     }   
  333. }   
  334.   
  335. class Cimp2 implements Imp {   
  336.     public void operation(); {   
  337.         System.out.println("2");;   
  338.     }   
  339. }   
  340.   
  341. class Invoker {   
  342.     Imp imp = new Cimp1();;   
  343.        
  344.     public void invoke(); {   
  345.         imp.operation();;   
  346.     }   
  347. }   
  348.   
  349. //Composite   
  350.   
  351. interface Component {   
  352.     void operation();;   
  353.        
  354.     void add(Component component);;   
  355.        
  356.     void remove(Component component);;   
  357. }   
  358.   
  359. class Leaf implements Component {   
  360.     public void operation(); {   
  361.         System.out.println("an operation");;   
  362.     }   
  363.        
  364.     public void add(Component component); {   
  365.         throw new UnsupportedOperationException();;   
  366.     }   
  367.        
  368.     public void remove(Component component); {   
  369.         throw new UnsupportedOperationException();;   
  370.     }   
  371. }   
  372.   
  373. class Composite implements Component {   
  374.     List components = new ArrayList();;   
  375.        
  376.     public void operation(); {   
  377.         Component component = null;   
  378.            
  379.         Iterator it = components.iterator();;          
  380.         while (it.hasNext();); {   
  381.             //不知道此component对象是leaf还是composite,   
  382.             //如果是leaf则直接实现操作,如果是composite则继续递归调用   
  383.             component = (Component); it.next();;   
  384.             component.operation();;   
  385.         }   
  386.     }   
  387.        
  388.     public void add(Component component); {        
  389.         components.add(component);;   
  390.     }   
  391.        
  392.     public void remove(Component component); {         
  393.         components.remove(component);;   
  394.     }   
  395. }   
  396.   
  397. //Decorator   
  398. //对一个类的功能进行扩展时,我可以使用继承,但是不够灵活,所以选用了   
  399. //另外的一种形式,引用与继承都可活得对对象的一定的使用能力,而使用引用将更灵活   
  400. //我们要保证是对原功能的追加而不是修改,否则只能重写方法,或使用新的方法   
  401. //注意concrete的可以直接new出来,   
  402. //而decorator的则需要用一个另外的decorator对象才能生成对象   
  403. //使用对象封装,和公用接口   
  404. //Decorator链上可以有多个元素   
  405.   
  406. interface Componenta {   
  407.     void operation();;   
  408. }   
  409.   
  410. class ConcreteComponent implements Componenta {   
  411.     public void operation(); {   
  412.         System.out.println("do something");;   
  413.     }   
  414. }   
  415.   
  416. class Decorator implements Componenta {   
  417.     private Componenta component;   
  418.        
  419.     public Decorator(Componenta component); {   
  420.         this.component = component;   
  421.     }   
  422.        
  423.     public void operation(); {   
  424.         //do something before   
  425.            
  426.         component.operation();;   
  427.            
  428.         //do something after   
  429.     }   
  430. }   
  431.   
  432. //Facade   
  433. //非常实用的一种设计模式,我可以为外部提供感兴趣的接口   
  434.   
  435. class Obj1 {   
  436.     public void ope1(); {}   
  437.     public void ope2(); {}   
  438. }   
  439.   
  440. class Obj2 {   
  441.     public void ope1(); {}   
  442.     public void ope2(); {}   
  443. }   
  444.   
  445. class Facade {   
  446.     //我得到了一个简洁清晰的接口   
  447.     public void fdMethod(); {   
  448.         Obj1 obj1 = new Obj1();;   
  449.         Obj2 obj2 = new Obj2();;   
  450.            
  451.         obj1.ope1();;   
  452.         obj2.ope2();;   
  453.     }   
  454. }   
  455.   
  456. //Flyweight   
  457. //空   
  458.   
  459. //**********行为型模式*************   
  460.   
  461. //Chain of Responsibility   
  462. //与Decorator的实现形式相类似, &nb
评论
添加红包

请填写红包祝福语或标题

红包个数最小为10个

红包金额最低5元

当前余额3.43前往充值 >
需支付:10.00
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明:

1.余额是钱包充值的虚拟货币,按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载,可以购买VIP、付费专栏及课程。

余额充值