设计模式答辩.docx
《设计模式答辩.docx》由会员分享，可在线阅读，更多相关《设计模式答辩.docx（14页珍藏版）》请在冰豆网上搜索。
设计模式答辩
《大话设计模式》
设计模式简单介绍
&
学习总结
学号：
13700107
姓名：
庄鹏
完成日期：
2015年6月5日
目录:
目录
目录:
2
代理模式模式详解3
1真实场景&实例代码：
3
真实场景：
3
实例代码：
3
2模式带来的优缺点设计思想6
优点：
6
缺点：
6
设计思想：
6
定义：
6
思想与使用场景：
6
工厂模式详解8
3真实场景&实例代码：
8
真实场景：
8
实例代码：
8
4模式带来的优缺点设计思想10
优点：
10
缺点：
10
设计思想：
10
定义：
10
思想与使用场景：
10
原型设计模式详解12
5真实场景&实例代码：
12
真实场景：
12
实例代码：
12
2模式带来的优缺点设计思想13
优点：
13
缺点：
13
设计思想：
13
定义：
13
思想与使用场景：
13
设计模式总结14
1设计模式的由来：
14
1、1由来：
14
1、2设计模式的分类：
14
2设计模式的依据：
14
1、根本依据：
14
2、依据的开发原则：
15
3设计模式的本质：
15
4感悟：
15
代理模式模式详解
要求：
写实例代码，真实场景，使用这种模式带来的优缺点设计思想
1真实场景&实例代码：
真实场景：
当修改类A的数时，将这个数字乘以100赋给类B，而修改类B时，要将数除以100赋给类A。
类A类B互相影响
实例代码：
abstractclassAbstractColleague{
protectedintnumber;
publicintgetNumber（）{
returnnumber;
}
publicvoidsetNumber（intnumber）{
this.number=number;
}
//注意这里的参数不再是同事类，而是一个代理
publicabstractvoidsetNumber（intnumber,AbstractMediatoram）;
}
classColleagueAextendsAbstractColleague{
publicvoidsetNumber（intnumber,AbstractMediatoram）{
this.number=number;
am.AaffectB（）;
}
}
classColleagueBextendsAbstractColleague{
@Override
publicvoidsetNumber（intnumber,AbstractMediatoram）{
this.number=number;
am.BaffectA（）;
}
}
abstractclassAbstractMediator{
protectedAbstractColleagueA;
protectedAbstractColleagueB;
publicAbstractMediator（AbstractColleaguea,AbstractColleagueb）{
A=a;
B=b;
}
publicabstractvoidAaffectB（）;
publicabstractvoidBaffectA（）;
}
classMediatorextendsAbstractMediator{
publicMediator（AbstractColleaguea,AbstractColleagueb）{
super（a,b）;
}
//处理A对B的影响
publicvoidAaffectB（）{
intnumber=A.getNumber（）;
B.setNumber（number*100）;
}
//处理B对A的影响
publicvoidBaffectA（）{
intnumber=B.getNumber（）;
A.setNumber（number/100）;
}
}
publicclassClient{
publicstaticvoidmain（String[]args）{
AbstractColleaguecollA=newColleagueA（）;
AbstractColleaguecollB=newColleagueB（）;
AbstractMediatoram=newMediator（collA,collB）;
System.out.println（"==========通过设置A影响B=========="）;
collA.setNumber（1000,am）;
System.out.println（"collA的number值为：
"+collA.getNumber（））;
System.out.println（"collB的number值为A的10倍：
"+collB.getNumber（））;
System.out.println（"==========通过设置B影响A=========="）;
collB.setNumber（1000,am）;
System.out.println（"collB的number值为：
"+collB.getNumber（））;
System.out.println（"collA的number值为B的0.1倍：
"+collA.getNumber（））;
}
}
2模式带来的优缺点设计思想
优点：
∙适当地使用代理模式可以避免同事类之间的过度耦合，使得各同事类之间可以相对独立地使用。
∙使用代理模式可以将对象间一对多的关联转变为一对一的关联，使对象间的关系易于理解和维护。
∙使用代理模式可以将对象的行为和协作进行抽象，能够比较灵活的处理对象间的相互作用。
缺点：
对于大多数的情况，同事类之间的关系不会复杂到混乱不堪的网状结构，因此，大多数情况下，将对象间的依赖关系封装的同事类内部就可以的，没有必要非引入代理模式。
滥用代理模式，只会让事情变的更复杂。
设计思想：
定义：
用一个代理对象封装一系列的对象交互，代理使各对象不需要显示地相互作用，从而使耦合松散，而且可以独立地改变它们之间的交互
思想与使用场景：
在面向对象编程中，一个类必然会与其他的类发生依赖关系，完全独立的类是没有意义的。
一个类同时依赖多个类的情况也相当普遍，既然存在这样的情况，说明，一对多的依赖关系有它的合理性，适当的使用代理模式可以使原本凌乱的对象关系清晰，但是如果滥用，则可能会带来反的效果。
一般来说，只有对于那种同事类之间是网状结构的关系，才会考虑使用代理模式。
可以将网状结构变为星状结构，使同事类之间的关系变的清晰一些。
代理模式是一种比较常用的模式，也是一种比较容易被滥用的模式。
对于大多数的情况，同事类之间的关系不会复杂到混乱不堪的网状结构，因此，大多数情况下，将对象间的依赖关系封装的同事类内部就可以的，没有必要非引入代理模式。
滥用代理模式，只会让事情变的更复杂。
工厂模式详解
要求：
写实例代码，真实场景，使用这种模式带来的优缺点设计思想
3真实场景&实例代码：
真实场景：
场景如下：
汽车由发动机、轮、底盘组成，现在需要组装一辆车交给调用者
实例代码：
工厂代码：
（java）
接口：
interfaceIFactory{
publicICarcreateCar（）;
}
工厂类：
classFactoryimplementsIFactory{
publicICarcreateCar（）{
Engineengine=newEngine（）;
Underpanunderpan=newUnderpan（）;
Wheelwheel=newWheel（）;
ICarcar=newCar（underpan,wheel,engine）;
returncar;
}
}
调用组装汽车：
publicclassClient{
publicstaticvoidmain（String[]args）{
IFactoryfactory=newFactory（）;
ICarcar=factory.createCar（）;
car.show（）;
}
}}
4模式带来的优缺点设计思想
优点：
1、抽象工厂模式隔离了具体类的生产，使得客户并不需要知道什么被创建。
2、当一个产品族中的多个对象被设计成一起工作时，它能保证客户端始终只使用同一个产品族中的对象。
3、增加新的具体工厂和产品族很方便，无须修改已有系统，符合“开闭原则”。
缺点：
1、简单的对象如果使用工厂模式，就需要引入一个工厂类，会增加系统的复杂度。
2、增加新的产品等级结构很复杂，需要修改抽象工厂和所有的具体工厂类
设计思想：
定义：
一个用于创建对象的接口，让子类决定实例化哪一个类，工厂方法使一个类的实例化延迟到其子类。
思想与使用场景：
首先，工厂模式作为一种创建类模式，在任何需要生成复杂对象的地方，都可以使用工厂方法模式。
应用特点就是复杂对象适合使用工厂模式，而简单对象，特别是只需要通过new就可以完成创建的对象，无需使用工厂模式。
如果使用工厂模式，就需要引入一个工厂类，会增加系统的复杂度。
其次，工厂模式是一种典型的解耦模式，迪米特法则在工厂模式中表现的尤为明显。
假如调用者自己组装产品需要增加依赖关系时，可以考虑使用工厂模式。
将会大大降低对象之间的耦合度。
再次，由于工厂模式是依靠抽象架构的，它把实例化产品的任务交由实现类完成，扩展性比较好。
也就是说，当需要系统有比较好的扩展性时，可以考虑工厂模式，不同的产品用不同的实现工厂来组装。
原型设计模式详解
要求：
写实例代码，真实场景，使用这种模式带来的优缺点设计思想
5真实场景&实例代码：
真实场景：
实现一个接口，重写一个方法完成一个简单的原型模式
实例代码：
classPrototypeimplementsCloneable{
publicPrototypeclone（）{
Prototypeprototype=null;
try{
prototype=（Prototype）super.clone（）;
}catch（CloneNotSupportedExceptione）{
e.printStackTrace（）;
}
returnprototype;
}
}
classConcretePrototypeextendsPrototype{
publicvoidshow（）{
System.out.println（"原型模式实现类"）;
}
}
publicclassClient{
publicstaticvoidmain（String[]args）{
ConcretePrototypecp=newConcretePrototype（）;
for（inti=0;i<10;i++）{
ConcretePrototypeclonecp=（ConcretePrototype）cp.clone（）;
clonecp.show（）;
}
}
}
2模式带来的优缺点设计思想
优点：
使用原型模式创建对象比直接new一个对象在性能上要好的多，因为Object类的clone方法是一个本地方法，它直接操作内存中的二进制流，特别是复制大对象时，性能的差别非常明显。
使用原型模式的另一个好处是简化对象的创建，使得创建对象就像我们在编辑文档时的复制粘贴一样简单。
缺点：
1、单例模式与原型模式是冲突的
2、Object类的clone方法只会拷贝对象中的基本的数据类型，对于数组、容器对象、引用对象等都不会拷贝，这就是浅拷贝。
如果要实现深拷贝，必须将原型模式中的数组、容器对象、引用对象等另行拷贝。
设计思想：
定义：
用原型实例指定创建对象的种类，并通过拷贝这些原型创建新的对象。
思想与使用场景：
在需要重复地创建相似对象时可以考虑使用原型模式。
比如需要在一个循环体内创建对象，假如对象创建过程比较复杂或者循环次数很多的话，使用原型模式不但可以简化创建过程，而且可以使系统的整体性能提高很多
设计模式总结
要求：
总结设计模式（设计模式的由来，依据，本质，感悟）
1设计模式的由来：
1、1由来：
（个人理解）：
是软件长期开发（面向对象）中人们总结并经验逐渐有了一个简单的开发编写代码的流程，继而提出相应的原则与理论体系。
人们根据这些原则与体系逐渐摸索并提出来具有普遍适应（各个厂家）的编程方法与方式即1设计模式
1、2设计模式的分类：
设计模式分为三种类型，共23种。
1、创建型模式：
单例模式、抽象工厂模式、建造者模式、工厂模式、原型模式。
2、结构型模式：
适配器模式、桥接模式、装饰模式、组合模式、外观模式、享元模式、代理模式。
3、行为型模式：
模版方法模式、命令模式、迭代器模式、观察者模式、中介者模式、备忘录模式、解释器模式、状态模式、策略模式、职责链模式、访问者模式。
2设计模式的依据：
1、根本依据：
代码复用，增加可维护性。
2、依据的开发原则：
依据面向对象的几个原则
开闭原则（OpenClosedPrinciple，OCP）、
里氏代换原则（LiskovSubstitutionPrinciple，LSP）、
依赖倒转原则（DependencyInversionPrinciple，DIP）、
接口隔离原则（InterfaceSegregationPrinciple，ISP）、
合成/聚合复用原则（Composite/AggregateReusePrinciple，CARP）、
最小知识原则（PrincipleofLeastKnowledge，PLK，也叫迪米特法则）。
开闭原则具有理想主义的色彩，它是面向对象设计的终极目标。
其他几条，则可以看做是开闭原则的实现方法。
设计模式就是实现了这些原则，从而达到了代码复用、增加可维护性的目的。
3设计模式的本质：
设计模式是一套被反复使用、多数人知晓的、经过分类编目的、代码设计经验的总结。
如同：
建筑的设计标准一样：
各个地形（场景）适应不同的建筑结构（设计模式）
4感悟：
学习感悟：
（个人感觉）设计模式有点像数学中的计算公式，不同的题型有不同的公式可以套用
公式（设计模式）的运用可以简化解题的过程。
同样，设计模式的应用于学习可以简化软件的开发与设计过程。
个人认为设计模式优点：
1、给设计软件的人一个方向与思路，给出了一个简单的实现软件功能的方向
2、简化了，程序的编写（让人逻辑思路清晰。
）
3、可以减少代码量，增加代码复用（以前编写的类似代码可以改改继续使用）
升级会员 