设计模式代码样例文档格式.docx
《设计模式代码样例文档格式.docx》由会员分享，可在线阅读，更多相关《设计模式代码样例文档格式.docx（72页珍藏版）》请在冰豆网上搜索。
"
）;
5.
}
6.}
SmsSender
sms
sender!
6.
7.}
最后，建工厂类：
SendFactory
produce（String
type）
if
（"
mail"
.equals（type））
return
new
MailSender（）;
else
sms"
7.
SmsSender（）;
8.
9.
请输入正确的类型!
10.
null;
11.
12.
13.}
我们来测试下：
FactoryTest
static
main（String[]
args）
factory
=
SendFactory（）;
sender
factory.produce（"
sender.Send（）;
8.}
输出：
thisissmssender!
22、多个工厂方法模式，是对普通工厂方法模式的改进，在普通工厂方法模式中，如果传递的字符串出错，则不能正确创建对象，而多个工厂方法模式是提供多个工厂方法，分别创建对象。
关系图：
将上面的代码做下修改，改动下SendFactory类就行，如下：
viewplaincopypublic
{
produceMail（）{
1.
produceSms（）{
测试类如下：
factory.produceMail（）;
thisismailsender!
33、静态工厂方法模式，将上面的多个工厂方法模式里的方法置为静态的，不需要创建实例，直接调用即可。
produceMail（）{
10.}
SendFactory.produceMail（）;
总体来说，工厂模式适合：
凡是出现了大量的产品需要创建，并且具有共同的接口时，可以通过工厂方法模式进行创建。
在以上的三种模式中，第一种如果传入的字符串有误，不能正确创建对象，第三种相对于第二种，不需要实例化工厂类，所以，大多数情况下，我们会选用第三种——静态工厂方法模式。
2、抽象工厂模式（AbstractFactory）
工厂方法模式有一个问题就是，类的创建依赖工厂类，也就是说，如果想要拓展程序，必须对工厂类进行修改，这违背了闭包原则，所以，从设计角度考虑，有一定的问题，如何解决？
就用到抽象工厂模式，创建多个工厂类，这样一旦需要增加新的功能，直接增加新的工厂类就可以了，不需要修改之前的代码。
因为抽象工厂不太好理解，我们先看看图，然后就和代码，就比较容易理解。
请看例子：
两个实现类：
两个工厂类：
SendMailFactory
Provider
produce（）{
SendSmsFactory
Provider{
produce（）
在提供一个接口：
produce（）;
测试类：
Test
provider
SendMailFactory（）;
provider.produce（）;
其实这个模式的好处就是，如果你现在想增加一个功能：
发及时信息，则只需做一个实现类，实现Sender接口，同时做一个工厂类，实现Provider接口，就OK了，无需去改动现成的代码。
这样做，拓展性较好！
抽象工厂：
提供一个创建一系列相关或相互依赖对象的接口，而无需指定它们具体的类
3、建造者模式（Builder）
工厂类模式提供的是创建单个类的模式，而建造者模式则是将各种产品集中起来进行管理，用来创建复合对象，所谓复合对象就是指某个类具有不同的属性，其实建造者模式就是前面抽象工厂模式和最后的Test结合起来得到的。
我们看一下代码：
还和前面一样，一个Sender接口，两个实现类MailSender和SmsSender。
最后，建造者类如下：
例子1：
Builder
private
List<
Sender>
list
ArrayList<
（）;
produceMailSender（int
count）{
for（int
i=0;
i<
count;
i++）{
list.add（new
MailSender（））;
produceSmsSender（int
13.
SmsSender（））;
14.
15.
16.}
builder
Builder（）;
builder.produceMailSender（10）;
例子2：
Builder
publicinterfacePersonBuilder{
voidbuildHead（）;
voidbuildBody（）;
voidbuildFoot（）;
PersonbuildPerson（）;
}
ConcreteBuilder
publicclassManBuilderimplementsPersonBuilder{
Personperson;
publicManBuilder（）{
person=newMan（）;
}
publicvoidbuildbody（）{
person.setBody（"
建造男人的身体"
publicvoidbuildFoot（）{
person.setFoot（"
建造男人的脚"
publicvoidbuildHead（）{
person.setHead（"
建造男人的头"
publicPersonbuildPerson（）{
returnperson;
Director（负责人、主管）
publicclassPersonDirector{
publicPersonconstructPerson（PersonBuilderpb）{
pb.buildHead（）;
pb.buildBody（）;
pb.buildFoot（）;
returnpb.buildPerson（）;
Product
publicclassPerson{
privateStringhead;
privateStringbody;
privateStringfoot;
publicStringgetHead（）{
returnhead;
publicvoidsetHead（Stringhead）{
this.head=head;
publicStringgetBody（）{
returnbody;
publicvoidsetBody（Stringbody）{
this.body=body;
publicStringgetFoot（）{
returnfoot;
publicvoidsetFoot（Stringfoot）{
this.foot=foot;
publicclassManextendsPerson{
Test
publicclassTest{
publicstaticvoidmain（String[]args）{
PersonDirectorpd=newPersonDirector（）;
Personperson=pd.constructPerson（newManBuilder（））;
System.out.println（person.getBody（））;
System.out.println（person.getFoot（））;
System.out.println（person.getHead（））;
result
建造男人的身体
建造男人的脚
建造男人的头
从这点看出，建造者模式将很多功能集成到一个类里，这个类可以创造出比较复杂的东西。
所以与工厂模式的区别就是：
工厂模式关注的是创建单个产品，而建造者模式则关注创建复合对象，多个部分。
因此，是选择工厂模式还是建造者模式，大家要多多思量。
去肯德基吃汉堡，售卖员接单后，可以跟后厨说，先来一个后厨对象，请后厨对象调用你自己的生产奥尔良鸡腿堡初始化类生成一个汉堡（问题在于，其实你只想要一个汉堡，汉堡本身是不会做汉堡的，为了达到目的，你必须硬给他加一个后厨部分，整合成一个对象，才能生产汉堡）；
或者请厨师Builder帮忙做一个奥尔良鸡腿堡。
4、原型模式（Prototype）
原型模式虽然是创建型的模式，但是与工程模式没有关系，从名字即可看出，该模式的思想就是将一个对象作为原型，对其进行复制、克隆，产生一个和原对象类似的新对象。
在Java中，复制对象是通过clone（）实现的，先创建一个原型类：
Prototype
Cloneable
Object
clone（）
throws
CloneNotSupportedException
proto
（Prototype）
super.clone（）;
proto;
很简单，一个原型类，只需要实现Cloneable接口，覆写clone方法，此处clone方法可以改成任意的名称，因为Cloneable接口是个空接口，你可以任意定义实现类的方法名，如cloneA或者cloneB，因为此处的重点是super.clone（）这句话，super.clone（）调用的是Object的clone（）方法，而在Object类中，clone（）是native的。
也可以封装到工厂类中使用
首先需要了解对象深、浅复制的概念：
浅复制：
将一个对象复制后，基本数据类型的变量都会重新创建，而引用类型，指向的还是原对象所指向的。
深复制：
将一个对象复制后，不论是基本数据类型还有引用类型，都是重新创建的。
简单来说，就是深复制进行了完全彻底的复制，而浅复制不彻底。
此处，写一个深浅复制的例子：
Cloneable,
Serializable
final
long
serialVersionUID
1L;
String
string;
SerializableObject
obj;
/*
浅复制
*/
深复制
deepClone（）
IOException,
ClassNotFoundException
16.
17.
写入当前对象的二进制流
18.
ByteArrayOutputStream
bos
ByteArrayOutputStream（）;
19.
ObjectOutputStream
oos
ObjectOutputStream（bos）;
20.
oos.writeObject（this）;
21.
22.
读出二进制流产生的新对象
23.
ByteArrayInputStream
bis
ByteArrayInputStream（bos.toByteArray（））;
24.
ObjectInputStream
ois
ObjectInputStream（bis）;
25.
ois.readObject（）;
26.
27.
28.
getString（）
29.
30.
31.
32.
setString（String
string）
33.
this.string
34.
35.
36.
getObj（）
37.
38.
39.
40.
setObj（SerializableObject
obj）
41.
this.obj
42.
43.
44.}
45.
46.class
47.
48.}
要实现深复制，需要采用流的形式读入当前对象的二进制输入，再写出二进制数据对应的对象。
5、单例模式（Singleton）
单例对象（Singleton）是一种常用的设计模式。
在Java应用中，单例对象能保证在一个JVM中，该对象只有一个实例存在。
这样的模式有几个好处：
1、某些类创建比较频繁，对于一些大型的对象，这是一笔很大的系统开销。
2、省去了new操作符，降低了系统内存的使用频率，减轻GC压力。
3、有些类如交易所的核心交易引擎，控制着交易流程，如果该类可以创建多个的话，系统完全乱了。
（比如一个军队出现了多个司令员同时指挥，肯定会乱成一团），所以只有使用单例模式，才能保证核心交易服务器独立控制整个流程。
首先我们写一个简单的单例类：
Singleton
持有私有静态实例，防止被引用，此处赋值为null，目的是实现延迟加载
instance
私有构造方法，防止被实例化
7
升级会员 