Java的23种设计模式疯狂Java总结个人修改增强版.docx
《Java的23种设计模式疯狂Java总结个人修改增强版.docx》由会员分享，可在线阅读，更多相关《Java的23种设计模式疯狂Java总结个人修改增强版.docx（96页珍藏版）》请在冰豆网上搜索。
Java的23种设计模式疯狂Java总结个人修改增强版
Java设计模式（疯狂Java联盟版）
个人修改增强版
1.设计模式
内容简介
有感于设计模式在日常开发中的重要性，同时笔者也自觉对设计模式小有心得，故笔者*写二十三种设计模式的简单例子、并整理二十三种设计模式的理论部分，综合汇总成这份Java设计模式（疯狂Java联盟版），希望对大家有所帮助。
本份帮助文档主要是为了向读者介绍二十三种设计模式，包括模式的描述，适用性，模式的组成部分，并附带有简单的例子和类*，目的是为了让读者了解二十三种设计模式，并能方便的查阅各种设计模式的用法及注意点。
所附的例子非常简单，慢慢的引导读者从浅到深了解设计模式，并能从中享受设计的乐趣。
由于每个人对设计*式的理解都不尽一致，因此，可能本文档的例子*有不恰当的地方，还望各位读者指出不恰当的地方。
欢迎登录疯狂Java联盟进行技术交流，疯狂Java联盟的论坛宗旨是：
所有的技术发帖，均有回复。
疯狂Java联盟网址：
http:
//www.crazyit.org
笔者简介
笔者曾师从李刚老师学习Java，现居广州。
对Java软件开发、各种Java开源技术都非常感兴趣，曾参与开发、主持*发过大量Java、JavaEE项目，对Java、Java*E项目有一定认识*见解。
欢迎大家与笔者就Java、JavaEE相*方面进行技术交流。
笔者现为疯狂Java联盟的总版主（论坛ID：
杨恩雄），也希望通过该平台与大家分享Java、JavaEE技术、*得。
本人邮箱：
yangenxiong@
声明
本文档编写、制作过程中得到了疯狂Java联盟、以及笔者学习工作过程大量朋友的支持，大家都抱着一个目的：
为国内软件
软件开发事业作出绵薄贡献。
我们在此郑重宣布，本*档遵循Apache2.0协议。
在完整保留全部文本（包括本版权页），并且不违反Apache2.0协议的前提
下，允许和鼓励任何人进行全文转载及推广，我们放弃除署名权外的一切权利。
1.1创建型模式
FactoryMethod（工厂方法）
AbstractFactory（抽象工厂）
Singleton（单态模式）
Builder（建造者模式）
Prototype（原型模式）
1.1.1工厂方法（FactoryMethod）
定义一个用于创建对象的接口，让子类决定实例化哪一个类。
FactoryMethod使一个类的实例化延迟到其子类。
适用性
1.当一个类不知道它所必须创建的对象的类的时候。
2.当一个类希望由它的子类来指定它所创建的对象的时候。
3.当类将创建对象的职责委托给多个帮助子类中的某一个，并且你希望将哪一个帮助子类是代理者这一信息局部化的时候。
参与者
1.Product
定义工厂方法所创建的对象的接口。
2.ConcreteProduct
实现Product接口。
3.Creator
声明工厂方法，该方法返回一个Product类型的对象*
Creator也可以定义一个工厂方法的缺省实现，它返回一个缺省的ConcreteProduct对象。
可以调用工厂方法以创建一个Product对象。
4.ConcreteCreator
重定义工厂方法以返回一个ConcreteProduct实例。
类图
《Java与模式》中的图：
例子
product
publicinterfaceWork{
voiddoWork（）;
}
ConcreteProduct
publicclassStudentWorkimplementsWork{
publicvoiddoWork（）{
System.out.println（"学生做作业!
"）;
}
}
publicclassTeacherWorkimplementsWork{
publicvoiddoWork（）{
System.out.println（"老师审批作业!
"）;
}
}
Creator
publicinterfaceIWorkFactory{
WorkgetWork（）;
}
ConcreteCreator
publicclassStudentWorkFactoryimplementsIWorkFactory{
publicWorkgetWork（）{
returnnewStudentWork（）;
}
}
publicclassTeacherWorkFactoryimplementsIWorkFactory{
publicWorkgetWork（）{
returnnewTeacherWork（）;
}
}
Test
publicclassTest{
publicstaticvoidmain（String[]args）{
IWorkFactorystudentWorkFactory=newStudentWorkFactory（）;
studentWorkFactory.getWork（）.doWork（）;
IWorkFactoryteacherWorkFactory=newTeacherWorkFactory（）;
teacherWorkFactory.getWork（）.doWork（）;
}
}
本人改造：
publicclassTest{
publicstaticvoidmain（String[]args）{
IWorkFactorystudentWorkFactory=newStudentWorkFactory（）;
WorkstudentWork=studentWorkFactory.getWork（）;
studentWork.doWork（）;
IWorkFactoryteacherWorkFactory=newTeacherWorkFactory（）;
WorkteatherWork=teacherWorkFactory.getWork（）;
teatherWork.doWork（）;
}
}
result
学生做作业!
老师审批作业!
形象比喻：
FACTORYMETHOD—请MM去麦当劳吃汉堡，不同的MM有不同的口味，要每个都记住是一件烦人的事情，我一般采用FactoryMethod模式，带着MM到服务员那儿，说“要一个汉堡”，具体要什么样的汉堡呢，让MM直接跟服务员说就行了。
工厂方法模式：
核心工厂类不再负责所有产品的创建，而是将具体创建的工作交给子类去做，成为一个抽象工厂角色，仅负责给出具体工厂类必须实现的接口，而不接触哪一个产品类应当被实例化这种细节。
1.1.2抽象工厂（AbstractFactory）
提供一个创建一系列相关或相互依赖对象的接口，而无需指定它们具体的类。
适用性
1.一个系统要独立于它的产品的创建、组合和表示时。
2.一个系统要由多个产品系列中的一个来配置时。
3.当你要强调一系列相关的产品对象的设计以便进行联合使用时。
4.当你提供一个产品类库，而只想显示它们的接口而不是实现时。
参与者
1.AbstractFactory
声明一个创建抽象产品对象的操作接口。
2.ConcreteFactory
实现创建具体产品对象的操作。
3.AbstractProduct
为一类产品对象声明一个接口。
4.ConcreteProduct
定义一个将被相应的具体工厂创建的产品*象。
实现abstractProduct接口。
5.Client
仅使用由AbstractFactory和AbstractProduct类声明的接口
类图
《Java与模式》中的图：
例子
abstractFactory
publicinterfaceIAnimalFactory{
ICatcreateCat（）;
IDogcreateDog（）;
}
ConcreteFactory
publicclassBlackAnimalFactoryimplementsIAnimalFactory{
publicICatcreateCat（）{
returnnewBlackCat（）;
}
publicIDogcreateDog（）{
returnnewBlackDog（）;
}
}
publicclassWhiteAnimalFactoryimplementsIAnimalFactory{
publicICatcreateCat（）{
returnnewWhiteCat（）;
}
publicIDogcreateDog（）{
returnnewWhiteDog（）;
}
}
AbstractProduct
publicinterfaceICat{
voideat（）;
}
publicinterfaceIDog{
voideat（）;
}
Concreteproduct
publicclassBlackCatimplementsICat{
publicvoideat（）{
System.out.println（"Theblackcatiseating!
"）;
}
}
publicclassWhiteCatimplementsICat{
publicvoideat（）{
System.out.println（"Thewhitecatiseating!
*）;
}
}
publicclassBlackDogimplementsIDog{
publicvoideat（）{
System.out.println（"Theblackdogiseating"）;
}
}
publicclassWhiteDogimplementsIDog{
publicvoideat（）{
System.out.println（"Thewhitedogiseating!
"）;
}
}
Client
publicstaticvoidmain（String[]args）{
IAnimalFactoryblackAnimalFactory=newBlackAnimalFactory（）;
ICatblackCat=blackAnimalFactory.createCat（）;
blackCat.eat（）;
IDogblackDog=blackAnimalFactory.createDog（）;
blackDog.eat（）;
IAnimalFactorywhiteAnimalFactory=newWhiteAnimalFactory（）;
ICatwhiteCat=whiteAnimalFactory.createCat（）;
whiteCat.eat（）;
IDogwhiteDog=whiteAnimalFactory.createDog（）;
whiteDog.eat（）;
}
result
Theblackcatiseating!
Theblackdogiseating!
Thewhitecatiseating!
Thewhitedogiseating!
形象比喻：
ABSTRACTFACTORY—追MM少不了请吃饭了，麦当劳的鸡翅和肯德基的鸡翅都是MM爱吃的东西，虽然口味有所不同，但不管你带MM去麦当劳或肯德基，只管向服务员说“来四个鸡翅”就行了。
麦当劳和肯德基就是生产鸡翅的Factory
工厂模式：
客户类和工厂类分开。
消费者任何时候需要某种产品，只需向工厂请求即可。
消费者无须修改就可以接纳新产品。
缺点是当产品修改时，工厂类也要做相应的修改。
如：
如何创建及如何向客户端提供。
1.1.3建造者模式（Builder）
将一个复杂对象的构建与它的表示分离，使得同样的构建过程可以创建不同的表示。
适用性
1.当创建复杂对象的算法应该独立于该对象的组成部分以及它们的装配方式时。
2.当构造过程必须允许被构造的对象有不同的表示时。
参与者
1.Builder
为创建一个Product对象的各个部件指定抽象接口。
2.ConcreteBuilder
实现Builder的接口以构造和装配该产品的各个部件。
定义并明确它所创建的表示。
提供一个检索产品的接口。
3.Director
构造一个使用Builder接口的对象。
4.Product
表示被构造的复杂对象。
ConcreteBuilder创建该产品的内部表示并定义它的装配过程。
包含定义组成部件的类，包括将这些部件装配成最终产品的接口。
类图
例子
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—MM最爱听的就是“我爱你”这句话了，见到不同地方的MM,要能够用她们的方言跟她说这句话哦，我有一个多种语言翻译机，上面每种语言都有一个按键，见到MM我只要按对应的键，它就能够用相应的语言说出“我爱你”这句话了，国外的MM也可以轻松搞定，这就是我的“我爱你”builder。
（这一定比美军在伊拉克用的翻译机好卖）
建造模式：
将对象的内部表象和对象的生成过程分割开来，从而使一个建造过程生成具有不同的内部表象的产品对象。
建造模式使得产品内部表象可以独立的变化，客户不必知道产品内部组成的细节。
建造模式可以强制实行一种分步骤进行的建造过程。
1.1.4单态模式（Singleton）
保证一个类仅有一个实例，并提供一个访问它的全局访问点。
适用性
1.当类只能有一个实例而且客户可以从一个众所周知的访问点访问它时。
2.当这个唯一实例应该是通过子类化可扩展的，并且客户应该无需更改代码就能使用一个扩展的实例时。
参与者
Singleton
定义一个Instance操作，允许客户访问它的唯一实例。
Instance是一个类操作。
可能负*创建它自己的唯一实例。
类图
例子
Singleton
publicclassSingleton{
privatestaticSingletonsing;
privateSingleton（）{
}
publicstaticSingletongetInstance（）{
if（sing==null）{
sing=newSingleton（）;
}
returnsing;
}
}
Test
publicclassTest{
publicstaticvoidmain（String[]args）{
Singletonsing=Singleton.getInstance（）;
Singletonsing2=Singleton.getInstance（）;
System.out.println（sing）;
System.out.println（sing2）;
}
}
result
singleton.Singleton@1c78e57
singleton.Singleton@1c78e57
形象比喻：
SINGLETON—俺有6个漂亮的老婆，她们的老公都是我，我就是我们家里的老公Sigleton，她们只要说道“老公”，都是指的同一个人，那就是我（刚才做了个梦啦，哪有这么好的事）
单例模式：
单例模式确保某一个类只有一个实例，而且自行实例化并向整个系统提供这个实例单例模式。
单例模式只应在有真正的“单一实例”的需求时才可使用。
1.1.5原型模式（Prototype）
用原型实例指定创建对象的种类，并且通过拷贝这些原型创建新的对象。
适用性
1.当一个系统应该独立于它的产品创建、构成和表示时。
2.当要实例化的类是在运行时刻指定时，例如，通过动态装载。
3.为了避免创建一个与产品类层次平行的工厂类层次时。
4.当一个类的实例只能有几个不同状态组合中的一种时。
建立相应数目的原型并克隆它们可能比每次用合适的状态手工实例化该类更方便一些。
参与者
1.Prototype
声明一个克隆自身的接口。
2.ConcretePrototype
实现一个克隆自身的操作。
3.Client
让一个原型克隆自身从而创建一个新的对象。
类图
例子
Prototype
publicclassPrototypeimplementsCloneable{
privateStringname;
publicvoidsetName（Stringname）{
this.name=name;
}
publicStringgetName（）{
returnthis.name;
}
publicObjectclone（）{
try{
returnsuper.clone（）;
}catch（Exceptione）{
e.printStackTrace（）;
returnnull;
}
}
}
ConcretePrototype
publicclassConcretePrototypeextendsPrototype{
publicConcretePrototype（Stringname）{
setName（name）;
}
}
Client
publicclassTest{
publicstaticvoidmain（String[]args）{
Prototypepro=newConcretePrototype（"prototype"）;
Prototypepro2=（Prototype）pro.clone（）;
System.out.println（pro.getName（））;
System.out.println（pro2.getName（））;
}
}
result
prototype
prototype
形象比喻：
PROTOTYPE—跟MM用QQ聊天，一定要说些深情的话语了，我搜集了好多肉麻的情话，需要时只要copy出来放到QQ里面就行了，这就是我的情话prototype了。
（100块钱一份，你要不要）
原始模型模式：
通过给出一个原型对象来指明所要创建的对象的类型，然后用复制这个原型对象的方法创建出更多同类型的对象。
原始模型模式允许动态的增加或减少产品类，产品类不需要非得有任何事先确定的等级结构，原始模型模式适用于任何的等级结构。
缺点是每一个类都必须配备一个克隆方法。
1.2结构型模式
Adapter（适配器模式）
Bridge（桥接模式）
Composite（组合模式）
Decorator（装饰模式）
Facade（外观模式）
Flyweight（享元模式）
Proxy（代理模式）
1.2.1适配器模式（Adapter）
将一个类的接口转
升级会员 