《JAVA设计模式》.docx
《《JAVA设计模式》.docx》由会员分享，可在线阅读，更多相关《《JAVA设计模式》.docx（15页珍藏版）》请在冰豆网上搜索。
《JAVA设计模式》
编号
计算机工程学院
《Java设计模式》课程结题技术报告
课题名称：
原型模式与策略模式的比较
学生姓名：
学号：
专业：
计算机科学与技术
班级：
2014级2班
指导教师：
2017年6月
原型模式的原理与使用
摘要：
Prototype原型模式是一种创建型设计模式，Prototype模式允许一个对象再创建另外一个可定制的对象，根本无需知道任何如何创建的细节,工作原理是:
通过将一个原型对象传给那个要发动创建的对象，这个要发动创建的对象通过请求原型对象拷贝它们自己来实施创建。
策略模式定义了一系列算法，封装每个算法，并使它们互换。
策略使算法与使用它的客户端独立变化。
关键词：
原型模式；策略模式；创建型设计模式；原理；应用
Principleanduseofprototypemodel
Abstract:
Prototypeprototypemodeisacreativedesignpattern,Prototypemodeallowsanobjecttocreateanothercustomizableobject,thereisnoneedtoknowanydetailsofhowtocreate,theworkingprincipleis:
bypassingaprototypeobjecttothelaunchCreatetheobject,theobjecttobecreatedtocreatetheobjectbyrequestingtheprototypeobjecttocopytheirowntoimplementthecreation.
TheStrategyPatterndefinesafamilyofalgorithms,encapsulateseachone,andmakestheminterchangeable.Strategyletsthealgorithmvaryindependentlyfromclientsthatuseit.
Keywords:
prototypemodel;creationdesignpattern;principle;application
目录
1前言4
1.1选题的目的和意义4
2概述、定义、结构和使用、优点和缺点5
3在Java中的应用10
3.110
原型模式：
10
3.2综合应用举例 11
结束语13
参考文献14
1前言
1.1选题的目的和意义
全用此课题的目的是深入了解原型模式和策略模式的原理，能够应用原型模式或策略模式构架不同的应用程序。
意义是通过对原型模式和策略模式的对比研究，掌握一种研究方法，并推广到其他的模式研究中去，并锻炼出自主研究学习的能力，并加深对JAVA设计模式的理解与应用。
2概述、定义、结构和使用、优点和缺点
2.1原型模式
2.1.1原型模式概述
在某些情况下，可能不希望反复使用类的构造方法创建许多对象，而是希
望用该类型创建一个对象后，以该对象为原型得到该对象的若干个复制品。
也就是说，将一个对象定义为原型对象，要求该原型对象提供一个方法，使该原型对象调用此方法可以复制一个和自己有完全相同状态的同类型对象，即该方法“克隆”原型对象得到一个新对象，这里使用“克隆”一词可能比复制一词更为形象，所以人们在复制对象时，也可经常等价说克隆对象。
原型对象与以他为原型“克隆”出的新对象可以分别独立的变化，也就是说，原型对象改变其状态不会影响到以它为原型所克隆的心对象，反之也是一样。
比如，通过复制一个已有的Word文档中的文本创建一个新Word文档后，两个文档中的文本内容可独立的变化互不影响，也就是说，一个含有文本数据的原型对象改变其含有的文本数据不会影响以他为原型多克隆出的新对象中的文本内容。
2.1.2原型模式的定义
原型模式就是通过一个原型对象来表明要创建的对象类型，然后用复制这个
对象的方法来创建更痛类型的对象。
2.1.3原型模式的结构和使用
原型模式要求对象实现一个可以“克隆”自身的接口，这样就可以通过复制一个实例对象本身来创建一个新的实例。
这样一来，通过原型实例创建新的对象，就不再需要关心这个实例本身的类型，只要实现了克隆自身的方法，就可以通过这个方法来获取新的对象，而无须再去通过new来创建。
原型模式有两种表现形式：
（1）简单形式、
（2）登记形式，这两种表现形式仅仅是原型模式的不同实现。
2.1.4 原型模式的优点和缺点
（1）原型模式的优点
当在创建对象成本太高的情况下（即初始化会占用较长时间，占用太多的cpu资源或网络资源），而这个对象又需要重复使用，这种情况下，新的对象可以通过原型模式对已有对象的属性进行复制并稍作修改来获得。
（2）原型模式的缺点
自己实现深层复制需要编写复杂的代码。
2.1.5. 适合使用原型模式的情景
clone（）方法将对象复制了一份并返还给调用者。
所谓“复制”的
含义与clone（）方法是怎么实现的。
一般而言，clone（）方法满足以下的描述：
（1）对任何的对象x，都有：
x.clone（）!
=x。
换言之，克隆对象
与原对象不是同一个对象。
（2）对任何的对象x，都有：
x.clone（）.getClass（） == x.getClass（），换言之，克隆对象与原对象的类型一样。
（3）如果对象x的equals（）方法定义其恰当的话，那么x.clone（）.equals（x）应当成立的。
在JAVA语言的API中，凡是提供了clone（）方法的类，都满足上面的这些条件。
JAVA语言的设计师在设计自己的clone（）方法时，也应当遵守着三个条件。
一般来说，上面的三个条件中的前两个是必需的，而第三个是可选的。
2.1.6、浅克隆和深克隆
无论你是自己实现克隆方法，还是采用Java提供的克隆方法，都
存在一个浅度克隆和深度克隆的问题。
1、浅度克隆
只负责克隆按值传递的数据（比如基本数据类型、String类型），而不复制它所引用的对象，换言之，所有的对其他对象的引用都仍然指向原来的对象。
2、深度克隆
除了浅度克隆要克隆的值外，还负责克隆引用类型的数据。
那些
引用其他对象的变量将指向被复制过的新对象，而不再是原有的那些被引用的对象。
换言之，深度克隆把要复制的对象所引用的对象都复制了一遍，而这种对被引用到的对象的复制叫做间接复制。
深度克隆要深入到多少层，是一个不易确定的问题。
在决定以深度克隆的方式复制一个对象的时候，必须决定对间接复制的对象时采取浅度克隆还是继续采用深度克隆。
因此，在采取深度克隆时，需要决定多深才算深。
此外，在深度克隆的过程中，很可能会出现循环引用的问题，必须小心处理。
2.2策略模式
2.2.1策略模式的定义
策略模式是一种行为模式。
定义一系列的算法，把他们一个个
封装起来，并且使他们可以相互替换，并对用户提供统一的接口，策略模式使算法可独立于使用它的客户而变化。
（Define a family of algorithms,encapsulate each one, and make them interchangeable. Strategy lets the algorithm vary independently from clients that use it. ）
策略模式把对象本身和运算规则区分开来，其功能非常强大，因为这个设计模式本身的核心思想就是面向对象编程的多形性的思想。
策略模式的功能：
把具体的算法实现从具体的业务处理中独立出来来，把它们实现成单独的算法类，从而形成一系列的算法，并让这些算法可以相互替换。
策略模式的重心不是如何实现算法，而是如何组织、调用这些算法，从而让程序结构更灵活，具有更好的可维护性和可扩展性策略算法在实现上也是相互独立的，相互之间相互没有依赖的。
2.2.2策略模式的结构与使用
策略模式的结构图如上所示：
Context定义了一个面向应用的接口。
它维护对一个Strategy对象的引用，并使用一个ConcreteStrategy 对象来配置本身。
Strategy定义所有的的算法的公共接口，Context使用此接口来调用具体的算法（策略）。
具体算法在ConcreteStrategy中实现。
这里每一种算法即为一个策略。
当客户调用Context 时，它将客户的请求转发给它的Strategy 。
Context将该算法所需的所有数据传递给Strategy，或者将自身作为参数传递给Strategy ，使 Strategy可以回调Context 。
ConcreteStrategy实现具体算法。
Strategy模式以以下几条原则为基础：
（1）对象都具有职责，这些职责不同的具体实现是通过多态的使用完成的。
（2）概念上相同的算法具有多个不同的实现，需要进行管理。
将问题域中的各个行为互相分离开来----也就是说将他们解耦，是一个好的设计实践，这使得我们可以修改负责某一行为的类，不会对其它的类产生不良影响
trategy模式关键特征
A.意图：
可以根据所处的上下文，使用不同的的业务规则或算法；
问题：
对所需算法的选择取决于发出请求的客户或者要处理的数据，如果只有一些不会变化的算法，就不需要 Strategy 模式；
B.解决方案：
将对算法的选择和算法的实现相分离。
允许根据上下文进行选择；
C.参与者与写作者：
Strategy 模式制定了如何使用不同的算法，各ConcreteStrategy实现了这些不同个算法，Context 通过类型Strategy的引用时用具体的ConcreteStrategy，Strategy与Contextx相互作用以实现所选的算法，Context将均来自Context的请求转发给Strategy。
D.效果：
Strategy 模式定义了一些列的算法；可以不使用Switch语句或条件语句;必须以相同的方法调用所有的算法，（他们之间必须拥有相同的接口），各ConcreteStrategy与Context中加入获取状态的方法.
E.实现：
让使用算法的类（Context）包含一个抽象类（Strategy），该抽象类由一个抽象方法制定如何让调用算法，每个派生类按需要实现算法。
注意：
在原型Strategy模式中，选择所有具体实现的职责由Context对象承担，并转给Strategy模式的Context对象 3.4 Strategy模式的组成
环境类（Context）:
用一个ConcreteStrategy对象来配置。
维护一个对Strategy对象的引用。
可定义一个接口来让Strategy访问它的数据。
抽象策略类（Strategy）：
定义所有支持的算法的公共接口。
Context使用这个接口来调用某ConcreteStrategy定义的算法。
具体策略类 （ConcreteStrategy ）：
Strategy接口实现某具体算法。
2.2.3策略模式的优缺点
1） 相关算法系列 Strategy类层次为Context定义了一系列的可供重用的算法或行为。
继承有助于析取出这些算法中的公共功能。
2） 提供了可以替换继承关系的办法：
继承提供了另一种支持多种算法或行为的方法。
你可以直接生成一个Context类的子类，从而给它以不同的行为。
但这会将行为硬行编制到 Context中，而将算法的实现与Context的实现混合起来,从而使Context难以理解、难以维护和难以扩展，而且还不能动态地改变算法。
最后你得到一堆相关的类 , 它们之间的唯一差别是它们所使用的算法或行为。
将算法封装在独立的Strategy类中使得你可以独立于其Context改变它，使它易于切换、易于理解、易于扩展。
3） 消除了一些if else条件语句 ：
Strategy模式提供了用条件语句选择所需的行为以外的另一种选择。
当不同的行为堆砌在一个类中时 ,很难避免使用条件语句来选择合适的行为。
将行为封装在一个个独立的Strategy类中消除了这些条件语句。
含有许多条件语句的代码通常意味着需要使用Strategy模式。
4） 实现的选择 Strategy模式可以提供相同行为的不同实现。
客户可以根据不同时间 /空间权衡取舍要求从不同策略中进行选择。
3在Java中的应用
3.1
原型模式：
public abstract class AbstractSpoon implements Cloneable{
String spoonName;
public void setSpoonName（String spoonName）
{
this.spoonName = spoonName;
}
public String getSpoonName（）
{
return this.spoonName;}
public Object clone（）
{
Object object = null;
try {
object = super.clone（）; }
catch （CloneNotSupportedException exception）
{
System.err.println（"AbstractSpoon is not Cloneable"）; }
return object;
} }
策越模式：
我们在一家餐厅吃饭，针对套餐，不同年龄的人可能收费不一样，大人如父母40元每份，老人20元每份，小孩子10元每份。
如果要设计个软件来做这件事，那么通常首先考虑的是使用if„else或switch之类的结构来解决这个问题，例如如下代码：
（代码不能运行，仅仅说明问题）
public class Client {
public static void main（String[] arg）{
showPrice（persontypeType）;
}
public static void showPrice（persontype persontypeType）{
if（persontypeType.equals（daren））{
//大人
System.out.println（"每份40"）; }
else
if（persontypeType.equals（laoren））{
//老人
System.out.println（"每份20"）;
}else
if（persontypeType.equals（xiaihai））
{//小孩子
System.out.println（"每份10"）;
} } }
3.2综合应用举例
代码如下：
新建赛车的接口：
Package car_interface;
public interface car_interface { public void start（）; public void stop（）;
}
新建奥迪汽车的实现类：
package car_imple;
import car_fittings.car_tyre; import car_interface.car_interface; public class audi_imple implements car_interface, Cloneable { private car_tyre car_tyre_ref; public void start（） {
System.out.println（"奥迪A6启动了"）; }
public void stop（） {
System.out.println（"奥迪A6停止了"）; }
public car_tyre getCar_tyre_ref（） { return car_tyre_ref;
}
public void setCar_tyre_ref（car_tyre car_tyre_ref） {
this.car_tyre_ref =
car_tyre_ref; }
@Override public
Object
clone（）
throws
CloneNotSupportedException { super.clone（）;
audi_imple audi_imple = new audi_imple（）;
audi_imple.setCar_tyre_ref（new car_tyre（））;
return audi_imple; }
新建奥迪汽车的配件轮胎类
package car_fittings;
public class car_tyre {
private String name = "德国制造原版轮胎";
public String getName（） { return name; } }
新建客户端运行类：
package run_main;
import car_fittings.car_tyre; import car_imple.audi_imple; import car_interface.car_interface;
public class run_main {
public static void main（String[] args） {
try {
audi_imple car_ref_my = new audi_imple（）;
car_ref_my.setCar_tyre_ref（new car_tyre（））;
System.out.println（"我的奥迪车的参数是：
" + car_ref_my）;
System.out.println（"我的奥迪车的轮胎参数是：
" + car_ref_my.getCar_tyre_ref（））;
audi_imple car_ref_other = （audi_imple） car_ref_my.clone（）;
System.out.println（"其它人的奥迪车的参数是：
" + car_ref_other）;
System.out.println（"其它人的奥迪车的轮胎参数是：
"
+ car_ref_other.getCar_tyre_ref（））;
}
catch （CloneNotSupportedException e）
{ // TODO Auto-generated catch block
e.printStackTrace（）;
}
} }
程序运行结果如下：
我的奥迪车的参数是：
car_imple.audi_imple@9cab16
我的奥迪车的轮胎参数是：
car_fittings.car_tyre@1a46e30
其它人的奥迪车的参数是：
car_imple.audi_imple@3e25a5
从打印的结果来看，我的汽车我的轮胎和其它人的汽车和轮胎都是不一样的对象，但“类型”都是一样的：
奥迪的汽车，原版的轮胎。
本例中也实现了“原型模式”中的“深拷贝/深复制”，即汽车类中有一个对象“轮胎”对象，关于深拷贝/深复制的概念请参考其它的资料。
原型模式通常都是在复制对象的时候使用，而在常规的情况下都是使用new重新创建一个，并且重新对属性进行复制，代码重复度很高，原型模式的出现避免了new的硬操作。
结束语
通过本次研究，学习了JAVA设计模式“原型模式”和“策略模式”，并通过对原形模式和策略模式的研究和学习，发现了一种JAVA设计模式的研究方法，即“概念-原理-应用”的研究学习方法。
在原形模式的学习中，理解了Prototype原型模式是一种创建型设计模式，Prototype模式允许一个对象再创建另外一个可定制的对象，根本无需知道任何如何创建的细节,工作原理是:
通过将一个原型对象传给那个要发动创建的对象，这个要发动创建的对象通过请求原型对象拷贝它们自己来实施创建。
并通过实例《奥迪车的轮胎型号》，对原型模式的应用进行了尝试，对接下来其他模式的应用提供了经验。
接下来我将逐步深入学习JAVA设计模式的其他模型，更好的掌握JAVA程序的编写。
参考文献
[1]沈琦，张虹．多媒体数据库模型与存储模型研究[J]．计算机工程．1997，23（6）
[2]钟玉琢，沈洪，吕小星等．多媒体技术及应用其应用[M]．北京：
机械工业出版社．2003
[3]XX百科
[4]谷歌翻译
升级会员 