Java各种设计模式详解整理版.docx
- 文档编号:9346538
- 上传时间:2023-02-04
- 格式:DOCX
- 页数:95
- 大小:2.22MB
Java各种设计模式详解整理版.docx
《Java各种设计模式详解整理版.docx》由会员分享,可在线阅读,更多相关《Java各种设计模式详解整理版.docx(95页珍藏版)》请在冰豆网上搜索。
Java各种设计模式详解整理版
Java设计模式
1.设计模式(超级详细)
(1)设计模式是一套被反复使用、多数人知晓的、经过分类编目的、代码设计经验的总结。
使用设计模式是为了可重用代码、让代码更容易被他人理解、保证代码可靠性。
代码规范
(1)首先是要注意注释文档的格式,注释文档将用来生成HTML格式的代码报告,所以注释文档必须书写在类、域、构造函数、方法、定义之前。
(2)注释文档由两部分组成——描述、块标记。
描述部分用来书写类的作用或者相关信息,块标记部分必
(3)注释的种类:
文件头注释、构造函数注释、域注释、方法注释和定义注释。
文件头注释需要注明该文件的创建时间、文件名、命名空间信息。
构造函数注释采用描述部分注明构造函数的作用。
方法注释采用描述部分注明方法的功能,块标记注明方法的参数、返回值、异常等信息。
面向对象:
面向对象OO=面向对象的分析OOA+面向对象的设计OOD+面向对象的编程OOP
接口:
接口好比一种模板,这种模板定义了对象必须实现的方法,其目的就是让这些方法可以作为接口实例被引用。
接口不能被实例化。
类可以实现多个接口并且通过这些实现的接口被索引。
接口变量只能索引实现该接口的类的实例。
接口和抽象的区别:
(1)abstractclass在Java语音中表示的是一种继承关系,一个类只能使用一次继承关系。
但是一个类却可以实现多个interface.
(2)在abstractclass中可以有自己的数据成员,也可以有非abstract的成员方法,而在interface中,只能够有静态的不能被修改的数据成员(也就是必须是staticfinal的,不过在interface中一般不定义数据成员),所有的成员方法都是abstract的。
(3)Abstractclass和interface所反映出的设计理念不同。
其实abstractclasss表示的是"is---a"关系,interface表示的是“like---a”关系。
(4)实现抽象类和接口的类必须实现其中的所有方法。
抽象类中可以有非抽象方法。
接口中则不能有实现方法。
(5)接口中定义的变量默认是publicstaticfinal型,且必须给其初值,所以实现类中不能重新定义,也不能改变其值。
(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{
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();
}
}
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{
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!
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{
}
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
建造男人的身体
建造男人的脚
建造男人的头
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();
}{
returninstance;
}
}
3.多例模式:
除了可以提供多个实例,其他和单体没有区别,包括有上限多例模式和没有上限的多例模式。
类图
例子
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
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
- 配套讲稿:
如PPT文件的首页显示word图标,表示该PPT已包含配套word讲稿。双击word图标可打开word文档。
- 特殊限制:
部分文档作品中含有的国旗、国徽等图片,仅作为作品整体效果示例展示,禁止商用。设计者仅对作品中独创性部分享有著作权。
- 关 键 词:
- Java 各种 设计 模式 详解 整理