享元模式(FlyWeight)详解

享元模式

模式描述：

享元模式以共享的方式高效地支持大量的细粒度对象。

享元对象能做到共享的关键是区分内蕴状态和外蕴状态:

?内蕴状态（Internal State）是存储在享元对象内部并且不会随环境改变而改变。

因此内蕴状态并可以共享。

?外蕴状态（External State）是随环境改变而改变的、不可以共享的状态。享元对象的外蕴状态必须由客户端保存，并在享元对象被创建之后，在需要使用的时候再

传入到享元对象内部。外蕴状态与内蕴状态是相互独立的。

名称：

享元模式（Flyweight），Flyweight在拳击比赛中指最轻量级，即"蝇量级"，有些作者翻译为"羽量级"。这里使用"享元模式"更能反映模式的用意。

计算模型：

享元模式可以分为单纯享元模式和复合享元模式：

一、单纯享元模式结构图：

单纯享元模式构成说明：

1)抽象享元(Flyweight)角色：此角色是所有的具体享元类的超类，为这些类规定出需要

实现的公共接口。那些需要外蕴状态(External State)的操作可以通过调用商业方法以参数形式传入。

2)具体享元(ConcreteFlyweight)角色：实现抽象享元角色所规定的接口。如果有内蕴状

态的话，必须负责为内蕴状态提供存储空间。享元对象的内蕴状态必须与对象所处的周围环境无关，从而使得享元对象可以在系统内共享的。

3)享元工厂(FlyweightFactory)角色：本角色负责创建和管理享元角色。本角色必须保证

享元对象可以被系统适当地共享。当一个客户端对象调用一个享元对象的时候，享元工厂角色会检查系统中是否已经有一个复合要求的享元对象。如果已经有了，享元工厂角色就应当提供这个已有的享元对象；如果系统中没有一个适当的享元对象的话，享元工厂角色就应当创建一个合适的享元对象。

4)客户端(Client)角色：需要维护一个对所有享元对象的引用;需要自行存储所有享元对

象外蕴状态。

二、复合享元模式结构图：

复合享元模式构成说明：

1)抽象享元角色：此角色是所有的具体享元类的超类，为这些类规定出需要实现的公共

接口。那些需要外蕴状态(External State)的操作可以通过方法的参数传入。抽象享元的接口使得享元变得可能，但是并不强制子类实行共享，因此并非所有的享元对象都是可以共享的。

2)具体享元(ConcreteFlyweight)角色：实现抽象享元角色所规定的接口。如果有内蕴状

态的话，必须负责为内蕴状态提供存储空间。享元对象的内蕴状态必须与对象所处的周围环境无关，从而使得享元对象可以在系统内共享。有时候具体享元角色又叫做单纯具体享元角色，因为复合享元角色是由单纯具体享元角色通过复合而成的。

3)复合享元(UnsharableFlyweight)角色：复合享元角色所代表的对象是不可以共享的，

但是一个复合享元对象可以分解成为多个本身是单纯享元对象的组合。复合享元角色又称做不可共享的享元对象。

4)享元工厂(FlyweightFactoiy)角色：本角色负责创建和管理享元角色。本角色必须保

证享元对象可以被系统适当地共享。当一个客户端对象请求一个享元对象的时候，享元工厂角色需要检查系统中是否已经有一个符合要求的享元对象，如果已经有了，享元工厂角色就应当提供这个已有的享元对象；如果系统中没有一个适当的享元对象的话，享元工厂角色就应当创建一个新的合适的享元对象。

5)客户端(Client)角色：本角色还需要自行存储所有享元对象的外蕴状态。

配置约束：

享元模式应用的条件如下：

1.一个系统有大量的对象。

2.这些对象耗费大量的内存。

3.这些对象的状态中的大部分都可以外部化。

4.这些对象可以按照内蕴状态分成很多的组，当把外蕴对象从对象中剔除时，每一个

组都可以仅用一个对象代替。

5.软件系统不依赖于这些对象的身份，换言之，这些对象可以是不可分辨的。

特点：

享元模式的优点:

? 大幅度地降低内存中对象的数量。

??享元模式的缺点:

? 1:享元模式使得系统更加复杂。为了使对象可以共享，需要将一些状态外部化，这使得程序的逻辑复杂化。

??2:享元模式将享元对象的状态外部化，而读取外部状态使得运行时间稍微变长。

? 总结：

??享元模式一般是解决系统性能问题的，所以经常用于底层开发，在项目开发中并不常用。不变式：

1.存在一个享元工厂角色，负责创建和管理享元角色。

2.存在一个抽象享元角色，作为所有具体享元类的超类，为这些类规定出需要实现的

公共接口。

3.存在一个或多个具体享元角色，实现抽象享元角色所规定的接口。

代码：

单纯享元模式：

///?

????abstract?class?Flyweight

????{

????????//?Methods

????????///?

????????///?外蕴状态

????????abstract?public?void?Operation(int?extrinsicstate);

????}

///?

????class?ConcreteFlyweight?:?Flyweight

????{

????????private?string?intrinsicstate?=?"A";

????????//?Methods

????????override?public?void?Operation(int?extrinsicstate)

????????{

????????????Console.WriteLine("ConcreteFlyweight:?intrinsicst ate?{0},?extrinsicstate?{1}",intrinsicstate,?extrinsicstate);

????????}

????}

///?

????class?FlyweightFactory

????{

????????//?Fields

????????private?Dictionary?flyweights?=?

new?Dictionary();

????????private?static?readonly?FlyweightF actory?instance?=?

new?FlyweightFactory();

????????///?

????????private??FlyweightFactory()

????????{?????????

????????}

????????//?Methods

????????///?

????????///?内蕴状态

????????///?

????????public?Flyweight?GetFlyweight(stri ng?key)

????????{

????????????return?((Flyweight)flyweights[ key]);

????????}

????????///?

????????///?

????????public?static??FlyweightFactory?Si ngleton()

????????{

????????????return?FlyweightFactory.instan ce;

????????}?

????????///?

????????///?内蕴状态

????????///?具体享元对象

????????public?void?AddFlyweight(string?sK ey,?Flyweight?_Flyweight)

????????{

????????????flyweights.Add(sKey?,?_Flyweig ht);

????????}

????????public?Flyweight?factory(string?sK ey)

????????{

????????????if?(flyweights.ContainsKey(sKe y))

????????????{

????????????????return?this.GetFlyweight(s Key);

????????????}

????????????else

????????????{

????????????????this.AddFlyweight(sKey,?ne w?ConcreteFlyweight());

????????????????return?this.GetFlyweight(s Key);

????????????}?????

????????}

????}

///?

?class?Test

{

public static void main()

{

?? ??//?初始化外蕴状态值

????????????int?extrinsicstate?=?22;

????????????//享元工厂对象使用单例

????????????FlyweightFactory?f?=?FlyweightFactory.Singleto n?()?;

????????????//调用过程

????????????//向享元工厂对象请求一个内蕴状态为"X"的单纯享元对象

????????????Flyweight?fx?=?f.factory("X");

????????????//调用X的商业方法,X的外蕴状态值为21

????????????fx.Operation(--extrinsicstate);

????????????Flyweight?fy?=?f.factory("Y");

????????????fy.Operation(--extrinsicstate);

????????????Flyweight?fz?=?f.factory("Z");

????????????fz.Operation(--extrinsicstate);

}

}

public interface Flyweight {

public void operation(String state);

}

public class ConcerteFlyweight implements Flyweight{ //内蕴状态

private Character intrinsicState = null;

//传进来的参数属于外晕状态

public ConcerteFlyweight(Character state) {

this.intrinsicState = state;

}

public void operation(String state) {

}

}

public class FlyweightFactory {

private HashMap flies = new HashMap();

private Flyweight fly;

public FlyweightFactory(){

}

//字体样式

public Flyweight factory(Character state){

if(flies.containsKey(state)){

return (Flyweight)flies.get(state);

}else{

fly = new ConcerteFlyweight(state);

flies.put(state, fly);

return fly;

}

}

}

public class Client {

public static void main(String[] args){

FlyweightFactory factory=new FlyweightFactory();

Flyweight fly=factory.factory(new Character('a'));

fly.operation("罗马字符");

fly.operation("新罗马字符");

fly=factory.factory(new Character('b'));

fly.operation("阿拉伯字符");

}

}

复合享元模式：

public interface Flyweight {

public void operation(String state);

}

public class ConcreteFlyweight implements Flyweight {

private Character intrinsicState=null;

//构造子，内蕴状态作为参数传入

public ConcreteFlyweight(Character state)

{

this.intrinsicState=state;

}

//外蕴状态作为参数传入方法

public void operation(String state)

{

}

}

public class ConcreteCompositeFlyweight implements Flyweight{ private HashMap flies=new HashMap(10);

private Flyweight flyweight;

public ConcreteCompositeFlyweight() { }

//增加一个新的单纯享元对象到聚集中

public void add(Character key,Flyweight fly)

{

flies.put(key,fly);

}

//外蕴状态作为参数传入到方法中

public void operation(String extrinsicState)

{

Flyweight fly=null;

for(Iterator it=flies.entrySet().iterator();it.hasNext();) {

Map.Entry e=(Map.Entry)it.next();

fly=(Flyweight)e.getValue();

fly.operation(extrinsicState);

}

}

}

public class FlyweightFactory

{

private HashMap flies=new HashMap();

public FlyweightFactory() { }

//单纯享元工厂方法，所需状态以参量形式传入

public Flyweight factory(Character state)

{

if(flies.containsKey(state))

{

return (Flyweight)flies.get(state);

} else {

Flyweight fly=new ConcreteFlyweight(state);

flies.put(state,fly);

return fly;

}

}

//符合享元工厂方法，所需状态以参量形式传入，这个参量巧好可以使用string类型 public Flyweight factory(String compositeState)

{

ConcreteCompositeFlyweight compositeFly=new ConcreteCompositeFlyweight();

int length=compositeState.length();

Character state=null;

for(int i=0;i

{

state=new Character(compositeState.charAt(i));

compositeFly.add(state,this.factory(state));

}

return compositeFly;

}

}

public class Client {

/**

* @param args

*/

public static void main(String[] args) {

FlyweightFactory factory=new FlyweightFactory();

Flyweight fly=(Flyweight) factory.factory("abac");

fly.operation("罗马字符");

}

}

/*********************************

*设计模式--享元模式实现

*C++语言

*Author：WangYong

********************************/

#include

#include

#include

#include

using namespace std;

class Flyweight

{

public:

virtual ~Flyweight(){}

virtual void Operation(const string & extrinsicState){}

string GetIntrinsicState(){return this->_intrinsicState;}

protected:

Flyweight(string intrinsicState){this->_intrinsicState =

_intrinsicState;}

private:

string _intrinsicState;

};

class ConcreteFlyweight:public Flyweight

{

public:

ConcreteFlyweight(string

intrinsicState):Flyweight(intrinsicState)

{cout<<"ConcreteFlyweight Build ...."<

~ConcreteFlyweight(){}

void Operation(const string & extrinsicState)

{

cout<<"ConcreteFlyweight:内蕴

"<GetIntrinsicState()

<<"ConcreteFlyweight:外蕴"<

}

};

class FlyweightFactory

{

public:

FlyweightFactory(){}

~FlyweightFactory(){}

Flyweight * GetFlyweight(const string &key)

{

vector::iterator it = _fly.begin();

for(;it != _fly.end(); it++)

{

if( (*it)->GetIntrinsicState() == key)

cout<<"already created by users..."<

return *it;

}

Flyweight *fn = new ConcreteFlyweight(key);

_fly.push_back(fn);

return fn;

}

private:

vector _fly;

};

int main()

{

FlyweightFactory *fc = new FlyweightFactory();

Flyweight * fw1 = fc->GetFlyweight("hello");

Flyweight * fw2 = fc->GetFlyweight("world!");

Flyweight * fw3 = fc->GetFlyweight("hello");

}

典型应用：

一、享元模式在编辑器系统中大量使用。一个文本编辑器往往会提供很多种字体，而通常的

做法就是将每一个字母做成一个享元对象。享元对象的内蕴状态就是这个字母，而字母在文本中的位置和字模风格等其他信息则是外蕴状态。比如，字母a可能出现在文本的很多地方，虽然这些字母a的位置和字模风格不同，但是所有这些地方使用的都是同一个字母对象。这样一来，字母对象就可以在整个系统中共享。

二、享元模式在.NET Framework中的应用。String 无论在.NET 还是 Java中，都是一个特

殊的引用对象。我们可以试想，出现了这样一段代码：

String s=”Hello world”;

String s1=”Hello world”;

那么是不是每次都要重新的去申请一块内存，然后去保存这个字符串呢？那么这样的话是不是会效率很低呢？因为我们知道，字符串在实际使用中往往都是非常短暂的。他们通常

是被读出来之后，便直接展示给了客户。然后这个字符串的生命结束，变成垃圾。在.NET 和Java中，String都被以不变模式来进行设计。我们来简单的分析一下String的驻留机制：在CLR被加载之后，就会在SystemDomain的托管堆中去建立一个HashTable来维护String。

于是模拟代码如下：（伪代码）

也就是说，我是在模拟一个string s=”Hello world”的过程。过程是，首先，他先去找Hashtable中目前是否存有Key为”Hello world”的项。如果不存在，那么就分配一块堆内存，存储这字符串，然后将地址作为Value，存储在Hashtable中。如果存在的话，那么便直接找到该字符串所对应的地址，然后取出地址中的值。用一个Hashtable来控制String 对象的数量。

享元模式(FlyWeight)详解

享元模式 模式描述： 享元模式以共享的方式高效地支持大量的细粒度对象。 享元对象能做到共享的关键是区分内蕴状态和外蕴状态: ?内蕴状态（Internal State）是存储在享元对象内部并且不会随环境改变而改变。 因此内蕴状态并可以共享。 ?外蕴状态（External State）是随环境改变而改变的、不可以共享的状态。享元对象的外蕴状态必须由客户端保存，并在享元对象被创建之后，在需要使用的时候再 传入到享元对象内部。外蕴状态与内蕴状态是相互独立的。 名称： 享元模式（Flyweight），Flyweight在拳击比赛中指最轻量级，即"蝇量级"，有些作者翻译为"羽量级"。这里使用"享元模式"更能反映模式的用意。 计算模型： 享元模式可以分为单纯享元模式和复合享元模式： 一、单纯享元模式结构图： 单纯享元模式构成说明： 1)抽象享元(Flyweight)角色：此角色是所有的具体享元类的超类，为这些类规定出需要 实现的公共接口。那些需要外蕴状态(External State)的操作可以通过调用商业方法以参数形式传入。 2)具体享元(ConcreteFlyweight)角色：实现抽象享元角色所规定的接口。如果有内蕴状 态的话，必须负责为内蕴状态提供存储空间。享元对象的内蕴状态必须与对象所处的周围环境无关，从而使得享元对象可以在系统内共享的。 3)享元工厂(FlyweightFactory)角色：本角色负责创建和管理享元角色。本角色必须保证 享元对象可以被系统适当地共享。当一个客户端对象调用一个享元对象的时候，享元工厂角色会检查系统中是否已经有一个复合要求的享元对象。如果已经有了，享元工厂角色就应当提供这个已有的享元对象；如果系统中没有一个适当的享元对象的话，享元工厂角色就应当创建一个合适的享元对象。

java设计模式选择题复习

工厂系列模式的优缺点： 1.让用户的代码和某个特定类的子类的代码解耦 用户不必知道它所使用的对象是怎样创建的，只需知道该对象有哪些方法 2.抽象工厂模式可以为用户创建一系列相关的对象，使用户和创建这些对象的类脱耦 MVC模式是不是一种设计模式？为什么 MVC不是设计模式，应该是框架/架构模式，因为它的定义是抽象的，没有足够的细节描述使你直接去实现，而只能根据MVC的概念和思想，用几个设计模式组合实现。 举出一个生活中使用装饰者模式的例子，用程序实现思路 举个生活中的例子，俗话说“人在衣着马在鞍”，把这就话用装饰者模式的语境翻译一下，“人通过漂亮的衣服装饰后，男人变帅了，女人变漂亮了；”。对应上面的类图，这里人对应于ConcreteComponent,而漂亮衣服则对应于ConcreteDecorator； 设计模式如何分类，每一个类别都有什么特征？ 设计模式分为3类，分别是：创建型模式、行为型模式、结构型模式。 创建型特点：避免用户直接使用new运算符创建对象。 行为型特点：怎样合理的设计对象之间的交互通信，以及怎样合理的为对象分配职 结构型特点：主要用于处理类或对象的组合 Java jdk中使用了哪些设计模式 1.单例 2.静态工厂 3.工厂方法 4.抽象工厂 5.构造者 6.原型 7.适配器8桥接9.组合10.装饰器11.外观12.享元 页脚内容1

14.代理15.迭代器16.观察者17.协调者18.模板方法19.策略20.责任链21.命令22.空对象25.解释器 面向对象的设计原则有哪些？ 开闭原则、面向抽象的原则（依赖倒转原则）、多用组合少用继承原则、高内聚-低耦合原则。 观察者模式的推拉有什么不同？使用场景 推，具体主题将变化后的数据全部交给具体观察者。场景：当具体主题认为具体观察者需要这些变换后的数据时，往往采用推数据方式； 拉，具体主题不将变化后的数据交给具体观察者，而是提供获得这些数据的方法。场景：当具体主题不知道具体观察者是否需要这些变换后的数据时，往往采用拉数据的方式。 策略模式和工厂模式有什么不同？ 策略模式定义了一系列算法，将他们一个个封装，并且他们之间可以相互替换； 工厂模式定义一个创建对象的接口，让子类决定实例化哪一个类 5观察者模式的推拉有什么不同？适用场景 现在要说的分歧在这里： “推”的方式是指，Subject维护一份观察者的列表，每当有更新发生，Subject会把更新消息主动推送到各个Observer去。 “拉”的方式是指，各个Observer维护各自所关心的Subject列表，自行决定在合适的时间去Subject获取相应的更新数据。 “推”的好处包括： 页脚内容2

23种设计模式趣味讲解

23种设计模式趣味讲解 对设计模式很有意思的诠释，呵呵，原作者不详。 创立型模式 1、FACTORY—追MM少不了请吃饭了，麦当劳的鸡翅和肯德基的鸡翅都是MM爱吃的东西，固然口味有所不同，但不管你带MM往麦当劳或肯德基，只管向服务员说“来四个鸡翅”就行了。麦当劳和肯德基就是生产鸡翅的Factory 工厂模式：客户类和工厂类离开。花费者任何时候需要某种产品，只需向工厂恳求即可。花费者无须修正就可以接纳新产品。毛病是当产品修正时，工厂类也要做相应的修正。如：如何创立及如何向客户端供给。 2、BUILDER—MM最爱听的就是“我爱你”这句话了，见到不同处所的MM,要能够用她们的方言跟她说这句话哦，我有一个多种语言翻译机，上面每种语言都有一个按键，见到MM 我只要按对应的键，它就能够用相应的语言说出“我爱你”这句话了，国外的MM也可以轻松搞掂，这就是我的“我爱你”builder。（这必定比美军在伊拉克用的翻译机好卖） 建造模式：将产品的内部表象和产品的天生过程分割开来，从而使一个建造过程天生具有不同的内部表象的产品对象。建造模式使得产品内部表象可以独立的变更，客户不必知道产品内部组成的细节。建造模式可以强迫履行一种分步骤进行的建造过程。 3、FACTORY METHOD—请MM往麦当劳吃汉堡，不同的MM有不同的口味，要每个都记住是一件烦人的事情，我一般采用Factory Method模式，带着MM到服务员那儿，说“要一个汉堡”，具体要什么样的汉堡呢，让MM直接跟服务员说就行了。 工厂方法模式：核心工厂类不再负责所有产品的创立，而是将具体创立的工作交给子类往做，成为一个抽象工厂角色，仅负责给出具体工厂类必须实现的串口，而不接触哪一个产品类应当被实例化这种细节。 4、PROTOTYPE—跟MM用QQ聊天，必定要说些深情的话语了，我搜集了好多肉麻的情话，需要时只要copy出来放到QQ里面就行了，这就是我的情话prototype了。（100块钱一份，你要不要） 原始模型模式：通过给出一个原型对象来指明所要创立的对象的类型，然后用复制这个原型对象的方法创立出更多同类型的对象。原始模型模式容许动态的增加或减少产品类，产品类不需要非得有任何事先断定的等级结构，原始模型模式实用于任何的等级结构。毛病是每一个类都必须配备一个克隆方法。 5、SINGLETON—俺有6个美丽的老婆，她们的老公都是我，我就是我们家里的老公Sigleton，

java设计模式享元模式

java设计模式———享元模式 享元模式的结构 享元模式采用一个共享来避免大量拥有相同内容对象的开销。这种开销最常见、最直观的就是内存的损耗。享元对象能做到共享的关键是区分内蕴状态(Internal State)和 外蕴状态(External State)。 一个内蕴状态是存储在享元对象内部的，并且是不会随环境的改变而有所不同。因此，一个享元可以具有内蕴状态并可以共享。 一个外蕴状态是随环境的改变而改变的、不可以共享的。享元对象的外蕴状态必须由客户端保存，并在享元对象被创建之后，在需要使用的时候再传入到享元对象内部。外蕴状态不可以影响享元对象的内蕴状态，它们是相互独立的。 享元模式的优点：减少对象数量，节省内存空间。 享元模式的缺点：维护共享对象，需要额外的开销（用一个线程来维护垃圾回收）。 享元模式的本质：分离与共享 何时使用享元模式：如果一个应用程序使用了大量的细粒度对象，可以使用享元模式来减少对象数量。

如果使用大量的对象，造成很大的存储开销，可以使用享元模式来减少对象数量，并节约内存。 如果对象的大多数状态都可以转变为外部状态，可以使用享元对象来实现外部状态与内部状态的分离。享元模式可以分成单纯享元模式和复合享元模式两种形式。 单纯享元模式 在单纯的享元模式中，所有的享元对象都是可以共享的。 单纯享元模式所涉及到的角色如下： 抽象享元(Flyweight)角色：给出一个抽象接口，以规定出所有具体享元角色需要实现的方法。具体享元(ConcreteFlyweight)角色：实现抽象享元角色所规定出的接口。如果有内蕴状态的话，必须负责为内蕴状态提供存储空间。享元工厂(FlyweightFactory)角色：本角色负责创建和管理享元角色。本角色必须保证享元对象可以被系统适当地共享。当一个客户端对象调用一个享元对象的 时候，享元工厂角色会检查系统中是否已经有一个符合要求的享元对象。如果已经有了，享元工厂角色就应当提供这个已有的享元对象；如果系统中没有一个适当的享元对象

24种设计模式的定义和使用场合

一.创建型模式(Creational): 简单工厂模式(simpleFactory)发音:['simpl] ['f?kt(?)r?] 定义: 提供一个创建对象实例的功能,而无须关心其具体实现.被创建实例的类型可以是接口,抽象类,也可以是具体的类. 1.抽象工厂(AbstractFactory)发音: ['?bstr?kt] 定义: 提供一个创建一系列相关或相互依赖对象的接口,而无需指定他们具体的类. 使用场合: 1.如果希望一个系统独立于它的产品的创建,组合和表示的时候,换句话书,希望一个系统只是知道产品的接口,而不关心实现的时候. 2.如果一个系统要由多个产品系列中的一个来配置的时候.换句话说,就是可以,就是可以动态地切换产品簇的时候. 3.如果强调一系列相关产品的接口,以便联合使用他们的时候 2.建造者模式(Builder)发音: ['b?ld?] 定义: 将复杂对象的构建与它的表示分离,使得同样的构建过程可以创建不同的表示. 使用场合: 1.如果创建对象的算法,应该独立于该对象的组成部分以及它们的装配方式时 2.如果同一个构建过程有着不同的表示时 3.工厂方法模式(Factory Method) 定义: 为创建对象定义一个接口,让子类决定实例化哪个类.工厂方法让一个类的实例化延迟到了子类. 使用场景: 1.客户类不关心使用哪个具体类,只关心该接口所提供的功能. 2.创建过程比较复杂,例如需要初始化其他关联的资源类,读取配置文件等. 3.接口有很多具体实现或者抽象类有很多具体子类时, 4.不希望给客户程序暴露过多的此类的内部结构,隐藏这些细节可以降低耦合度. 5.优化性能,比如缓存大对象或者初始化比较耗时的对象. 4.原型模式(Prototype Method)发音: ['pr??t?ta?p] 定义: 使用原形实例指定将要创建的对象类型,通过复制这个实例创建新的对象. 应用场合: 1.如果一个系统想要独立于它想要使用的对象时,可以使用原型模式,让系统只面向接口编程,在系统需要新的对象的时候,可以通过克隆原型来得到. 2.如果需要实例化的类是在运行时刻动态指定时,可以使用原型模式,通过克隆原型来得到需要的实例.

《JAVA设计模式》期末考试复习资料资料讲解

《JAVA设计模式》复习资料 一、单项选择题 1．设计模式起源于（） A、机械设计 B、建筑工程设计 C、水利工程设计 D、工业电力化设计 2．“不要和陌生人说话”是（）原则的通俗表述。 A、接口隔离 B、里氏替换 C、依赖倒置 D、迪米特 3．目前常见的设计模式主要有（）种。 A、23 B、21 C、32 D、28 4．以下关于单一职责原则的叙述不正确的是（）。 A、单一职责原则的英文名称是Single Responsibility Principle. B、单一职责原则要求一个类只有一个职责 C、单一职责原则有利于对象的稳定，降低类的复杂性 D、单一职责原则提高了类之间的耦合性 5．以下关于依赖倒置原则的叙述不正确的是（） A、依赖倒置原则的简称是DIP B、高层模块不依赖于低层模块，低层模块依赖于高层模块 C、依赖倒置原则中高层模块和低层模块都依赖于抽象 D、依赖倒置原则实现模块间的松耦合 6．下面关于单例模式说法错误的是（） A、单例模式是指一个类只有一个实例 B、单例类从实现方式上分为懒汉式和饿汉式 C、单例类从功能上分为状态单例类和无状态单例类 D、可以通过继承的方式对单例类进行扩展得到功能更丰富的单例类 7．下面关于工厂方法模式说法错误的是（）。 A、工厂方法模式使一个类是实例化延迟到其子类中 B、工厂方法模式中具有抽象工厂、具体工厂、抽象产品和具体产品4个角色 C、工厂方法模式可以处理多个产品的多个等级结构 D、工厂方法模式可以屏蔽产品类 8．在以下情况不适合使用责任职责链模式（） A、有多个对象可以处理请求，哪个对象处理该请求在运行时刻自动确定。 B、在需要用比较通用和复杂的对象指针代替简单的指针的时候。 C、你想在不明确指定接收者的情况下，向多个对象中的一个提交一个请求。 D、一个请求需要一系列的处理工作。 9．当我们想创建一个具体的对象而又不希望指定具体的类时，可以使用（）模式 A、结构型 B、创建型 C、行为型 D、以上都可以 10．以下用来描述适配器模式的是（） A、表示一个作用于某对象结构中的各元素的操作，它使你可以在不改变各元素的类的前提下定义作用于这些元素的新操作。 B、定义一个用于创建对象的接口，让子类决定实例化哪一个类。

软件设计模式复习题

软件设计模式复习题 1、熟悉每个设计模式的定义、模式UML图解、模式使用情形以及模式优缺点。 2、设计模式的两大主题是什么？ 3、设计模式分成几大类？每大类各包含哪些模式？ 4、为什么要使用设计模式？使用设计模式有哪些好处？ 5、比较抽象工厂模式和工厂方法模式相似性和差异性。什么情况下使用抽象工厂模式？什 么情形下使用工厂方法模式？ 6、简述原型模式中浅层克隆和深度克隆的区别？分别给出代码说明。 7、模板方法和普通的实现类继承抽象类方式有何区别？ 8、是比较和分析适配器模式和桥接模式之间的共性和差异性。 9、请用组合模式实现学校人事管理模式。 10、综合应用装饰模式、命令模式和状态模式实现工具条命令按钮鼠标进入时高亮显示 状态以及鼠标单击按钮后呈现凹陷状态，表明当前按钮为选中状态。 11、请阐述享元模式是如何节省系统内存的？试举例分析使用享元模式前后的内存节 约之比。 12、使用解析器模式实现对学生成绩表的查询输入语句进行解析并执行查询，成绩表结 14、试比较和分析中介者模式和观察者模式之间的相似性和差异性？两者是否能够相 互转化？ 15、模板方法和普通的抽象类继承有什么区别？ 16、使用访问者模式对12题中的学生信息进行报到。 1、熟悉每个设计模式的定义、模式UML图解、模式使用情形以及模式优缺点。（见书）答：单件模式： ○1单例模式：class Singleton{private static Singleton instance; private Singleton(){} public static Singleton GetInstance(){if (instance == null) { instance = new Singleton();} return instance; } 客户端代码：class Program{static void Main(string[] args) { Singleton s1 = Singleton.GetInstance(); Singleton s2 = Singleton.GetInstance(); if (s1 = = s2) {Console.WriteLine("Objects are the same instance");} Console.Read();}} ○2多线程时的单例（Lock是确保当一个线程位于代码的临界区时，另一个线程不进入临界区。如果其他线程试图进入锁定的代码，则它将一直等待（即被阻止），直到该对象被释放）class Singleton{private static Singleton instance; private static readonly object syncRoot = new object(); private Singleton(){} public static Singleton GetInstance(){lock (syncRoot) {

第4章结构型模式实训

第4章结构型模式实训 实训练习 4.3.1 选择题 1. 某公司开发一个文档编辑器，该编辑器允许在文档中直接嵌入图形对象，但开销很大。用户在系统设计之初提出编辑器在打开文档时必须十分迅速，可以暂时通过一些符号来表示相应的图形。针对这种需求，公司可以采用( )避免同时创建这些图形对象。 A. 代理模式 B. 外观模式 C. 桥接模式 D. 组合模式 2. 下面的( )模式将对象组合成树形结构以表示“部分-整体”的层次结构，并使得用户对单个对象和组合对象的使用具有一致性。 A. 组合(Composite) B. 桥接(Bridge) C. 装饰(Decorator) D. 外观(Facade) 3. 已知某子系统为外界提供功能服务，但该子系统中存在很多粒度十分小的类，不便被外界系统直接使用，采用( )设计模式可以定义一个高层接口，这个接口使得这一子系统更加容易使用。 A. Facade（外观） B. Singleton（单例） C. Participant（参与者） D. Decorator（装饰） 4. 当不能采用生成子类的方法进行扩充时，可采用( )设计模式动态地给一个对象添加一些额外的职责。 A. Facade（外观） B. Singleton（单例） C. Participant（参与者） D. Decorator（装饰） 5. ( ①)设计模式将抽象部分与它的实现部分相分离，使它们都可以独立地变化。下图为该设计模式的类图，其中，( ②)用于定义实现部分的接口。 ① A. Singleton（单例） B. Bridge（桥接） C. Composite（组合） D. Facade（外观） ② A. Abstraction B. ConcreteImplementorA C. ConcreteImplementorB D. Implementor 6. ( ①)限制了创建类的实例数量，而( ②)将一个类的接口转换成客户希望的另外一个接口，使得原本由于接口不兼容而不能一起工作的那些类可以一起工作。 ① A. 命令模式(Command) B. 适配器模式(Adapter)

《JAVA设计模式》期末考试复习

《J A V A设计模式》复习资料 一、单项选择题 1．设计模式起源于（） A、机械设计 B、建筑工程设计 C、水利工程设计 D、工业电力化设计 2．“不要和陌生人说话”是（）原则的通俗表述。 A、接口隔离 B、里氏替换 C、依赖倒置 D、迪米特3．目前常见的设计模式主要有（）种。 A、23 B、21 C、32 D、28 4．以下关于单一职责原则的叙述不正确的是（）。 A、单一职责原则的英文名称是SingleResponsibilityPrinciple. B、单一职责原则要求一个类只有一个职责 C、单一职责原则有利于对象的稳定，降低类的复杂性 D、单一职责原则提高了类之间的耦合性 5．以下关于依赖倒置原则的叙述不正确的是（） A、依赖倒置原则的简称是DIP B、高层模块不依赖于低层模块，低层模块依赖于高层模块 C、依赖倒置原则中高层模块和低层模块都依赖于抽象 D、依赖倒置原则实现模块间的松耦合 6．下面关于单例模式说法错误的是（） A、单例模式是指一个类只有一个实例 B、单例类从实现方式上分为懒汉式和饿汉式 C、单例类从功能上分为状态单例类和无状态单例类 D、可以通过继承的方式对单例类进行扩展得到功能更丰富的单例类7．下面关于工厂方法模式说法错误的是（）。 A、工厂方法模式使一个类是实例化延迟到其子类中 B、工厂方法模式中具有抽象工厂、具体工厂、抽象产品和具体产品4个角色 C、工厂方法模式可以处理多个产品的多个等级结构 D、工厂方法模式可以屏蔽产品类 8．在以下情况不适合使用责任职责链模式（） A、有多个对象可以处理请求，哪个对象处理该请求在运行时刻自动确定。 B、在需要用比较通用和复杂的对象指针代替简单的指针的时候。 C、你想在不明确指定接收者的情况下，向多个对象中的一个提交一个请求。 D、一个请求需要一系列的处理工作。 9．当我们想创建一个具体的对象而又不希望指定具体的类时，可以使用（）模式 A、结构型 B、创建型 C、行为型 D、以上都可以 10．以下用来描述适配器模式的是（）

23种模式详解

总体来说设计模式分为三大类： 创建型模式，共五种：工厂方法模式、抽象工厂模式、单例模式、建造者模式、原型模式。结构型模式，共七种：适配器模式、装饰器模式、代理模式、外观模式、桥接模式、组合模式、享元模式。 行为型模式，共十一种：策略模式、模板方法模式、观察者模式、迭代子模式、责任链模式、命令模式、备忘录模式、状态模式、访问者模式、中介者模式、解释器模式。 其实还有两类：并发型模式和线程池模式。用一个图片来整体描述一下： 二、设计模式的六大原则 1、开闭原则（Open Close Principle）

开闭原则就是说对扩展开放，对修改关闭。在程序需要进行拓展的时候，不能去修改原有的代码，实现一个热插拔的效果。所以一句话概括就是：为了使程序的扩展性好，易于维护和升级。想要达到这样的效果，我们需要使用接口和抽象类，后面的具体设计中我们会提到这点。 2、里氏代换原则（Liskov Substitution Principle） 里氏代换原则(Liskov Substitution Principle LSP)面向对象设计的基本原则之一。里氏代换原则中说，任何基类可以出现的地方，子类一定可以出现。LSP是继承复用的基石，只有当衍生类可以替换掉基类，软件单位的功能不受到影响时，基类才能真正被复用，而衍生类也能够在基类的基础上增加新的行为。里氏代换原则是对“开-闭”原则的补充。实现“开-闭”原则的关键步骤就是抽象化。而基类与子类的继承关系就是抽象化的具体实现，所以里氏代换原则是对实现抽象化的具体步骤的规范。—— From Baidu 百科 3、依赖倒转原则（Dependence Inversion Principle） 这个是开闭原则的基础，具体内容：真对接口编程，依赖于抽象而不依赖于具体。 4、接口隔离原则（Interface Segregation Principle） 这个原则的意思是：使用多个隔离的接口，比使用单个接口要好。还是一个降低类之间的耦合度的意思，从这儿我们看出，其实设计模式就是一个软件的设计思想，从大型软件架构出发，为了升级和维护方便。所以上文中多次出现：降低依赖，降低耦合。 5、迪米特法则（最少知道原则）（Demeter Principle） 为什么叫最少知道原则，就是说：一个实体应当尽量少的与其他实体之间发生相互作用，使得系统功能模块相对独立。 6、合成复用原则（Composite Reuse Principle） 原则是尽量使用合成/聚合的方式，而不是使用继承。 三、Java的23中设计模式 从这一块开始，我们详细介绍Java中23种设计模式的概念，应用场景等情况，并结合他们的特点及设计模式的原则进行分析。 1、工厂方法模式（Factory Method） 工厂方法模式分为三种：

java笔试题目及答案分析

Java上市公司笔试题目及答案分析 一、选择题（不定项选题） 1下面说法正确的是（ C ） A．Java中包的主要作用是实现跨平台功能 B．package语句只能放在import语句后 C．包（package）是由一组类（class) 和接口（inter'face)组成 D．无 2不能用来修饰interface的有（ACD ） Aprivate Bpublic Cprotected Dstatic 3在Java语言中,下列关于字符编码和国际化的叙述，哪些是正确的（CD） A每个中文字符占用2个字节，每个英文字符占用1个字节 B假设数据库中的字符是以GBK编码的，那么显示数据库数据的网页也必须是GBK编码的。 CJava的char类型，通常以UTF-16 Big Endian的方式保存一个字符。 D实现国际化应用常用的手段是利用ResourceBundle类 解析： 1.不同的编码格式，字符所占用的字节数是不一样的。如GBK中每个中文占用2个字 节，UTF-8中则是变长编码，可能占用3个字节或者4个字节。因此A不正确。 2.不同的编码方式之间是可以转换的，如果数据库GBK编码，页面上可以使用任意 支持汉字编码的编码方式显示都可以，只要在向页面传输的数据过程中进行编码的转换即可。如：数据库是GBK，页面上是UTF-8,那么可以这样转换：实例代码以java语法编写 4下面代码的执行结果是（C ） public class TestDemo { public static void main(String[] args) { System.out.println(test1());

享元模式

享元模式(Flyweight Pattern) 面向对象的代价 面向对象很好地解决了系统抽象性的问题，同时在大多数情况下，也不会损及系统的性能。但是，在 某些特殊的应用中下，由于对象的数量太大，采用面向对象会给系统带来难以承受的内存开销。比如: 图形应用中的图元等对象、字处理应用中的字符对象等。 动机(Motivate): 采用纯粹对象方案的问题在于大量细粒度的对象会很快充斥在系统中，从而带来很高的运行时代价--------主要指内存需求方面的代价。 如何在避免大量细粒度对象问题的同时，让外部客户程序仍然能够透明地使用面向对象的方式来进行操作？ 意图(Intent): 运用共享技术有效地支持大量细粒度的对象。 -------《设计模式》GOF 结构(Struct):

适用性： 当以下所有的条件都满足时，可以考虑使用享元模式： 1、一个系统有大量的对象。 2、这些对象耗费大量的内存。 3、这些对象的状态中的大部分都可以外部化。 4、这些对象可以按照内蕴状态分成很多的组，当把外蕴对 象从对象中剔除时，每一个组都可以仅用一个对象代替。 5、软件系统不依赖于这些对象的身份，换言之，这些对象 可以是不可分辨的。 满足以上的这些条件的系统可以使用享元对象。最后，使用享元模式需要维护一个记录了系统已有的所有享元的表，而这需要耗费资源。因此，应当在有足够多的享元实例可供共享时才值得使用享元模式。 生活中的例子： 享元模式使用共享技术有效地支持大量细粒度的对象。公共交换电话网（PSTN）是享元的一个例子。有一些资源例如拨号音发生器、振铃发生器和拨号接收器是必须由所有用户共享的。当一个用户拿起听筒打电话时，他不需要知道使用了多少资源。对于用户而言所有的事情就是有拨号音，拨打号码，拨通电话。

《软件设计模式》教学设计2018(模板)

教 学 设 计 （理论版） 课程名称：软件设计模式 开课单位名称：信息科学与工程学院 授课教师：韩丞（讲师） 授课班级：16计科1班 授课学年学期：2018-2019学年第一学期

填表说明 1.该教学设计模板为理论课教学设计模板。“课程教学设计总概”是对该门课程教学设计的总体要求；“主题（章、节）教学设计”指具体内容的设计，教师要根据首页的“教学安排”整体情况，并视一次授课内容量，选择以主题或章或节作为设计单元；“课程教学反思”是教师本人在该门课程教学实施结束后的整体评价和反思。总概页、教学反思页内容在一门课程的教学设计中只需填写1次。所有表格均可添加页面。 2.封面内容 （1）“授课教师”内容包括授课教师的姓名和职称，以“张三（教授）”形式填写。 （2）“授课班级”内容分两种情况填写，“授课班级”是行政班的教学班应填写“年级、专业、班”信息，非行政班的教学班填写“混合教学班”。 3.总概内容 （1）“课程性质”参照2017级人才培养方案课程性质分类。 （2）“课程目标”指该门课程“课程标准”规定的课程目标。 （3）“学情分析”指对学生的性别构成、原有知识结构、学习动机、学习行为习惯、时间投入、资源获取方式等有效影响学习成效的因素进行分析。 （4）“课程资源”指纸质资源（如教材、参考资料、习题集、辅助资料等）、电子资源（如网站、网络课程、精品课程、视频公开课、PPT、电子学术论文、专著、会议报告等）、硬件资源（场馆、器材、设备、实验室等）、社会资源（如基地、平台、厂、所等）。 （5）“学时安排”采用“Ｘ学时”格式填写。 4.主题（章、节）教学设计内容 （1）“学习目标”描述学生完成学习后的行为表现，应用可观察的行为动词，学习行为表现要有成果物。采用“学生能够……”的方式进行表述。如：“学生能够根据案例给出的背景，综合分析案例中的外汇风险类型，并选择正确的外汇风险管理方法，能撰写分析报告并上交。”上述学习目标中的“分析”“选择”“撰写”“上交”等行为动词均可检测，忌用“知道”“掌握”“了解”等在“学习目标评价”中不能检测的行为动词，否则学习目标无法评价是否达到。 （2）“教学分析”中，“教学内容分析”指教师对讲解内容的分析，鼓励教师把教学内容系统化，用结构化图表或思维导图呈现；“教学重点”指教学内容中最基本、核心的内容；“教学难点”指学生不易理解的内容、技能。 （3）“学习效果评价”指为达成学习目标，教师对“学习目标”进行评价的设计活动。如上述“学习目标”中，教师组织学生“分析”“选择”“撰写”等活动。评价设计活动实施时，根据不同学习目标要求，可在课中评价，如“说出……”“分析……”“选择……”；也可在课后完成，比如“撰写……”“课后作业”等。 5.课程教学反思 “教学反思内容”指教师完成该门课程所有教学设计后，对“课程目标”的科学性、“课程资源”的时代性、“教学安排”的合理性、各“主题（章、节）教学设计”的有效性等内容进行再认识、再思考。

Java设计模式大作业

武汉轻工大学 数学与计算机学院 2018-2019学年第二学期 JAVA大作业 指导老师： ***** 专业：信息管理与信息系统 班级：信管1602班 学号： ********** 姓名： **** 2019年6月5日

Java设计模式学习体会 1、策略模式： 策略模式就是将能够通用的算法，封装成不同的组件，实现同一个接口，使之可以互换。 例子：SpringMVC的9大组件，都采用策略模式。比如HandlerMethodArgumentResolver，有非常多不同的实现类，这些实现类都可以互相替换来处理不同类型的参数，这就是策略模式。 我们知道一件事可能会有很多种方式来实现它，但是其中总有一种最高效的方式，在软件开发的世界里面同样如此，我们也有很多中方法来实现一个功能，但是我们需要一种简单、高效的方式来实现它，使得系统能够非常灵活，这就是策略模式。 所以策略模式就是定义了算法族，分别封装起来，让他们之前可以互相转换，此模式然该算法的变化独立于使用算法的客户。 在策略模式中它将这些解决问题的方法定义成一个算法群，每一个方法都对应着一个具体的算法，这里的一个算法我就称之为一个策略。虽然策略模式定义了算法，但是它并不提供算法的选择，即什么算法对于什么问题最合适这是策略模式所不关心的，所以对于策略的选择还是要客户端来做。客户必须要清楚的知道每个算法之间的区别和在什么时候什么地方使用什么策略是最合适的，这样就增加客户端的负担。 同时策略模式也非常完美的符合了“开闭原则”，用户可以在不修改原有系统的基础上选择算法或行为，也可以灵活地增加新的算法或行为。但是一个策略对应一个类将会是系统产生很多的策略类。 策略模式与模板方法模式的区别：比如一个抽象类有一个抽象方法，每个实现该抽象方法的具体实现都不同，就是模板方法模式，一般在抽象类中会有逻辑处理，只是用到了抽象的模板方法时，交给具体的子类去不同实现。 如果一个模板方法，被子类实现时，实现方式大都相同，比如模板方法为处理字符（10个子类可能只有两种实现，一种是处理为UTF-8，一种是处理成GBK），那么这个模板方法就应该使用策略模式。 2、观察者模式： 观察者模式就是将“观察者”注册给“被观察者”，当被观察者发生改变时，能够及时的通知所有观察者。 例子：比如listener或者事件触发等，都是观察者模式

设计模式主要分三个类型

设计模式主要分三个类型:创建型、结构型和行为型。 其中创建型有： 一、Singleton，单例模式：保证一个类只有一个实例，并提供一个访问它的全局访问点 二、Abstract Factory，抽象工厂：提供一个创建一系列相关或相互依赖对象的接口，而无须指定它们的具体类。 三、Factory Method，工厂方法：定义一个用于创建对象的接口，让子类决定实例化哪一个类，Factory Method使一个类的实例化延迟到了子类。 四、Builder，建造模式：将一个复杂对象的构建与他的表示相分离，使得同样的构建过程可以创建不同的表示。 五、Prototype，原型模式：用原型实例指定创建对象的种类，并且通过拷贝这些原型来创建新的对象。 行为型有： 六、Iterator，迭代器模式：提供一个方法顺序访问一个聚合对象的各个元素，而又不需要暴露该对象的内部表示。 七、Observer，观察者模式：定义对象间一对多的依赖关系，当一个对象的状态发生改变时，所有依赖于它的对象都得到通知自动更新。 八、Template Method，模板方法：定义一个操作中的算法的骨架，而将一些步骤延迟到子类中，TemplateMethod使得子类可以不改变一个算法的结构即可以重定义该算法得某些特定步骤。 九、Command，命令模式：将一个请求封装为一个对象，从而使你可以用不同的请求对客户进行参数化，对请求排队和记录请求日志，以及支持可撤销的操作。 十、State，状态模式：允许对象在其内部状态改变时改变他的行为。对象看起来似乎改变了他的类。 十一、Strategy，策略模式：定义一系列的算法，把他们一个个封装起来，并使他们可以互相替换，本模式使得算法可以独立于使用它们的客户。 十二、China of Responsibility，职责链模式：使多个对象都有机会处理请求，从而避免请求的送发者和接收者之间的耦合关系 十三、Mediator，中介者模式：用一个中介对象封装一些列的对象交互。 十四、Visitor，访问者模式：表示一个作用于某对象结构中的各元素的操作，它使你可以在不改变各元素类的前提下定义作用于这个元素的新操作。 十五、Interpreter，解释器模式：给定一个语言，定义他的文法的一个表示，并定义一个解释器，这个解释器使用该表示来解释语言中的句子。 十六、Memento，备忘录模式：在不破坏对象的前提下，捕获一个对象的内部状态，并在该对象之外保存这个状态。 结构型有： 十七、Composite，组合模式：将对象组合成树形结构以表示部分整体的关系，Composite使得用户对单个对象和组合对象的使用具有一致性。 十八、Facade，外观模式：为子系统中的一组接口提供一致的界面，fa?ade 提供了一高层接口，这个接口使得子系统更容易使用。 十九、Proxy，代理模式：为其他对象提供一种代理以控制对这个对象的访问

二十三种设计模式的通俗理解

二十三种设计模式的通俗理解 1、FACTORY 追MM少不了请吃饭了，麦当劳的鸡翅和肯德基的鸡翅都是MM爱吃的东西，虽然口味有所不同，但不管你带MM去麦当劳或肯德基，只管向服务员说“来四个鸡翅”就行了。麦当劳和肯德基就是生产鸡翅的Factory 工厂模式：客户类和工厂类分开。消费者任何时候需要某种产品，只需向工厂请求即可。消费者无须修改就可以接纳新产品。缺点是当产品修改时，工厂类也要做相应的修改。如：如何创建及如何向客户端提供。 2、BUILDER MM最爱听的就是“我爱你”这句话了，见到不同地方的MM,要能够用她们的方言跟她说这句话哦，我有一个多种语言翻译机，上面每种语言都有一个按键，见到MM我只要按对应的键，它就能够用相应的语言说出“我爱你”这句话了，国外的MM也可以轻松搞掂，这就是我的“我爱你”builder。（这一定比美军在伊拉克用的翻译机好卖）建造模式：将产品的内部表象和产品的生成过程分割开来，从而使一个建造过程生成具有不同的内部表象的产品对象。建造模式使得产品内部表象可以独立的变化，客户不必知道产品内部组成的细节。建造模式可以强制实行一种分步骤进行的建造过程。

3、FACTORY METHOD 请MM去麦当劳吃汉堡，不同的MM有不同的口味，要每个都记住是一件烦人的事情，我一般采用Factory Method模式，带着MM到服务员那儿，说“要一个汉堡”，具体要什么样的汉堡呢，让MM直接跟服务员说就行了。工厂方法模式：核心工厂类不再负责所有产品的创建，而是将具体创建的工作交给子类去做，成为一个抽象工厂角色，仅负责给出具体工厂类必须实现的接口，而不接触哪一个产品类应当被实例化这种细节。 4、PROTOTYPE 跟MM用QQ聊天，一定要说些深情的话语了，我搜集了好多肉麻的情话，需要时只要copy出来放到QQ里面就行了，这就是我的情话prototype了。（100块钱一份，你要不要）原始模型模式：通过给出一个原型对象来指明所要创建的对象的类型，然后用复制这个原型对象的方法创建出更多同类型的对象。原始模型模式允许动态的增加或减少产品类，产品类不需要非得有任何事先确定的等级结构，原始模型模式适用于任何的等级结构。缺点是每一个类都必须配备一个克隆方法。 5、SINGLETON 俺有6个漂亮的老婆，她们的老公都是我，我就是我们家里的老公Sigleton，她们只要说道“老公”，

《JAVA设计模式》期末考试复习资料

《JAVA设计模式》复习资料 、单项选择题 1．设计模式起源于（） A、机械设计 C、水利工程设计 2．“不要和陌生人说话”是（ A、接口隔离 B、里氏替换3．目前常见的设计模式主要有（ A、 23 B、 21 B 、建筑工程设计 D 、工业电力化设计）原则的通俗表述。 C、依赖倒置 D、迪米特 ）种。 C、 32 D、 28 4．以下关于单一职责原则的叙述不正确的是（）。 A、单一职责原则的英文名称是Si ngle Respo nsibility Prin ciple. B、单一职责原则要求一个类只有一个职责 C、单一职责原则有利于对象的稳定，降低类的复杂性 D、单一职责原则提高了类之间的耦合性 5．以下关于依赖倒置原则的叙述不正确的是（） A、依赖倒置原则的简称是DIP B、高层模块不依赖于低层模块，低层模块依赖于高层模块 C、依赖倒置原则中高层模块和低层模块都依赖于抽象 D、依赖倒置原则实现模块间的松耦合 6．下面关于单例模式说法错误的是（） A、单例模式是指一个类只有一个实例 B、单例类从实现方式上分为懒汉式和饿汉式 C、单例类从功能上分为状态单例类和无状态单例类 D、可以通过继承的方式对单例类进行扩展得到功能更丰富的单例类 7．下面关于工厂方法模式说法错误的是（）。 A、工厂方法模式使一个类是实例化延迟到其子类中 B、工厂方法模式中具有抽象工厂、具体工厂、抽象产品和具体产品4个角色 C、工厂方法模式可以处理多个产品的多个等级结构 D、工厂方法模式可以屏蔽产品类 8．在以下情况不适合使用责任职责链模式（） A、有多个对象可以处理请求，哪个对象处理该请求在运行时刻自动确定。 B、在需要用比较通用和复杂的对象指针代替简单的指针的时候。 C、你想在不明确指定接收者的情况下，向多个对象中的一个提交一个请求。 D、一个请求需要一系列的处理工作。 9．当我们想创建一个具体的对象而又不希望指定具体的类时，可以使用（）模式 A、结构型 B、创建型 C、行为型 D、以上都可以 10．以下用来描述适配器模式的是（） A、表示一个作用于某对象结构中的各元素的操作，它使你可以在不改变各元素的类的前提下定义作用于这些元素的新操作。 B、定义一个用于创建对象的接口，让子类决定实例化哪一个类。

23种设计模式的通俗理解

23种设计模式的通俗理解【转】 1、FACTORY 工厂方法 追MM少不了请吃饭了，麦当劳的鸡翅和肯德基的鸡翅都是MM爱吃的东西，虽然口味有所不同，但不管你带MM去麦当劳或肯德基，只管向服务员说“来四个鸡翅”就行了。麦当劳和肯德基就是生产鸡翅的Factory 工厂模式：客户类和工厂类分开。消费者任何时候需要某种产品，只需向工厂请求即可。消费者无须修改就可以接纳新产品。缺点是当产品修改时，工厂类也要做相应的修改。如：如何创建及如何向客户端提供。 2、BUILDER 抽象工厂 MM最爱听的就是“我爱你”这句话了，见到不同地方的MM,要能够用她们的方言跟她说这句话哦，我有一个多种语言翻译机，上面每种语言都有一个按键，见到MM我只要按对应的键，它就能够用相应的语言说出“我爱你”这句话了，国外的MM也可以轻松搞掂，这就是我的“我爱 你”builder。（这一定比美军在伊拉克用的翻译机好卖）建造模式：将产品的内部表象和产品的生成过程分割开来，从而使一个建造过程生成具有不同的内部表象的产品对象。建造模式使得产品内部表象可以独立的变化，客户不必知道产品内部组成的细节。建造模式可以强制实行一种分步骤进行的建造过程。 3、FACTORY METHOD 建造者模式 请MM去麦当劳吃汉堡，不同的MM有不同的口味，要每个都记住是一件烦人的事情，我一般采用Factory Method模式，带着MM到服务员那儿，说“要一个汉堡”，具体要什么样的汉堡呢，让MM直接跟服务员说就行了。工厂方法模式：核心工厂类不再负责所有产品的创建，而是将具体创建的工作交给子类去做，成为一个抽象工厂角色，仅负责给出具体工厂类必须实现的接口，而不接触哪一个产品类应当被实例化这种细节。 4、PROTOTYPE 原型模式 跟MM用QQ聊天，一定要说些深情的话语了，我搜集了好多肉麻的情话，需要时只要copy出来放到QQ里面就行了，这就是我的情话prototype了。（100块钱一份，你要不要）原始模型模式：通过给出一个原型对象来指明所要创建的对象的类型，然后用复制这个原型对象的方法创建出更多同类型的对象。原始模型模式允许动态的增加或减少产品类，产品类不需要非得有任何事先确定的等级结构，原始模型模式适用于任何的等级结构。缺点是每一个类都必须配备一个克隆方法。 5、SINGLETON 单态模式 俺有6个漂亮的老婆，她们的老公都是我，我就是我们家里的老公Sigleton，她们只要说道“老公”，都是指的同一个人，那就是我(刚才做了个梦啦，哪有这么好的事) 单例模式：单例模式确保某一个类只有一个实例，而且自行实例化并向整个系统提供这个实例单例模式。单例模式只应在有真正的“单一实例”的需求时才可使用。[b:9ceca65206]结构型模式[/b:9ceca65206] 6、ADAPTER 适配器模式 在朋友聚会上碰到了一个美女Sarah，从香港来的，可我不会说粤语，她不会说普通话，只好求助于我的朋友kent了，他作为我和Sarah之间的Adapter，让我和Sarah可以相互交谈了(也不知道他会不会耍我) 适配器（变压器）模式：把一个类的接口变换成客户端所期待的另一种接口，