六种创建型设计模式总结.docx

1、六种创建型设计模式总结创建型模式分为六种：1、 单例模式：在系统中只能形成类的一个对象。2、 工厂方法模式：按类型创建出一个笼统的对象。3、 抽象工厂模式：按多级类型创建笼统的对象。4、 模板模式：在抽象类中实现一部分代码，通过继承方式使子类共享，避免代码复制。5、 建造模式：按顺序一步步创建出复杂对象。6、 原型模式：利用克隆方法，快速创建出一模一样的对象。以下为了节省篇幅，忽略了一些程序细节和严谨性，包括： 忽略了部分getter和setter方法。 忽略了必须的trycatch 忽略了一些原本应该从接口实现或从抽象类集成的代码（一） 单例模式确保在整个系统中仅有该类的一个对象，该对象对于

2、整个系统来说时全局的。/单例类public class Singleton /在类中自己初始化一个static且final的自己对象。 private static final Singleton singleton = new Singleton(); /将类的构造函数定义为私有的，以避免被其他类new出来一个对象。 private Singleton() /设置一个静态成员函数getInstance()，用于返回对象本身。 public static Singleton getInstance() return singleton; public static void doSomethi

3、ng() /* do something */ /高层调用类public class Clientpublic static void main(String args) /不是通过new来的，而是通过Singleton.getInstance()来的 Singleton singleton = Singleton.getInstance(); singleton.doSomething();优点：节省资源、可以做全局变量使用。缺点：没有实现接口扩展困难、可能会导致并发性问题。注意：单例对象不要实现Cloneable接口。Spring框架中的每个Bean默认都是单例的，由Spring容器管理B

4、ean生命期，并可以避免并发性问题。（二） 工厂方法模式定义一个用于创建对象的接口，让子类决定实例化的是哪一个接口实现类。/抽象产品类public abstract class AbstractProduct public abstract void method() /具体产品1public class Product1 extends AbstractProduct override public void method() System.out.println(“我是产品1”); /具体产品2public class Product2 extends AbstractProduct ov

5、erridepublic void method() System.out.println(“我是产品2”); /抽象工厂类public abstract class AbstractFactory /可创建所有从AbstractProduct继承的产品public abstract T createProduct(Class c); /具体工厂类public class Factory extends AbstractFactory override public T createProduct(Class c) /如果不用反射，也可向工厂方法传入参数，根据参数通过if来分别创建不同产品的对

6、象 /但如果不用反射，则每增加一种具体产品，均需要修改具体工厂类 AbstractProduct product = (AbstractProduct)Class.forName(c.getName).newInstance(); return (T) product;/高层调用类public class Clientpublic static void main(String args) /不是通过new来的，而是通过Singleton.getInstance()来的 AbstractFactory factory = new Factory(); AbstractProduct produ

7、ct1 = factory.createProduct(Product1.class); AbstractProduct product2 = factory.createProduct(Product2.class); product1.method(); product2.method();输出结果：-我是产品1我是产品2-变化：可将Factory扩展为Factory1和Factory2，内部只是简单的return new Product1(); 和return new Product2(); 。就变成多工厂模式，每个工厂只创建一种具体类的对象，具体类的数量与工厂类的数量相等。（三） 抽象

8、工厂模式抽象工厂模式是对工厂方法模式的升级，每个工厂类中有多个工厂方法。适用于“产品族产品型号”的结构，有多少个产品族则工厂类中就有多少个工厂方法，有多少产品型号就有多少个具体工厂类。/抽象产品族Apublic abstract class AbstractProductA public abstract void method() /产品族A的具体产品1public class ProductA1 extends AbstractProductA override public void method() System.out.println(“我是产品A1”); /产品族A的具体产品2pu

9、blic class ProductA2 extends AbstractProductA overridepublic void method() System.out.println(“我是产品A2”); /产品族B及其具体产品类似，不再赘述。/抽象工厂类，有几个产品族，就需要有几个工厂方法public abstract class AbstractFactory /创建产品族A的工厂方法public abstract AbstractProductA createProductA();/创建产品族B的工厂方法public abstract AbstractProductB createP

10、roductB(); /有几个产品型号，就需要有几个具体工厂类/具体工厂类1public class Factory1 extends AbstractFactory /创建产品族A的工厂方法 overridepublic AbstractProductA createProductA() return new ProductA1();/创建产品族B的工厂方法 overridepublic AbstractProductB createProductB() return new ProductB1();/具体工厂类2public class Factory2 extends AbstractF

11、actory /创建产品族A的工厂方法 overridepublic AbstractProductA createProductA() return new ProductA2();/创建产品族B的工厂方法 overridepublic AbstractProductB createProductB() return new ProductB2();/高层调用类public class Clientpublic static void main(String args) /不是通过new来的，而是通过Singleton.getInstance()来的 AbstractFactory fact

12、ory1 = new Factory1(); AbstractFactory factory2 = new Factory2(); AbstractProductA productA1 = factory1.createProductA; AbstractProductA productA2 = factory1.createProductA; AbstractProductB productB1 = factory1.createProductB; AbstractProductB productB2 = factory1.createProductB; productA1.method()

13、; productA2.method(); productB2.method(); productB2.method();输出结果：-我是产品A1我是产品A2我是产品B1我是产品B2-优点：产品型号扩展简单，只需要增加一个新的具体工厂实现类即可。缺点：产品族扩展困难，需要对抽象工厂和每个具体工厂实现类增加方法。（四） 模板模式模板模式其实就是利用抽象类的继承。由抽象类定义出方法行为接口，并通过抽象类中的具体方法将通用的行为顺序实现，避免在实现类中编写重复代码。/抽象产品类，这是一个产品模板public abstract class AbstractProduct /产品的基本行为方法接口，由于

14、并不提供给高层模块调用，因此使用protected类型 protected abstract void method1(); protected abstract void method2(); /产品模板的具体实现类，用于绑定相同的行为顺序，为了防止被覆盖，所以加上final public abstract final void method(); this.method1(); this.method2();/具体产品实现类，只需要实现每种产品的基本行为方法，行为的执行顺序已由模板类提供public class Produt1 extends AbstractProduct overrid

15、e protected void method1() System.out.println(“产品1做行为1”); override protected void method2() System.out.println(“产品1做行为2”); public class Produt2 extends AbstractProduct override protected void method1() System.out.println(“产品2做行为1”); override protected void method2() System.out.println(“产品2做行为2”); /高

16、层调用类public class Clientpublic static void main(String args)/不是通过new来的，而是通过Singleton.getInstance()来的AbstractProduct product1 = new Product1(); AbstractProduct product2 = new Product1();System.out.println(“产品1开始做动作”);product1.method(); /调用模板方法，按顺序执行行为System.out.println(“产品2开始做动作”);product2.method(); /

17、调用模板方法，按顺序执行行为输出结果：-产品1开始做动作产品1做行为1产品1做行为2产品2开始做动作产品2做行为1产品2做行为2-优点：把不变的算法封装到父类，避免代码拷贝，便于维护。缺点：行为顺序在父类中，不太好理解，且具体产品的行为顺序一旦改变，父类的模板方法将无法再使用，需要在子类中覆盖父类的方法，子类将变得“有个性”。（五） 建造模式工厂模式只是简单返回一个类的对象，主要用于替代new。相对于工厂模式来说，建造模式不但生成一个对象，同时对对象的细节按顺序进行装配，使之丰满。/具体产品类，为省略篇幅，忽略了抽象产品类public class Product private String

18、part1; private String part2; /* 成员变量的getter和setter方法略 */抽象建造者类public abstract class AbstractBuilder /对产品零件进行细节设置的方法，方法个数按需编写 public abstract void setPart1(); public abstract void setPart2(); /建造者将产品成品返回的方法 public abstract Product getProduct();/具体建造者类public class Builder extends AbstractBuilder /生成一个

19、空产品，此处用new，也可使用工厂方法 private Product product = new Product(); /对产品零件进行装配，使空产品变得丰满overridepublic void setPart1(String partName) product.setPart1(partName);System.out.println(“产品零件1本次使用的型号是：” + partName); overridepublic void setPart1(String partName) product.setPart1(partName);System.out.println(“产品零件2

20、本次使用的型号是：” + partName); /将成品返回overridepublic Product getProduct() return product; /经理类（工头类，导演类），用于封装建造顺序，避免高层模块与建造者耦合打乱建造顺序/高层模块相当于客户，经理类相当于项目经理，建造者相当于程序员，客户自然是不适合与程序员直接沟通的，需要项目经理充当对接通道public class Manager /声明建造者，有了经理自然要给经理分配个小弟 private AbstractBuilder builder = new Builder(); /经理可以指导建造者建造两种型号的产品，具体

21、型号数量可根据实际情况决定 public Product getProductA() System.out.println(“开始建造产品A”); builder.setPart1(“主板A”); builder.setPart2(“芯片A”); return builder.getProduct(); public Product getProductB() System.out.println(“开始建造产品B”); builder.setPart1(“主板B”); builder.setPart2(“芯片B”); return builder.getProduct();/高层调用类（客户

22、类）public class Clientpublic static void main(String args) /客户只需要与经理打交道 Manager manager = new Manager (); /客户只要结果，并不知道经理的小弟是谁，也不知道是怎么建造的 Product productA = manager.getProductA(); Product productB = manager.getProductB();输出结果：-开始建造产品A产品零件1本次使用的型号是：主板A产品零件2本次使用的型号是：芯片A开始建造产品B产品零件1本次使用的型号是：主板B产品零件2本次使用的

23、型号是：芯片B-优点：适合建造复杂对象，却对高层模块屏蔽建造细节。（六） 原型模式在java中，类实现Cloneable接口，并覆盖clone()方法，创建对象时即可通过拷贝的方式来创建，这就是原型模式。/具体产品类，实现了Cloneable接口，为省略篇幅，忽略了抽象产品类public class Product implements Cloneable /覆盖clone方法，使对象可以拷贝 Override public Product clone() Product product = (Product)super.clone(); return product;/产品的普通方法 pub

24、lic void method() System.out.println(“我被复制出来了！”); /高层调用类public class Clientpublic static void main(String args) System.out.println(“先初始化原型产品”); /初始化一个原型产品 Product productProtoType = new Product(); /通过原型产品克隆出5个产品 for(int i=0; i5; +i) System.out.print(“克隆出第” + i + “个产品：”); Product product = productProtoType.clone(); product.method();输出结果：-先初始化原型产品克隆出第1个产品：我被复制出来了！克隆出第2个产品：我被复制出来了！克隆出第3个产品：我被复制出来了！克隆出第4个产品：我被复制出来了！克隆出第5个产品：我被复制出来了！-优点：对象生成性能比new来的快得多，不执行构造函数逃避约束。注意：浅拷贝和深拷贝的问题，并且类的成员变量不要加final，否则无法拷贝。原型模式一般和工厂模式一起使用，在工厂方法内采用原型模式生成对象。