设计模式总结.docx

1、设计模式总结 1，简单工厂，工厂方法和抽象工厂模式作者：罗鹏 Email：luopeng对于简单工厂来说，它的工厂只能是这个样子的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

2、 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(); void productMetho

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

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

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

6、么产品被生产了，甚至它连那个具体工厂被实例化它都不知道抽象工厂模式 抽象工厂模式主要是用来解决具体产品是有几类产品簇的问题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 Conc

7、reteProductA1(); 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 Produc

8、tA2 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,ProductB2都实现了ProductB接口4，ConCreator1负责

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

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

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

12、 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的硬盘私有变量); /组装成IBM电脑 catch(Exception e) System.out.println(制造IBM电脑失败

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

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

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

16、blic 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(String args) Designer designer1 = new Designer

17、(); /*/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=new String(window); public void makeFloor() floor=new String(floor); p

18、ublic Room getRoom() if(!window.equals()&(!floor.equals() System.out.println(room ready!); return new Room(); else return null; /*/package builder;public class Room private String window=; private String floor=; public Room() public static void main(String args) Room room1 = new Room(); /*/package b

19、uilder;public class Client public Client() public static void main(String args) Builder mingong=new Mingong(); Designer designer=new Designer(); designer.order(mingong); mingong.getRoom(); 3， 适配器模式的理解 作者：罗鹏 email:luopeng public class window的软件 public void run() System.out.print(我运行在window上); public

20、void run1() System.out.print(我运行在window上的run1方法); public class linux的软件 public void run() System.out.print(我运行在linux上); public class 适配器 extends window的软件 private linux的软件 软件1； /实际上是聚合的使用 public 适配器(linux的软件 软件变量) this.软件1= 软件变量; public void run() 软件1.run(); public void run1() System.out.print(“已经被a

21、dpter改写了”); 客户段 public class test public static void main(String args) linux的软件 test1=new linux的软件(); 适配器 test2=new 适配器(test1); test2.run(); test2.run1(); 4，Memento 模式理解作者：罗鹏 email:luopengMemento 模式说的明白一点，就是事情太多，你一个人记不住，找一个人专门帮你记住，用的时候去问一下。就象董事长和秘书一样public class Manage public String next_week; /下个星期

22、的安排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.n_next_week;public class Assistant implements java.io.Serializable public String next_week;pu

23、blic 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();manage.next_week=见客户;manage.n_next_week=见大客户;System.out.println(manage.next_week);System.o

24、ut.println(manage.n_next_week);Assistant assistant=manage.getMemento();manage.next_week=见1111客户;manage.n_next_week=见111111大客户;System.out.println(manage.next_week);System.out.println(manage.n_next_week);manage.setMemento(assistant);System.out.println(manage.next_week);System.out.println(manage.n_next

25、_week); 5，state模式理解作者：罗鹏 email: luopeng主要是用于状态的变化，就象红绿灯一样如何使用state模式1，要一个状态管理类2，状态接口3，各种子状态实现状态接口State模式的效果 1）它将与特定状态的行为局部化，并且将不同的行为分割开来 2）它使得状态转化显式化 3）State对象可以被共享 state模式中谁定义状态转化？ state模式中并没有指定哪一个参与者定义状态转换准则。换句话说，它们可以在Context中定义，也可以在state子类自身指定她们的后继状态以及何时进行转换，后者通常更灵活。public interface Statepublic a

26、bstract void handleGreen(State state);public abstract void handleRed(State state);public abstract State getColor(); public class Manage private State state=null; public Manage(State state) this.state=state; public void changeToGreen() this.state=new GreenLight(); state.handleGreen(state); public voi

27、d changeToRed() this.state=new RedLight(); state.handleRed(state); public class GreenLight implements State public State state=null; public State getColor() 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); public void handleRed(State s) System.ou