六种创建型设计模式总结.docx
《六种创建型设计模式总结.docx》由会员分享，可在线阅读，更多相关《六种创建型设计模式总结.docx（14页珍藏版）》请在冰豆网上搜索。
六种创建型设计模式总结
创建型模式分为六种：
1、单例模式：
在系统中只能形成类的一个对象。
2、工厂方法模式：
按类型创建出一个笼统的对象。
3、抽象工厂模式：
按多级类型创建笼统的对象。
4、模板模式：
在抽象类中实现一部分代码，通过继承方式使子类共享，避免代码复制。
5、建造模式：
按顺序一步步创建出复杂对象。
6、原型模式：
利用克隆方法，快速创建出一模一样的对象。
以下为了节省篇幅，忽略了一些程序细节和严谨性，包括：
●忽略了部分getter和setter方法。
●忽略了必须的try…catch
●忽略了一些原本应该从接口实现或从抽象类集成的代码
（一）单例模式
确保在整个系统中仅有该类的一个对象，该对象对于整个系统来说时全局的。
//单例类
publicclassSingleton
{
//在类中自己初始化一个static且final的自己对象。
privatestaticfinalSingletonsingleton=newSingleton（）;
//将类的构造函数定义为私有的，以避免被其他类new出来一个对象。
privateSingleton（）{}
//设置一个静态成员函数getInstance（），用于返回对象本身。
publicstaticSingletongetInstance（）
{
returnsingleton;
}
publicstaticvoiddoSomething（）{/*dosomething…*/}
}
//高层调用类
publicclassClient
{
publicstaticvoidmain（String[]args）
{
//不是通过new来的，而是通过Singleton.getInstance（）来的
Singletonsingleton=Singleton.getInstance（）;
singleton.doSomething（）;
}
}
优点：
节省资源、可以做全局变量使用。
缺点：
没有实现接口扩展困难、可能会导致并发性问题。
注意：
单例对象不要实现Cloneable接口。
Spring框架中的每个Bean默认都是单例的，由Spring容器管理Bean生命期，并可以避免并发性问题。
（二）工厂方法模式
定义一个用于创建对象的接口，让子类决定实例化的是哪一个接口实现类。
//抽象产品类
publicabstractclassAbstractProduct
{
publicabstractvoidmethod（）{}
}
//具体产品1
publicclassProduct1extendsAbstractProduct
{
@override
publicvoidmethod（）{System.out.println（“我是产品1”）;}
}
//具体产品2
publicclassProduct2extendsAbstractProduct
{
@override
publicvoidmethod（）{System.out.println（“我是产品2”）;}
}
//抽象工厂类
publicabstractclassAbstractFactory
{
//可创建所有从AbstractProduct继承的产品
publicabstractTcreateProduct（Classc）;
}
//具体工厂类
publicclassFactoryextendsAbstractFactory
{
@override
publicTcreateProduct（Classc）
{
//如果不用反射，也可向工厂方法传入参数，根据参数通过if来分别创建不同产品的对象
//但如果不用反射，则每增加一种具体产品，均需要修改具体工厂类
AbstractProductproduct=（AbstractProduct）Class.forName（c.getName）.newInstance（）;
return（T）product;
}
}
//高层调用类
publicclassClient
{
publicstaticvoidmain（String[]args）
{
//不是通过new来的，而是通过Singleton.getInstance（）来的
AbstractFactoryfactory=newFactory（）;
AbstractProductproduct1=factory.createProduct（Product1.class）;
AbstractProductproduct2=factory.createProduct（Product2.class）;
product1.method（）;
product2.method（）;
}
}
输出结果：
-----------------
我是产品1
我是产品2
-----------------
变化：
可将Factory扩展为Factory1和Factory2，内部只是简单的returnnewProduct1（）;和returnnewProduct2（）;。
就变成多工厂模式，每个工厂只创建一种具体类的对象，具体类的数量与工厂类的数量相等。
（三）抽象工厂模式
抽象工厂模式是对工厂方法模式的升级，每个工厂类中有多个工厂方法。
适用于“产品族→产品型号”的结构，有多少个产品族则工厂类中就有多少个工厂方法，有多少产品型号就有多少个具体工厂类。
//抽象产品族A
publicabstractclassAbstractProductA
{
publicabstractvoidmethod（）{}
}
//产品族A的具体产品1
publicclassProductA1extendsAbstractProductA
{
@override
publicvoidmethod（）{System.out.println（“我是产品A1”）;}
}
//产品族A的具体产品2
publicclassProductA2extendsAbstractProductA
{
@override
publicvoidmethod（）{System.out.println（“我是产品A2”）;}
}
//产品族B及其具体产品类似，不再赘述。
。
。
//抽象工厂类，有几个产品族，就需要有几个工厂方法
publicabstractclassAbstractFactory
{
//创建产品族A的工厂方法
publicabstractAbstractProductAcreateProductA（）;
//创建产品族B的工厂方法
publicabstractAbstractProductBcreateProductB（）;
}
//有几个产品型号，就需要有几个具体工厂类
//具体工厂类1
publicclassFactory1extendsAbstractFactory
{
//创建产品族A的工厂方法
@override
publicAbstractProductAcreateProductA（）
{
returnnewProductA1（）;
}
//创建产品族B的工厂方法
@override
publicAbstractProductBcreateProductB（）
{
returnnewProductB1（）;
}
}
//具体工厂类2
publicclassFactory2extendsAbstractFactory
{
//创建产品族A的工厂方法
@override
publicAbstractProductAcreateProductA（）
{
returnnewProductA2（）;
}
//创建产品族B的工厂方法
@override
publicAbstractProductBcreateProductB（）
{
returnnewProductB2（）;
}
}
//高层调用类
publicclassClient
{
publicstaticvoidmain（String[]args）
{
//不是通过new来的，而是通过Singleton.getInstance（）来的
AbstractFactoryfactory1=newFactory1（）;
AbstractFactoryfactory2=newFactory2（）;
AbstractProductAproductA1=factory1.createProductA;
AbstractProductAproductA2=factory1.createProductA;
AbstractProductBproductB1=factory1.createProductB;
AbstractProductBproductB2=factory1.createProductB;
productA1.method（）;
productA2.method（）;
productB2.method（）;
productB2.method（）;
}
}
输出结果：
-----------------
我是产品A1
我是产品A2
我是产品B1
我是产品B2
-----------------
优点：
产品型号扩展简单，只需要增加一个新的具体工厂实现类即可。
缺点：
产品族扩展困难，需要对抽象工厂和每个具体工厂实现类增加方法。
（四）模板模式
模板模式其实就是利用抽象类的继承。
由抽象类定义出方法行为接口，并通过抽象类中的具体方法将通用的行为顺序实现，避免在实现类中编写重复代码。
//抽象产品类，这是一个产品模板
publicabstractclassAbstractProduct
{
//产品的基本行为方法接口，由于并不提供给高层模块调用，因此使用protected类型
protectedabstractvoidmethod1（）;
protectedabstractvoidmethod2（）;
//产品模板的具体实现类，用于绑定相同的行为顺序，为了防止被覆盖，所以加上final
publicabstractfinalvoidmethod（）;
{
this.method1（）;
this.method2（）;
}
}
//具体产品实现类，只需要实现每种产品的基本行为方法，行为的执行顺序已由模板类提供
publicclassProdut1extendsAbstractProduct
{
@override
protectedvoidmethod1（）{System.out.println（“产品1做行为1”）;}
@override
protectedvoidmethod2（）{System.out.println（“产品1做行为2”）;}
}
publicclassProdut2extendsAbstractProduct
{
@override
protectedvoidmethod1（）{System.out.println（“产品2做行为1”）;}
@override
protectedvoidmethod2（）{System.out.println（“产品2做行为2”）;}
}
//高层调用类
publicclassClient
{
publicstaticvoidmain（String[]args）
{
//不是通过new来的，而是通过Singleton.getInstance（）来的
AbstractProductproduct1=newProduct1（）;
AbstractProductproduct2=newProduct1（）;
System.out.println（“产品1开始做动作…”）;
product1.method（）;//调用模板方法，按顺序执行行为
System.out.println（“产品2开始做动作…”）;
product2.method（）;//调用模板方法，按顺序执行行为
}
}
输出结果：
-----------------
产品1开始做动作…
产品1做行为1
产品1做行为2
产品2开始做动作…
产品2做行为1
产品2做行为2
-----------------
优点：
把不变的算法封装到父类，避免代码拷贝，便于维护。
缺点：
行为顺序在父类中，不太好理解，且具体产品的行为顺序一旦改变，父类的模板方法将无法再使用，需要在子类中覆盖父类的方法，子类将变得“有个性”。
（五）建造模式
工厂模式只是简单返回一个类的对象，主要用于替代new。
相对于工厂模式来说，建造模式不但生成一个对象，同时对对象的细节按顺序进行装配，使之丰满。
//具体产品类，为省略篇幅，忽略了抽象产品类
publicclassProduct
{
privateStringpart1;
privateStringpart2;
/*成员变量的getter和setter方法略*/
}
//抽象建造者类
publicabstractclassAbstractBuilder
{
//对产品零件进行细节设置的方法，方法个数按需编写
publicabstractvoidsetPart1（）;
publicabstractvoidsetPart2（）;
//建造者将产品成品返回的方法
publicabstractProductgetProduct（）;
}
//具体建造者类
publicclassBuilderextendsAbstractBuilder
{
//生成一个空产品，此处用new，也可使用工厂方法
privateProductproduct=newProduct（）;
//对产品零件进行装配，使空产品变得丰满
@override
publicvoidsetPart1（StringpartName）
{
product.setPart1（partName）;
System.out.println（“产品零件1本次使用的型号是：
”+partName）;
}
@override
publicvoidsetPart1（StringpartName）
{
product.setPart1（partName）;
System.out.println（“产品零件2本次使用的型号是：
”+partName）;
}
//将成品返回
@override
publicProductgetProduct（）
{
returnproduct;
}
}
//经理类（工头类，导演类），用于封装建造顺序，避免高层模块与建造者耦合打乱建造顺序
//高层模块相当于客户，经理类相当于项目经理，建造者相当于程序员，客户自然是不适合与程序员直接沟通的，需要项目经理充当对接通道
publicclassManager
{
//声明建造者，有了经理自然要给经理分配个小弟
privateAbstractBuilderbuilder=newBuilder（）;
//经理可以指导建造者建造两种型号的产品，具体型号数量可根据实际情况决定
publicProductgetProductA（）
{
System.out.println（“开始建造产品A…”）;
builder.setPart1（“主板A”）;
builder.setPart2（“芯片A”）;
returnbuilder.getProduct（）;
}
publicProductgetProductB（）
{
System.out.println（“开始建造产品B…”）;
builder.setPart1（“主板B”）;
builder.setPart2（“芯片B”）;
returnbuilder.getProduct（）;
}
}
//高层调用类（客户类）
publicclassClient
{
publicstaticvoidmain（String[]args）
{
//客户只需要与经理打交道
Managermanager=newManager（）;
//客户只要结果，并不知道经理的小弟是谁，也不知道是怎么建造的
ProductproductA=manager.getProductA（）;
ProductproductB=manager.getProductB（）;
}
}
输出结果：
-----------------
开始建造产品A…
产品零件1本次使用的型号是：
主板A
产品零件2本次使用的型号是：
芯片A
开始建造产品B…
产品零件1本次使用的型号是：
主板B
产品零件2本次使用的型号是：
芯片B
-----------------
优点：
适合建造复杂对象，却对高层模块屏蔽建造细节。
（六）原型模式
在java中，类实现Cloneable接口，并覆盖clone（）方法，创建对象时即可通过拷贝的方式来创建，这就是原型模式。
//具体产品类，实现了Cloneable接口，为省略篇幅，忽略了抽象产品类
publicclassProductimplementsCloneable
{
//覆盖clone方法，使对象可以拷贝
@Override
publicProductclone（）
{
Productproduct=（Product）super.clone（）;
returnproduct;
}
//产品的普通方法
publicvoidmethod（）{System.out.println（“我被复制出来了！
”）;}
}
//高层调用类
publicclassClient
{
publicstaticvoidmain（String[]args）
{
System.out.println（“先初始化原型产品…”）;
//初始化一个原型产品
ProductproductProtoType=newProduct（）;
//通过原型产品克隆出5个产品
for（inti=0;i<5;++i）
{
System.out.print（“克隆出第”+i+“个产品：
”）;
Productproduct=productProtoType.clone（）;
product.method（）;
}
}
}
输出结果：
-----------------
先初始化原型产品…
克隆出第1个产品：
我被复制出来了！
克隆出第2个产品：
我被复制出来了！
克隆出第3个产品：
我被复制出来了！
克隆出第4个产品：
我被复制出来了！
克隆出第5个产品：
我被复制出来了！
-----------------
优点：
对象生成性能比new来的快得多，不执行构造函数逃避约束。
注意：
浅拷贝和深拷贝的问题，并且类的成员变量不要加final，否则无法拷贝。
原型模式一般和工厂模式一起使用，在工厂方法内采用原型模式生成对象。
升级会员 