Java各种设计模式详解整理版文档格式.docx
《Java各种设计模式详解整理版文档格式.docx》由会员分享，可在线阅读，更多相关《Java各种设计模式详解整理版文档格式.docx（95页珍藏版）》请在冰豆网上搜索。
（6）抽象类中的变量默认是friendly型，其值可以再子类中重新定义，也可以重新赋值。
（7）接口中的方法默认都是public,abstract类型的。
接口和委托的区别：
接口可以包含属性、索引、方法以及事件。
但委托不能包含事件。
软件设计原则：
1.1创建型模式
AbstractFactory（抽象工厂）
FactoryMethod（工厂方法）
Singleton（单态模式）
Builder（建造者模式）
Protot*pe*原型模式）
1.1.1工厂方法
定义一个用于创建对象的接口，让子类决定实例化哪一个类。
FactoryMethod使一个类的实例化延迟到其子类。
适用性
1.当一个类不知道它所必须创建的对象的类的时候。
2.当一个类希望由它的子类来指定它所创建的对象的时候。
3.当想将创建对象的职责委托给多个帮助子类中的某一个，并且希望将哪一个帮助子类是代理者这一信息局部化的时候。
参与者
1.Product
定义工厂方法所创建的对象的接口。
2.ConcreteProduct
实现Product接口。
3.Creator
声明工厂方法，该方法返回一个Product类型的对象*
Creator也可以定义一个工厂方法的缺省实现，它返回一个缺省的ConcreteProduct对象。
可以调用工厂方法以创建一个Product对象。
4.ConcreteCreator
重定义工厂方法以返回一个ConcreteProduct实例。
类图
例子
product
publicinterfaceWork{
voiddoWork（）;
}
ConcreteProduct
publicclassStudentWorkimplementsWork{
publicvoiddoWork（）{
System.out.println（"
学生做作业!
"
）;
}
publicclassTeacherWorkimplementsWork{
老师审批作业!
Creator
publicinterfaceIWorkFactory{
WorkgetWork（）;
ConcreteCreator
publicclassStudentWorkFactoryimplementsIWorkFactory{
publicWorkgetWork（）{
returnnewStudentWork（）;
publicclassTeacherWorkFactoryimplementsIWorkFactory{
returnnewTeacherWork（）;
Test
publicclassTest{
publicstaticvoidmain（String[]args）{
IWorkFactorystudentWorkFactory=newStudentWorkFactory（）;
studentWorkFactory.getWork（）.doWork（）;
IWorkFactoryteacherWorkFactory=newTeacherWorkFactory（）;
teacherWorkFactory.getWork（）.doWork（）;
result
1.1.2抽象工厂
提供一个创建一系列相关或相互依赖对象的接口，而无需指定它们具体的类。
1.一个系统要独立于它的产品的创建、组合和表示时。
2.一个系统要由多个产品系列中的一个来配置时。
3.当你要强调一系列相关的产品对象的设计以便进行联合使用时。
4.当你提供一个产品类库，而只想显示它们的接口而不是实现时。
1.AbstractFactory
声明一个创建抽象产品对象的操作接口。
2.ConcreteFactory
实现创建具体产品对象的操作。
3.AbstractProduct
为一类产品对象声明一个接口。
4.ConcreteProduct
定义一个将被相应的具体工厂创建的产品*象。
实现AbstractProduct接口。
5.Client
仅使用由AbstractFactory和AbstractProduct类声明的接口
AbstractFactory
publicinterfaceIAnimalFactory{
ICatcreateCat（）;
IDogcreateDog（）;
ConcreteFactory
publicclassBlackAnimalFactoryimplementsIAnimalFactory{
publicICatcreateCat（）{
returenewBlackCat（）;
publicIDogcreateDog（）{
returnnewBlackDog（）;
publicclassWhiteAnimalFactoryimplementsIAnimalFactory{
returnnewWhiteCat（）;
returnnewWhiteDog（）;
AbstractProduct
publicinterfaceICat{
voideat（）;
publicinterfaceIDog{
Concreteproduct
publicclassBlackCatimplementsICat{
publicvoideat（）{
Theblackcatiseating!
publicclassWhiteCatimplementsICat{
Thewhitecatiseating!
publicclassBlackDogimplementsIDog{
Theblackdogiseating"
publicclassWhiteDogimplementsIDog{
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（）;
Theblackdogiseating!
1.1.3建造者模式
将一个复杂对象的构成与它的表示分离，使同样的构建过程可以创建不同的表示。
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（）;
publocvoidbuildBody（）{
person.setBody（"
建造男人的身体"
publicvoidbuildFoot（）{
person.setFoot（"
建造男人的脚"
publicvoidbuildHead（）{
person.setHead（"
建造男人的头"
publicPersonbuildPerson（）{
retureperson;
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{
publicclassTest{
PersonDirectorpd=newPersonDirector（）;
Personperson=pd.constructPerson（newManBuilder（））;
System.out.println（person.getBody（））;
System.out.println（person.getFoot（））;
System.out.println（person.getHead（））;
建造男人的身体
建造男人的脚
建造男人的头
1.1.4单态模式
定义：
对象只要利用自己的属性完成了自己的任务，那该对象就是承担了责任，除了维持了自身的一致性，该对象无需承担其他任何责。
如果该对象还承担着其他责任，而其他对象又依赖于该特定对象所承担的责任，我们就需要得到该特定对象。
1.当类只能有一个单例而且客户可以从一个众所周知的访问点访问它时。
2.当这个唯一实例应该是通过子类化可扩展的，并且客户应该无需更改代码就能使用一个扩展的实例时。
3.将类的责任集中到唯一的单体对象中，确保该类只有一个实例，并且为该类提供一个全局访问点，这就是单体模式的目的。
Singleton
定义一个Instance操作，允许客户访问它的唯一实例。
Instance是一个类操作。
可能负责创建它自己的唯一实例。
分类：
1.饿汉式单体类：
类被加载的时候将自己初始化，更加安全些。
privatestaticXConfigReaderinstance=newXConfigReader（）;
privatevoidXConfigReader（）{}
privatestaticXConfigReadergetInstance（）{
returninstance;
2.懒汉式单体类：
在第一次被引用的时候将自己初始化。
提高了效率。
privatestaticXConfigReaderinstance=null;
privateXConfigReader（）{
SAXReaderreader=newSAXReader（）;
InputStreamin=Thread.currentThread（）.getContextClassLoader（）.getResourceAsStream（"
sys-config.xml"
try{
Documentdoc=reader.read（in）;
//取得jdbcConfig相关配置
ElementdriverNameElt=（Element）doc.selectObject（"
/config/db-info/driver-name"
ElementurlElt=（Element）doc.selectObject（"
/config/db-info/url"
ElementuserNameElt=（Element）doc.selectObject（"
/config/db-info/user-name"
ElementpasswordElt=（Element）doc.selectObject（"
/config/db-info/password"
//设置jdbcConfig相关配置
jdbcConfig.setDriverName（driverNameElt.getStringValue（））;
jdbcConfig.setUrl（urlElt.getStringValue（））;
jdbcConfig.setUserName（userNameElt.getStringValue（））;
jdbcConfig.setPassword（passwordElt.getStringValue（））;
System.out.println（"
读取jdbcConfig--------------------》》"
+jdbcConfig）;
}catch（DocumentExceptione）{
e.printStackTrace（）;
}
publicstaticsynchronizedXConfigReadergetInstance（）{
if（instance==null）{
instance=newXConfigReader（）;
}{
3.多例模式：
除了可以提供多个实例，其他和单体没有区别，包括有上限多例模式和没有上限的多例模式。
Singleton
publicclassSingleton{
privatestaticSingletonsing;
privateSingleton（）{
publicstaticSingletongetInstance（）{
if（sing==null）{
sing=newSingleton（）;
returnsing;
Singletonsing=Singleton.getInstance（）;
Singletonsing2=Singleton.getInstance（）;
System.out.println（sing）;
System.out.println（sing2）;
singleton.Singleton@1c78e57
1.1.5原型模式
用原型实例指定创建对象的种类，并且通过拷贝这些原型创建新的对象。
1.当一个系统应该独立于它的产品创建、构成和表示时。
2.当要实例化的类是在运行时刻指定时，例如，通过动态装载。
3.为了避免创建一个与产品类层次平行的工厂类层次时。
4.当一个类的实例只能有几个不同状态组合中的一种时。
建立相应数目的原型并克隆它们可能比每次用合适的状态手工实例化该类更方便一些。
1.Prototype
声明一个克隆自身的接口。
2.ConcretePrototype
实现一个克隆自身的操作。
3.Client
让一个原型克隆自身从而创建一个新的对象。
原型模式优缺点：
优点：
1.Prototype模式允许动态增加或减少产品类。
由于创建产品类实例的方法是产批类内部具有的，因此增加新产品对整个结构没有影响。
2.Prototype模式提供了简化的创建结构。
工厂方法模式常常需要有一个与产品类等级结构相同的等级结构，而Prototype模式就不需要这样。
3.Prototype模式具有给一个应用软件动态加载新功能的能力。
由于Prototype的独立性高，可以很容易动态加载新功能而不影响老系统。
4.产品类不需要非得有任何事先确定的等级结构，因为Prototype模式适用于任何的等级结构。
缺点：
每一个类必须配备一个克隆方法，而且这个克隆方法需要对类的功能进行通盘考虑，这对全新的类来说不是很难，但对已有的类进行改造时，不一定是件容易的事。
Prototype
publicclassPrototypeimplementsCloneable{
privateStringname;
publicvoidsetName（Stringname）{
this.name=name;
publicStringgetName（）{
returnthis.name;
publicObjectclone（）{
try{
returnsuper.clone（）;
}catch（Exceptione）{
e.printStackTrace（）;
returnnull;
ConcretePrototype
publicc
升级会员 