设计模式的理解[两年前的学习笔记及体会]

1、.设计模式 设计模式的理解 研读GOF的"设计模式"和阎宏博士的"Java与模式"已经有一段时间，自己颇有一些体会，自己面向对象和软件设计模式有了一些深入的理解，下面就一步一步开始自己的模式历程吧，从最简单的工厂模式到适配器模式，从 State模式到Decorator模式，一直到最复杂难懂的visitor模式，没有一个模式不体现了前辈的聪明才智，需要我们大家用心去体会和理解 恰当地使用设计模式，能使软件系统的架构更合理，能使将来的维护和修改更方便，能使数据库表结构的设计更合理，恰当的冗余和数据关联，能使我们的软件更多地适应变化，总之，它的作用是不可低估的

2、！1，简单工厂，工厂方法和抽象工厂模式对于简单工厂来说，它的工厂只能是这个样子的public class SimplyFactory /* 静态工厂方法*/public static Prouct factory(String which) throw NoSuchProductExcption if(which.equalIgnoreCase("product1") return new Product1(); else if(which.equalsIgnoreCase("product2") return new Product2(); else

3、if(which.equalsIgnoreCase("product3") return new Product3(); else throw NoSuchProductExcption("NoSuchProduct"); 而对产品Product1,Product2,Product3,可以执行接口Product,也可以不执行接口Product（当然这样不好），这个Product接口只是用来抽象具体product用的public interface Product void productMethod1(); void productMethod2();

4、void productMethod3();对工厂来说，只要有这么一种产品，一般来说就要在工厂里有它的生产的方法， 否则抛出异常，而要工厂生产的话，也必须下达生产什么产品的命令，至少要向工厂发出信号，让工厂足以区分是要生产什么产品，否则工厂是不知道生产哪一种产品，对于简单工厂来说，就是需要在工厂中枚举所有的产品，所以说简单工厂还是非常笨的。 if(which.equalIgnoreCase("product1") 只是用来区分生产什么产品的标记值，（也可以根据产品其它属性来判断，比如产品类型，产品大小，总之能够区分是什么产品的属性，或者是与产品属性相关的变量）或者说标记值是

5、A,生产A产品，或者工厂里定义不是这样的，我偏偏要生产B产品，或者再特殊一些，我偏偏要生产A产品+B产品，那么就要return new ProductA()+new ProductB()了。这样，我们就可以看出一个问题来，如果要能够被简单工厂生产出来，就必须在简单工厂中有能够生产出的它的方法定义，当然还需要有这个具体产品类的定义，就是有class对应，这样确保在简单工厂中new 它的时候不会抛出 NoSuchProduct的Exception.对于工厂方法来说实质上它是让工厂实现了抽象的工厂接口，它把具体怎么生产一种东西，放在具体的工厂去实现了，所谓”延迟到子类中实现“public inter

6、face Creator public Prouct factory();public SubCreator1 implments Creator public Prouct factory() return new ConcreteProduct1(); public SubCreator2 implments Creator public Prouct factory() return new ConcreteProduct2(); 请注意：返回类型是Product型的！这样客户端调用是直接new 一个具体工厂的实例，然后命令它去生产，而对于具体工厂的父类（既工厂接口，接口完全可以改成子类

7、继承父类来实现，只是这样不好，不符合OO的原则），它完全不知道什么产品被生产了，甚至它连那个具体工厂被实例化它都不知道抽象工厂模式 抽象工厂模式主要是用来解决具体产品是有几类产品簇的问题public interface Creator public ProuctA factoryA(); public ProuctB factoryB();public interface ProductA /ProductA 接口public interface ProductB /ProductB 接口public class ConCreator1 implements Creator public Pr

8、ouctA factoryA() return new ConcreteProductA1(); public ProuctB factoryB() return new ConcreteProductB1(); public class ConCreator2 implements Creator public ProuctA factoryA() return new ProductA2(); public ProuctB factoryB() return new ProductB2(); public class ProductA1 implements ProductA public

9、 ProductA1() public class ProductA2 implements ProductA public ProductA2() public class ProductB1 implements ProductB public ProductB1() public class ProductB2 implements ProductB public ProductB2() 实际上是这样的1，两个工厂类ConCreator1，ConCreator2都实现了Creator接口2，ProuctA1,ProductA2都实现了ProductA接口3，ProuctB1,Produc

10、tB2都实现了ProductB接口4，ConCreator1负责生产ProductA类型的产品(包括ProductA1，ProductA2)5，ConCreator2负责生产ProductB类型的产品(包括ProductB1，ProductB2)6，工厂方法也有这样的特征，也就是说Creator不知道什么被生产出来，甚至不知道ConCreator1还是ConCreator2被实例化了，因为client高兴调那一个工厂，就调那一个工厂，就是说工厂能生产什么，对客户端是可见的。甚至还有一种情况，客户端高兴起来就生产了ProductA1,我就不生产ProductA2,因为上面的例子中它们还都是松散的

11、，没有绑定在一起于是提出另外一个例子，也是老提起的电脑类型的例子1，电脑生产商是接口，2，CUP是接口，3，硬盘是接口，4，IBM工厂是制造IBM品牌的电脑的工厂5，DELL工厂是制造DEll品牌的电脑的工厂为讨论方便，就认为电脑=CUP+硬盘；6，所以呀CUP有IBM的CPU和DELL的CPU7，同样硬盘也是有IBM的硬盘和DELL的硬盘8，IBM工厂生产IBM的CPU和IBM的硬盘，绝对不生产DELL的CPU，也不生产DELL的硬盘9，同样DELL工厂也是一样public interface 电脑生产商 public CPU 制造CPU(); public 硬盘 制造硬盘(); publi

12、c 电脑 制造电脑();public interface CPUpublic interface 硬盘public class IBM的CPU implements CPU public IBM的CPU();public class IBM的硬盘 implements 硬盘 public IBM的硬盘();public class DELL的CPU implements CPU public DELL的CPU();public class DELL的硬盘 implements 硬盘 public DELL的硬盘();/下面是IBM工厂public class IBM工厂 implements

13、电脑生产商 private CPU IBM的CPU私有变量=null; private 硬盘 IBM的硬盘私有变量=null; private CPU 制造CPU() return new IBM的CPU(); private 硬盘 制造硬盘() return new IBM的CPU(); public 电脑 制造电脑() try IBM的CPU私有变量=this.制造CPU(); IBM的硬盘私有变量=this.制造硬盘(); if(IBM的CPU私有变量!=null&&IBM的硬盘私有变量!=null) retrun (IBM的CPU私有变量+IBM的硬盘私有变量); /组

14、装成IBM电脑 catch(Exception e) System.out.println("制造IBM电脑失败！"); 这样，客户端无法通过命令单生产出一个CPU来，这样抽象才真正成为一个完整产品的工厂，只要向工厂发出生产的命令，一台完整的电脑就生产出来了，而工厂怎么生产的，生产了哪些部件，外界就看不见了，外界就知道这个工厂是生产IBM电脑整机的工厂！DELL电脑工厂一样/* 下面来改错, 请指出下面片段的错误*/public abstract class Factory public abstract Sample creator(); public abstract

15、Sample2 creator(); public class SimpleFactory extends Factory public Sample creator() . public Sample2 creator() . public class BombFactory extends Factory public Sample creator() . public Sample2 creator() . 思考：上面的代码错在哪？/* 改错结束 */2，builder模式的理解简单地说，就好象我要一座房子住，可是我不知道怎么盖（简单的砌墙，层次较低），也不知道怎么样设计（建几个房间，几

16、个门好看，层次较高），于是我需要找一帮民工，他们会砌墙，还得找个设计师，他知道怎么设计，我还要确保民工听设计师的领导，而设计师本身也不干脏活，重活，光是下命令，这里砌一堵墙，这里砌一扇门，这样民工开始建设，最后，我可以向民工要房子了。在这个过程中，设计师是什么也没有，除了他在脑子里的设计和命令，所以要房子也是跟民工要，记住了！就象国内好多企业上erp一样，上erp，首先得找软件公司呀，找到软件公司后，软件公司说，我只知道怎么写软件，就知道怎么实现，不清楚整个erp的流程。好，那我们还得找一个咨询公司，好，找到德勤了，德勤说好，我要软件怎么做，软件公司怎么做，我就能保证软件能为你们提供erp系统

17、了，哈哈！package builder;public interface Builderpublic void makeWindow();public void makeFloor();public Room getRoom();/*/package builder;public class Designer public Designer() public void order(Builder builder) /这些下等人没有知识，没有文化，哈哈，得听我的 builder.makeWindow(); builder.makeFloor(); public static void main

18、(String args) Designer designer1 = new Designer(); /*/package builder;public class Mingong implements Builder private String window="" private String floor="" public Mingong() public static void main(String args) Mingong mingong1 = new Mingong(); public void makeWindow() window=n

19、ew String("window"); public void makeFloor() floor=new String("floor"); public Room getRoom() if(!window.equals("")&&(!floor.equals("") System.out.println("room ready!"); return new Room(); else return null; /*/package builder;public class Ro

20、om private String window="" private String floor="" public Room() public static void main(String args) Room room1 = new Room(); /*/package builder;public class Client public Client() public static void main(String args) Builder mingong=new Mingong(); Designer designer=new Designe

21、r(); designer.order(mingong); mingong.getRoom(); 3， 适配器模式的理解 public class window的软件 public void run() System.out.print("我运行在window上"); public class linux的软件 public void run1() System.out.print("我运行在linux上"); public class 适配器 extends window的软件 private linux的软件 软件1； /实际上是聚合的使用 publ

22、ic 适配器(linux的软件 软件变量) this.软件1= 软件变量; public void run() 软件1.run1(); 客户段 public class test public static void main(String args) linux的软件 test1=new linux的软件(); 适配器 test2=new 适配器(test1); test2.run(); test2.run1(); /test2 即是window ,又是linux的? /test2是window型的，但是有linux的特征？ 4，Memento 模式理解Memento 模式说的明白一点，就是

23、事情太多，你一个人记不住，找一个人专门帮你记住，用的时候去问一下。就象董事长和秘书一样public class Manage public String next_week; /下个星期的安排public String n_next_week; /下个星期的安排public Manage() public Assistant getMemento() return new Assistant(this); public void setMemento(Assistant assistant)next_week=assistant.next_week;n_next_week=assistant.

24、n_next_week;public class Assistant implements java.io.Serializable public String next_week;public String n_next_week; public Assistant(Manage manage)next_week=manage.next_week;n_next_week=manage.n_next_week;public class Test public Test() public static void main(String args) Manage manage=new Manage

25、();manage.next_week="见客户"manage.n_next_week="见大客户"System.out.println(manage.next_week);System.out.println(manage.n_next_week);Assistant assistant=manage.getMemento();manage.next_week="见1111客户"manage.n_next_week="见111111大客户"System.out.println(manage.next_week);

26、System.out.println(manage.n_next_week);manage.setMemento(assistant);System.out.println(manage.next_week);System.out.println(manage.n_next_week); 5，state模式理解主要是用于状态的变化，就象红绿灯一样如何使用state模式1，要一个状态管理类2，状态接口3，各种子状态实现状态接口State模式的效果 1）它将与特定状态的行为局部化，并且将不同的行为分割开来 2）它使得状态转化显式化 3）State对象可以被共享 state模式中谁定义状态转化？ s

27、tate模式中并没有指定哪一个参与者定义状态转换准则。换句话说，它们可以在Context中定义，也可以在state子类自身指定她们的后继状态以及何时进行转换，后者通常更灵活。public interface Statepublic abstract void handleGreen(State state);public abstract void handleRed(State state);public abstract State getColor(); public class Manage private State state=null; public Manage(State s

28、tate) this.state=state; public void changeToGreen() this.state=new GreenLight(); state.handleGreen(state); public void changeToRed() this.state=new RedLight(); state.handleRed(state); public class GreenLight implements State public State state=null; public State getColor() return state; public void

29、handleGreen(State state) System.out.println("绿灯，前进"); public void handleRed(State state) System.out.println("，"); public class RedLight implements State public State state=null; public State getColor() return state; public void handleGreen(State s) System.out.println(",cc&qu

30、ot;); public void handleRed(State s) System.out.println("红灯，Stop!"); public class Test public Test() public static void main(String args) GreenLight state=new GreenLight(); Manage manage=new Manage(state); manage.changeToRed(); manage.changeToGreen(); manage.changeToGreen(); manage.changeT

31、oGreen(); manage.changeToRed(); GOF片段赏析1，Decrator 模式不同于Adapter模式，因为装饰仅改变对象的职责而不改变它的接口，而适配器将给对象一个全新的接口。2，Composite模式：可以将装饰视为一个退化的、仅有一个组件的组合。然而，装饰仅给对象添加一些额外的职责-它的目的不是在于对象聚集6，Proxy模式public interface Subjectpublib void request();public RealSubject implements Subjectpublic void request()System.out.printl

32、n("正在处理请求！");public class Proxy implements Subjectprivate RealSubject realSubject;public Proxy()public void request() if(realSubject=null) /这里有个单例 realSubject=new RealSubject(); realSubject.request(); System.out.println("哈哈，是我在处理！"); public class Clientpublic static void main(Str

33、ing args)Subject subject=new Proxy();subject.request(); /客户端没有看出来，实际上客户端发出的请求，是Proxy在处理/正常的没有采用代理的话，代码是这个样子的/*Subject subject=new RealSubject();subject.request(); */*思考题*/Proxy模式public interface Subjectpublib void request();public RealSubject implements Subjectpublic void request()System.out.println

34、("正在处理请求！");public class Proxy implements Subjectprivate RealSubject realSubject;public Proxy()public void request() if(realSubject=null) /这里有个单例 realSubject=new RealSubject(); realSubject.request(); System.out.println("哈哈，是我在处理！"); public class Clientpublic static void main(Stri

35、ng args)Subject subject=new Proxy();subject.request(); /客户端没有看出来，实际上客户端发出的请求，是Proxy在处理/正常的没有采用代理的话，代码是这个样子的/*Subject subject=new RealSubject();subject.request(); */7，Protype模式理解比如说有个叫张三的一个人可以复制，呵呵，他还有一本书import java.io.*;import java.io.Serializable;public class Zhangsan implements Cloneable,Serializa

36、ble public String name="zhangsan" public String name1="zhangsan1" / public Book book; public Book book=new Book(); public Zhangsan() ="zhangsan" this.book=new Book(); public Object clone() try return super.clone(); catch(CloneNotSupportedException e) return nul

37、l; public Object deepClone() throws IOException,OptionalDataException,ClassNotFoundException ByteArrayOutputStream bo=new ByteArrayOutputStream(); ObjectOutputStream oo=new ObjectOutputStream(bo); oo.writeObject(this); ByteArrayInputStream bi=new ByteArrayInputStream(bo.toByteArray(); ObjectInputStr

38、eam oi=new ObjectInputStream(bi); return (oi.readObject(); public Book getBook() return book; public String getName() return name; /*-*/import java.io.*;import java.io.Serializable;public class Zhangsan implements Cloneable,Serializable public String name="zhangsan" public String name1=&qu

39、ot;zhangsan1" / public Book book; public Book book=new Book(); public Zhangsan() ="zhangsan" this.book=new Book(); public Object clone() try return super.clone(); catch(CloneNotSupportedException e) return null; public Object deepClone() throws IOException,OptionalDataExcepti

40、on,ClassNotFoundException ByteArrayOutputStream bo=new ByteArrayOutputStream(); ObjectOutputStream oo=new ObjectOutputStream(bo); oo.writeObject(this); ByteArrayInputStream bi=new ByteArrayInputStream(bo.toByteArray(); ObjectInputStream oi=new ObjectInputStream(bi); return (oi.readObject(); public B

41、ook getBook()return book; public String getName() return name; /*-*/ public class test public static void main(String args) Zhangsan person=new Zhangsan(); Zhangsan copy= ( Zhangsan) person.clone(); System.out.println(); System.out.println(); System.out.println("ture of fals

42、e? "+(copy.book=person.book); System.out.println("ture of false? "+(copy.getName()=person.getName(); try Zhangsan deepcopy= (Zhangsan) person.deepClone(); System.out.println("ture of false? "+(deepcopy.getName()=person.getName(); System.out.println("ture of false? "

43、;+(deepcopy.getBook()=person.getBook(); System.out.println("ture of false? "+(deepcopy.book=person.book); System.out.println("title? "+deepcopy.book.title); System.out.println(person.book.pages); System.out.println("title? "+person.book.title); System.out.println(deepco

44、py.book.pages); System.out.println("ture of false? "+(deepcopy.book=person.book); catch (Exception e) System.out.println("error"); 所谓clone有深clone和浅clone博士使用的利用串行化来进行深clone，但是不能保证深clone得到的结果是正确的，这是因为有些不能串行化的，比如说，如果这个zhangsan类它继承了一个abstract class,或者implements 一些接口，而 abstract class或

45、接口有常量等不能串行化的东西，深clone可能会失败（deepClone方法本身没有失败，可是要访问clone的对象的属性时可能会失败！） 8，composite模式理解composite模式就是把一些具有相类似的接口的类组合起来，提供一致的访问接口三个角色1，抽象构件component2，Leaf 3,树枝角色compostiepublic interface Componentpublic Composite getComposite();public void mehod1();import java.until.*;public class Composite implements C

46、omponentprivate Vector vector_com=new vector();public Composite getComposite() return this; public void mehod1()System.out.println("method1 .");Emumeration emumeration=vector_com.elements();while(emumeration.hasMoreElements() (Component ) emumeration.nextElement().method1(); public void ad

47、d(Component component) vector_com.add(component); public void remove(Component component) vector_com.removeElement(component); public class Leaf implements Componentpublic void method1()System.out.println("method1 .");public Composite getComposite()return null;9，迭代子模式理解/*/public abstract c

48、lass Aggregatepublic Iterator createIterator()return null;/*/public interface Iterator void first();void next();boolean isDone();Object currentItem();/*/public class ConcreteAggregate extends Aggregateprivate Object obj="唐僧","孙悟空","猪八戒","沙僧","白龙马",&q

49、uot;妖怪"public Iterator createIterator()return new ConcreteIterator(this); public Object getElement(int index)if(index<obj.length) return objindex; else return null;public int size()return obj.length;/*/public class ConcreteIterator implements Iteratorprivate ConcreteAggregate agg;private int index=0;private int size=0;public Concrete