对设计模式的理解.docx

《对设计模式的理解.docx》由会员分享，可在线阅读，更多相关《对设计模式的理解.docx（39页珍藏版）》请在taowenge.com淘文阁网|工程机械CAD图纸|机械工程制图|CAD装配图下载|SolidWorks_CaTia_CAD_UG_PROE_设计图分享下载上搜索。

1、编号：时间：2021年x月x日书山有路勤为径，学海无涯苦作舟页码：第39页 共39页 设计模式的理解 研读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 if(which.

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

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

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

6、blic SubCreator1 implent Creator public Prouct factory() return new ConcreteProduct1(); public SubCreator2 implent Creator public Prouct factory() return new ConcreteProduct2(); 请注意：返回类型是Product型的！这样客户端调用是直接new 一个具体工厂的实例，然后命令它去生产，而对于具体工厂的父类（既工厂接口，接口完全可以改成子类继承父类来实现，只是这样不好，不符合OO的原则），它完全不知道什么产品被生产了，甚至它

7、连那个具体工厂被实例化它都不知道抽象工厂模式 抽象工厂模式主要是用来解决具体产品是有几类产品簇的问题public interface Creator public ProuctA factoryA(); public ProuctB factoryB();public interface ProductA /ProductA 接口public interface ProductB /ProductB 接口public class ConCreator1 implements Creator public ProuctA factoryA() return new ConcreteProduct

8、A1(); 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 ProductA1() public class ProductA2 impleme

9、nts 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,ProductB2都实现了ProductB接口4，ConCreator1负责生产1类型的产品(包括

10、ProductA1，ProductB1)5，ConCreator2负责生产2类型的产品(包括ProductA2，ProductB2)6，工厂方法也有这样的特征，也就是说Creator不知道什么被生产出来，甚至不知道ConCreator1还是ConCreator2被实例化了，因为client高兴调那一个工厂，就调那一个工厂，就是说工厂能生产什么，对客户端是可见的。甚至还有一种情况，客户端高兴起来就生产了ProductA1,我就不生产ProductA2,因为上面的例子中它们还都是松散的，没有绑定在一起于是提出另外一个例子，也是老提起的电脑类型的例子1，电脑生产商是接口，2，CUP是接口，3，硬盘是

11、接口，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 硬盘 制造硬盘(); public 电脑 制造电脑();public interface CPUpublic interface 硬盘public

12、 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 电脑生产商 private CPU IBM的CPU私有变量=null; private 硬盘 IBM的硬盘私有变量

13、=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的硬盘私有变量); /组装成IBM电脑 catch(Exception e) System.out.println(制造IBM电脑失败！); 这样，客户端无

14、法通过命令单生产出一个CPU来，这样抽象才真正成为一个完整产品的工厂，只要向工厂发出生产的命令，一台完整的电脑就生产出来了，而工厂怎么生产的，生产了哪些部件，外界就看不见了，外界就知道这个工厂是生产IBM电脑整机的工厂！DELL电脑工厂一样/* 下面来改错, 请指出下面片段的错误*/public abstract class Factory public abstract Sample creator(); public abstract Sample2 creator(); public class SimpleFactory extends Factory public Sample cr

15、eator() . public Sample2 creator() . public class BombFactory extends Factory public Sample creator() . public Sample2 creator() . 思考：上面的代码错在哪？/* 改错结束 */2，builder模式的理解作者：罗鹏 Email:luopeng简单地说，就好象我要一座房子住，可是我不知道怎么盖（简单的砌墙，层次较低），也不知道怎么样设计（建几个房间，几个门好看，层次较高），于是我需要找一帮民工，他们会砌墙，还得找个设计师，他知道怎么设计，我还要确保民工听设计师的领导，

16、而设计师本身也不干脏活，重活，光是下命令，这里砌一堵墙，这里砌一扇门，这样民工开始建设，最后，我可以向民工要房子了。在这个过程中，设计师是什么也没有，除了他在脑子里的设计和命令，所以要房子也是跟民工要，记住了！package builder;public interface Builderpublic void makeWindow();public void makeFloor();public Room getRoom();/*/package builder;public class Designer public Designer() public void order(Builder

17、 builder) /这些下等人没有知识，没有文化，哈哈，得听我的 builder.makeWindow(); builder.makeFloor(); public static void main(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(St

18、ring args) Mingong mingong1 = new Mingong(); public void makeWindow() window=new 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

19、 class Room 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 Designer(); designer

20、.order(mingong); mingong.getRoom(); 3， 适配器模式的理解 作者：罗鹏 email:luopeng public class window的软件 public void run() System.out.print(我运行在window上); public void run1() System.out.print(我运行在window上的run1方法); public class linux的软件 public void run() System.out.print(我运行在linux上); public class 适配器 extends window的软

21、件 private linux的软件 软件1； /实际上是聚合的使用 public 适配器(linux的软件 软件变量) this.软件1= 软件变量; public void run() 软件1.run(); public void run1() System.out.print(“已经被adpter改写了”); 客户段 public class test public static void main(String args) linux的软件 test1=new linux的软件(); 适配器 test2=new 适配器(test1); test2.run(); test2.run1()

22、; 4，Memento 模式理解作者：罗鹏 email:luopengMemento 模式说的明白一点，就是事情太多，你一个人记不住，找一个人专门帮你记住，用的时候去问一下。就象董事长和秘书一样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 assistan

23、t)next_week=assistant.next_week;n_next_week=assistant.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

24、static void main(String args) Manage manage=new Manage();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.n

25、ext_week);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模式理解作者：罗鹏 email: luopeng主要是用于状态的变化，就象红绿灯一样如何使用state模式1，要一个状态管理类2，状态接口3，各种子状态实现状态接口State模式的效果 1）它将与特定状态的行为局部化，并且将不同的行为分割开来 2）它使得状态转化显式化 3）S

26、tate对象可以被共享 state模式中谁定义状态转化？ state模式中并没有指定哪一个参与者定义状态转换准则。换句话说，它们可以在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 sta

27、te=null; public Manage(State state) 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 getColo

28、r() return state; public void 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);

29、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.changeToGreen(); manage.c

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

31、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(String args)Subject subject=new Proxy();subje

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

33、bjectprivate RealSubject realSubject;public Proxy()public void request() if(realSubject=null) /这里有个单例 realSubject=new RealSubject(); realSubject.request(); System.out.println(哈哈，是我在处理！); public class Clientpublic static void main(String args)Subject subject=new Proxy();subject.request(); /客户端没有看出来，实

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

35、public Book book; public Book book=new Book(); public Zhangsan() this.name=zhangsan; this.book=new Book(); public Object clone() try return super.clone(); catch(CloneNotSupportedException e) return null; public Object deepClone() throws IOException,OptionalDataException,ClassNotFoundException ByteAr

36、rayOutputStream 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 Book getBook() return book; publi

37、c String getName() return name; /*-*/import java.io.*;import java.io.Serializable;public class Zhangsan implements Cloneable,Serializable public String name=zhangsan; public String name1=zhangsan1; / public Book book; public Book book=new Book(); public Zhangsan() this.name=zhangsan; this.book=new B

38、ook(); public Object clone() try return super.clone(); catch(CloneNotSupportedException e) return null; public Object deepClone() throws IOException,OptionalDataException,ClassNotFoundException ByteArrayOutputStream bo=new ByteArrayOutputStream(); ObjectOutputStream oo=new ObjectOutputStream(bo); oo

39、.writeObject(this); ByteArrayInputStream bi=new ByteArrayInputStream(bo.toByteArray(); ObjectInputStream oi=new ObjectInputStream(bi); return (oi.readObject(); public Book getBook()return book; public String getName() return name; /*-*/ public class test public static void main(String args) Zhangsan person=new