C++设计模式
软件的架构与设计模式之模式的种类
【收藏】软件的架构与设计模式之模式的种类
C++设计模式之Adapter
2002-08-06· · ··COM集中营
由于[GOF95]是论述软件模式的著作的第一本，也是OO设计理论著作中最流行的一本，因此有些人常常使用设计模式（Design Pattern）一词来指所有直接处理软件的架构、设计、程序实现的任何种类的模式。另外一些人则强调要划分三种不同层次的模式：架构模式(Architectural Pattern)、设计模式(Design Pattern)、成例(Idiom)。成例有时称为代码模式(Coding Pattern)。
这三者之间的区别在于三种不同的模式存在于它们各自的抽象层次和具体
层次上。架构模式是一个系统的高层次策略，涉及到大尺度的组件以及整体性质和力学。架构模式的好坏可以影响到总体布局和框架性结构。设计模式是中等尺度的结构策略。这些中等尺度的结构实现了一些大尺度组件的行为和它们之间的关系。模式的好坏不会影响到系统的总体布局和总体框架。设计模式定义出子系统或组件的微观结构。代码模式（或成例）是特定的范例和与特定语言有关的编程技巧。代码模式的好坏会影响到一个中等尺度组件的内部、外部的结构或行为的底层细节，但不会影响到一个部件或子系统的中等尺度的结构，更不会影响到系统的总体布局和大尺度框架。
代码模式或成例(Coding Pattern 或 Idiom)
代码模式（或成例）是较低层次的模式，并与编程语言密切相关。代码模式描述怎样利用一个特定的编程语言的特点来实现一个组件的某些特定的方面或
关系。
较为著名的代码模式的例子包括双检锁（Double-Check Locking）模式等。
设计模式(Design Pattern)
一个设计模式提供一种提炼子系统或软件系统中的组件的，或者它们之间的关系的纲要设计。设计模式描述普遍存在的在相互通讯的组件中重复出现的结构，这种结构解决在一定的背景中的具有一般性的设计问题。
设计模式常常划分成不同的种类，常见的种类有：
创建型设计模式，如工厂方法（Factory Method）模式、抽象工厂（Abstract Factory）模式、原型（Prototype）模式、单例（Singleton）模式，建造（Builder）模式等
结构型设计模式，如合成（Composite）模式、装饰（Decorator）模式、代理（Proxy）模式、享元（Flyweight）模式、门面（Facade）模式、桥梁（Bridge）模式等
行为型模式，如模版方法（Template Method）模式、观察者（Observer）模式、迭代子（Iterator）模式、责任链（Chain of Responsibility）模式、备忘录（Memento）模式、命令（Command）模式、状态（State）模式、访问者（Visitor）模式等等。
以上是三种经典类型，实际上还有很多其他的类型，比如Fundamental型、Partition型，Relation型等等
设计模式在特定的编程语言中实现的时候，常常会用到代码模式。比如单例（Singleton）模式的实现常常涉及到双检锁（Double-Check Locking）模式等。
架构模式(Architectural Pattern)
一个架构模式描述软件系统里的基本的结构组织或纲要。架构模式提供一些事先定义好的子系统，指定它们的责任，并给出把它们组织在一起的法则和指南。有些作者把这种架构模式叫做系统模式[STELTING02]。
一个架构模式常常可以分解成很多个设计模式的联合使用。显然，MVC模式就是属于这一种模式。MVC模式常常包括调停者（Mediator）模式、策略（Strategy）模式、合成（Composite）模式、观察者（Observer）模式等。
此外，常见的架构模式还有：
·Layers（分层）模式，有时也称Tiers模式
·Blackboard（黑板）模式
·Broker（中介）模式
·Distributed Process（分散过程）模式
·Microkernel（微核）模式
架构模式常常划分成如下的几种：
一、 From Mud to Structure型。帮助架构师将系统合理划分，避免形成一个对象的海洋（A sea of objects）。包括Layers（分层）模式、Blackboard （黑板）模式、Pipes/Filters（管道/过滤器）模式等。
二、分散系统（Distributed Systems）型。为分散式系统提供完整的架构设计，包括像Broker（中介）模式等。
三、人机互动（Interactive Systems）型，支持包含有人机互动介面的系统的架构设计，例子包括MVC（Model-View-Controller）模式、PAC （Presentation-Abstraction-Control）模式等。
四、Adaptable Systems型，支持应用系统适应技术的变化、软件功能需求的变化。如Reflection（反射）模式、Microkernel（微核）模式等
一、功能
将一个类的接口转换成客户希望的另外一个接口，解决两个已有接口之间不匹配的问题。Adapter模式使得原本由于接口不兼容而不能一起工作的那些类可以一起工作。
二、结构图
(1)class adapter
(2)object adapter
三、实现
和其他很多模式一样，学习设计模式的重点是学习每种模式的思想，而不应拘泥于它的某种具体结构图和实现。因为模式是灵活的，其实现可以是千变万化的，只是所谓万变不离其宗。在STL中大量运用了Adapter模式，象function adapter、
iterator adpter，它们与这里说的adapter结构并不一样，但思想是一样的。具体的介绍可到侯捷网站上找相关文章，他讲得非常好。
四、示例代码
(1)class adapter
namespace DesignPattern_Adapter
{
// class Adaptee
class Adaptee
{
public:
void SpecialRequest() {}
} ;
// class Target
class Target
{
public:
virtual void Request() = 0 ;
} ;
// class Adapter
class Adapter : public Target, private Adaptee
{
public:
virtual void Request() { SpecialRequest() ; }
} ;
}
客户端代码：
{
using namespace DesignPattern_Adapter ;
Target *p = new Adapter() ;
p->Request() ; //实际上调用的是Adaptee::SpecialRequest()
}
(2)object adapter namespace DesignPattern_Adapter
{
// class Adaptee
class Adaptee
{
public:
void SpecialRequest() {}
} ;
// class Target
class Target
{
public:
virtual void Request() = 0 ;
} ;
// class Adapter
class Adapter : public Target
{
public:
virtual void Request() { _adaptee.SpecialRequest() ; } private:
Adaptee _adaptee ;
} ;
}
客户端代码：
{
using namespace DesignPattern_Adapter ;
Target *p = new Adapter() ;
p->Request() ; //实际上调用的是Adaptee::SpecialRequest() }
六、实例
(1)STL中的Class Adapter
STL中的Adapter Class包括：a.stack(对应的adaptee是deque)。b.queue(对应的adaptee是deque)。
c.priority_queue(对应的adaptee是vector)。下面是从VC中的< stack >拷出的stack的类定义：
template
class _Container = deque<_Ty> >
class stack
{ // LIFO queue implemented with a container
public:
typedef _Container container_type;
typedef typename _Container::value_type value_type;
typedef typename _Container::size_type size_type;
stack()
: c()
{ // construct with empty container
}
explicit stack(const _Container& _Cont)
: c(_Cont)
{ // construct by copying specified container
}
bool empty() const
{ // test if stack is empty
return (c.empty());
}
size_type size() const
{ // test length of stack
return (c.size());
}
value_type& top()
{ // return last element of mutable stack
return (c.back());
}
const value_type& top() const
{ // return last element of nonmutable stack
return (c.back());
}
void push(const value_type& _Val)
{ // insert element at end
c.push_back(_Val);
}
void pop()
{ // erase last element
c.pop_back();
}
bool _Eq(const stack<_Ty, _Container>& _Right) const
{ // test for stack equality
return (c == _Right.c);
}
bool _Lt(const stack<_Ty, _Container>& _Right) const
{ // test if this < _Right for stacks
return (c < _Right.c);
}
protected:
_Container c; // the underlying container
};
关键之处在于_Container c，stack所有的操作都转交给c去处理了。(这实际上就是前面所说的"object adapter"，注意STL中的class adapter与上面所说的class adapter概念不完全一致)
stack的使用方法很简单，如下：
{
int ia[] = { 1,3,2,4 };
deque id(ia, ia+4);
stack is(id);
}
(2)近日看了一篇文章“Generic< Programming >：简化异常安全代码”，原文出自
https://www.wendangku.net/doc/af2694380.html,/experts/1812/alexandr.htm?topic=experts，中文译文出自"C++ View第5期"。文章绝对一流，作者给出的代码中也使用了Adaptor模式，也有一定代表性。我将其问题一般化，概括出以下示例：
问题：假设有几个已有类，他们有某些共同的行为，但它们彼此间是独立的(没有共同的基类)。如：
class T1
{
public:
void Proc() {}
} ;
class T2
{
public:
void Proc() {}
} ;
// ...
如何以统一的方式去调用这些行为呢？
解决方法1：很自然的会想到用模板，如：
template
void Test(T t)
{
t.Proc() ;
}
的确不错，但这只适用于简单的情况，有时情况是很复杂的，比如我们无法把类型放到模板参数中！
解决方法2：困难来自于这些类没有共同的基类，所以我们就创造一个基类，然后再Adapt。
// class IAdaptor，抽象基类
class IAdaptor
{
public:
virtual void Proc() = 0 ;
} ;
// class Adaptor
template
class Adaptor : public IAdaptor, private T //实现继承
{
public:
virtual void Proc() { T::Proc() ; }
} ;
// 以统一方式调用函数Proc，而不关心是T1、T2或其他什么类
void Test(const std::auto_ptr& sp)
{
sp->Proc() ;
}
客户端代码：
Test(std::auto_ptr(new Adaptor)) ;
Test(std::auto_ptr(new Adaptor)) ;
上例很简单，用方法一中的模板函数就可以很好地解决了。下面是一个略微复杂一点的例子，根据参数类型来创建适当的对象：
class T1
{
public:
T1(int) { /*...*/ }
void Proc() { /*...*/ }
} ;
class T2
{
public:
T2(char) { /*...*/ }
void Proc() { /*...*/ }
} ;
// class IAdaptor，抽象基类
class IAdaptor
{
public:
virtual void Proc() = 0 ;
} ;
// class Adaptor
template
class Adaptor : public IAdaptor, private T //实现继承{
public:
Adaptor(int n) : T(n) {}
Adaptor(char c) : T(c) {}
virtual void Proc() { T::Proc() ; }
} ;
class Test
{
public:
Test(int n) : sp(new Adaptor(n)) {}
Test(char c) : sp(new Adaptor(c)) {}
void Proc() { sp->Proc() ; }
private:
std::auto_ptr sp ;
} ;
客户端代码：
Test t1(10) ;
t1.Proc() ;
Test t2('c') ;
t2.Proc() ;
上面是示例而非实例，你也许更愿意看看它实际的运用。去下载作者所写的代码，好好欣赏一下吧。
C++设计模式之Abstract Factory
2002-07-23· · ··COM集中营
一、功能
提供一个创建一系列相关或相互依赖对象的接口，而无需指定它们具体的类。
二、结构图
类厂最基本的结构示意图如下：
在实际应用中，类厂模式可以扩充到很复杂的情况，如下图所示：
三、优缺点
优点：(1)封装创建过程。客户不用知道类厂是如何创建类实例的，类厂封闭了所有创建的细节。这样可选择不同的创建方法，增加了灵活性。(2)将客户与具体类隔离，提高了各自的可重用性。
缺点：Factory类层次与具体类层次通常是平行的(即一一对应的)。增加一个具体类，一般也要相应地增加一个factory 类，增加了系统复杂度。
四、实现
(1)Abstract Factory类中通常是一组Factory Method的集合。个人认为与Factory Method模式没有本质区别。
(2)通常可以把工厂作为单件。
五、示例代码
namespace DesignPattern_AbstractFactory
{
class AbstractProductA {}; // Product A
class ProductA1 : public AbstractProductA {};
class ProductA2 : public AbstractProductA {};
class AbstractProductB {}; // Product B
class ProductB1 : public AbstractProductB {};
class ProductB2 : public AbstractProductB {};
class AbstractFactory
{
public:
virtual AbstractProductA* CreateProductA() = 0 ;// 创建ProductA
virtual AbstractProductB* CreateProductB() = 0 ;// 创建ProductB
} ;
class ConcreteFactory1 : public AbstractFactory
{
public:
virtual AbstractProductA* CreateProductA() { return new ProductA1() ; }
virtual AbstractProductB* CreateProductB() { return new ProductB1() ; }
static ConcreteFactory1* Instance() { static ConcreteFactory1 instance ; return &instance ; } protected:
ConcreteFactory1() {}
private:
ConcreteFactory1(const ConcreteFactory1&) ;
ConcreteFactory1& operator=(const ConcreteFactory1&) ;
} ;
class ConcreteFactory2 : public AbstractFactory
{
public:
virtual AbstractProductA* CreateProductA() { return new ProductA2() ; }
virtual AbstractProductB* CreateProductB() { return new ProductB2() ; }
static ConcreteFactory2* Instance() { static ConcreteFactory2 instance ; return &instance ; } protected:
ConcreteFactory2() {}
private:
ConcreteFactory2(const ConcreteFactory2&) ;
ConcreteFactory2& operator=(const ConcreteFactory2&) ;
} ;
}
客户端代码：
{
using namespace DesignPattern_AbstractFactory ;
// 第一种创建方法
AbstractFactory *pFactory = ConcreteFactory1::Instance() ;
AbstractProductA *pProductA = pFactory->CreateProductA() ;
AbstractProductB *pProductB = pFactory->CreateProductB() ;
// 第二种创建方法
pFactory = ConcreteFactory2::Instance() ;
pProductA = pFactory->CreateProductA() ;
pProductB = pFactory->CreateProductB() ;
}
六、实例
最早知道类厂的概念是在COM中，但当时也没想到这是如此重要的一种模式，在许多其他模式中都可以用到类厂模式。COM中不能直接创建组件，这也是由COM的一个特性决定的：即客户不知道要创建的组件的类名。
C++设计模式之Singleton
2002-07-26· · ··COM集中营
一、功能
保证一个类仅有一个实例。
二、结构图
三、优缺点
Singleton模式是做为"全局变量"的替代品出现的。所以它具有全局变量的特点：全局可见、贯穿应用程序的整个生命期，
它也具有全局变量不具备的性质：同类型的对象实例只可能有一个。
四、实现
教科书上的Singleton定义如下：
class Singleton
{
public:
static Singleton* Instance() ;
protected:
Singleton() {}
private:
static Singleton *_instance ;
Singleton(const Singleton&) ;
Singleton& operator=(const Singleton&) ;
} ;
Singleton* Singleton::_instance = NULL ;
Singleton* Singleton::Instance()
{
(_instance == NULL) ? _instance = new Singleton() : 0 ; //lazy initialization
return _instance ;
}
(1)因为返回的是指针，为防止用户调用delete函数，可把static Singleton *_instance；改为在Instance()中定义static Singleton _instance。这样显然更安全，同时也具有lazy initialization的特性(即第一次访问时才创建)。
(2)假设需要从Singleton派生子类，而子类也需要有同样的性质，既只能创建一个实例。我觉得，这很难办。根本原因在于Instance()函数不是虚函数，不具有多态的性质。一种常用方法是把Instance()函数移到子类中，这时就只能用static Singleton *_instance，而不能用static Singleton _instance了，除非把_instance也要移到子类，无论怎么做都不优雅。另一种方法是用模板。具体用什么方法，只能根据实际情况权衡。
五、示例代码
(1)没子类的情况
namespace DesignPattern_Singleton
{
class Singleton
{
public:
static Singleton* Instance() { static Singleton _instance ; return &_instance ; } protected:
Singleton() {}
private:
Singleton(const Singleton&) ;
Singleton& operator=(const Singleton&) ;
} ;
}
客户端代码：
{
using namespace DesignPattern_Singleton ;
Singleton *p = Singleton::Instance() ;
......
}
(2)有子类的情况
方法一：
namespace DesignPattern_Singleton
{
// class Singleton
class Singleton
{
protected:
Singleton() {}
static Singleton *_instance ;
private:
Singleton(const Singleton&) ;
Singleton& operator=(const Singleton&) ;
} ;
Singleton* Singleton::_instance = NULL ;
// class ConcreteSingleton
class ConcreteSingleton : public Singleton
{
public:
static Singleton* Instance() ;
protected:
ConcreteSingleton() {}
} ;
Singleton* ConcreteSingleton::Instance()
{
(_instance == NULL) ? _instance = new ConcreteSingleton() : 0 ; return _instance ;
}
}
客户端代码：
{
using namespace DesignPattern_Singleton ;
Singleton *p = ConcreteSingleton::Instance() ;
}
方法二：
namespace DesignPattern_Singleton
{
// class Singleton
class Singleton
{
protected:
Singleton() {}
private:
Singleton(const Singleton&) ;
Singleton& operator=(const Singleton&) ;
} ;
// class ConcreteSingleton
class ConcreteSingleton : public Singleton
public:
static Singleton* Instance() { static ConcreteSingleton _instance ; return &_instance ; } protected:
ConcreteSingleton() {}
} ;
}
客户端代码：
{
using namespace DesignPattern_Singleton ;
Singleton *p = ConcreteSingleton::Instance() ;
}
方法三：
namespace DesignPattern_Singleton
{
template < class T >
class Singleton
{
public:
static T* Instance() { static T _instance ; return &_instance ; }
protected:
Singleton() {}
private:
Singleton(const Singleton &) ;
Singleton& operator=(const Singleton&) ;
} ;
class ConcreteSingleton : public Singleton< ConcreteSingleton > {} ;
}
客户端代码
{
using namespace DesignPattern_Singleton ;
ConcreteSingleton *p = ConcreteSingleton::Instance() ;
}
C++模式开发之Bridge
2002-07-29· · ··COM集中营
一、功能
将抽象部分与它的实现部分分离，使它们都可以独立地变化。
二、结构图
三、示例代码
namespace DesignPattern_Bridge
{
// class Implementor
class Implementor
{
public:
virtual void OperationImp() = 0 ;
} ;
// class ConcreteImplementorA
class ConcreteImplementorA : public Implementor
{
public:
virtual void OperationImp() {}
} ;
// class ConcreteImplementorB
class ConcreteImplementorB : public Implementor
{
public:
virtual void OperationImp() {}
} ;
// class Abstraction
class Abstraction
{
public:
void Operation(Implementor* imp) { assert(imp) ; imp->OperationImp() ; }
} ;
}
客户端代码：
{
using namespace DesignPattern_Bridge ;
Abstraction obj ;
Implementor *impa = new ConcreteImplementorA() ;
Implementor *impb = new ConcreteImplementorB() ;
obj.Operation(impa) ; //第一种实现方法
obj.Operation(impb) ; //第二种实现方法
}
四、实例
(1)创建可以在X Window System和IBM的Presentation Manager系统中都可以使用的窗口。(书上的例子)
软件设计模式试题集 含答案
设计模式试题 一.选择 1. 设计模式具有的优点（）。 A．适应需求变化 B.程序易于理解 C．减少开发过程中的代码开发工作量 D.简化软件系统的设计 2. 设计模式一般用来解决什么样的问题( )。 A.同一问题的不同表相 B 不同问题的同一表相 C.不同问题的不同表相 D.以上都不是 3. 设计模式的两大主题是( )。 A.系统的维护与开发 B.对象组合与类的继承 C.系统架构与系统开发 D.系统复用与系统扩展 4. 以下哪些问题通过应用设计模式不能够解决。（） A）指定对象的接口B）针对接口编程 C）确定软件的功能都正确实现D）设计应支持变化 二.填空 1. 模式的基本要素包括名称、意图、问题、解决方案、参与者和协作者、（效果）、实现、GoF 参考。 2. 设计模式基本原则包括：开闭原则，（从场景进行设计的原则），包容变化原则。 3. 设计模式是一个(抽象)的方案，它可以解决一类问题。 4. 1. 在设计模式群体中，效果是指（原因和结果）。三. 判断 1. 适配器模式属于创建型模式。错 2. 在设计模式中，“效果”只是指“原因和结果”。对 3. 设计模式使代码编制不能真正工程化。错 4. 设计模式的两大主题是系统复用与系统扩展。对四. 名词解释 1. 设计模式 是一套被反复使用、多数人知晓的、经过分类编目的、代码设计经验的总结。使用设计模式是为了可重用代码、让代码更容易被他人理解、保证代码可靠性。 2. 模板 模式定义一个操作中的算法的骨架，而将一些步骤延迟到子类中。 3. 模式 就是解决某一类问题的方法论。把解决某类问题的方法总结归纳到理论高度，那就是模式。 4. 内聚度 模块内部各成分彼此结合的紧密程度。五.简答 题 1. 什么是设计模式？设计模式的目标是什么？设计模式是一套被反复使用、多数人知晓的、经过分类编目的、代码 设计经验的总结。使用设计模式是为了可 重用代码、让代码更容易被他人理解、保证代码可靠性。 2. 设计模式的基本要素有哪些？ 名称，意图，问题，解决方案，参与者和协作者，效果，实现，GOF 参考。 3. 设计模式中一般都遵循的原则有什么？ 开-闭原则，根据场景进行设计原则，优先组合原则，包容变化原则。 4. 四人团针对“创建优秀面向对象设计”建议了哪些策略？ 针对接口编程，优先使用对象组合而不是类继承，找到并封装变化点。 第6 章 facade(外观)模式 一.选择 1. 外观模式的作用是（）。A．当不能采用生成子类的方法进行扩充时，动态地给一个对象添加一些 额外的功能。B．为了系统中的一组功能调用提供一个一致的接口，这个接口使得这一子系统更 加容易使用。
设计模式题库(修改后)
1.设计模式的原理? (C) C. 面向接口编程 2. 以下对"开-闭"原则的一些描述错误的是?(A) A. "开-闭"原则与"对可变性的封装原则"没有相似性. 3.以下属于创建型模式是? (A) B.BUILDER（生成器） C. PROTOTYPE（原型） D.SINGLETON（单件） 4.以下属于结构型模式是? (D) COMPOSITE（组合） B. ADAPTER（适配器） B.FLYWEIGHT（享元） 5.以下属于行为型模式是? (D ) 6. COMMAND（命令） 7. STRATEGY(策略) 8. MEMENTO（备忘录） /*23模式意图*/ 6.以下意图那个是用来描述ABSTRACT FACTORY（抽象工厂)?(A) A.提供一个创建一系列相关或相互依赖对象的接口，而无需指定它们具体的类。 7.以下意图那个是用来描述BUILDER（生成器）?(B) 将一个复杂对象的构建与它的表示分离，使得同样的构建过程可以创建不同的表示。 8.以下意图那个是用来描述FACTORY METHOD（工厂方法）?(C) C.定义一个用于创建对象的接口，让子类决定实例化哪一个类。该模式使一个类的实例化延迟到其子类。 9.以下意图那个是用来描述PROTOTYPE（原型）?(D) D.用原型实例指定创建对象的种类，并且通过拷贝这些原型创建新的对象。 10.以下意图那个是用来描述SINGLETON（单件）?(B) B.保证一个类仅有一个实例，并提供一个访问它的全局访问点。
11.以下意图那个是用来描述ADAPTER（适配器）?(A) A.将一个类的接口转换成客户希望的另外一个接口。本模式使得原本由于接口不兼容 而不能一起工作的那些类可以一起工作。 12.以下意图那个是用来描述BRIDGE（桥接）?(B) B.将抽象部分与它的实现部分分离，使它们都可以独立地变化。 13.以下意图那个是用来描述COMPOSITE（组合）?(C) C.将对象组合成树形结构以表示“部分-整体”的层次结构。 14.以下意图那个是用来描述DECORATOR（装饰）?(D) 动态地给一个对象添加一些额外的职责。 15.以下意图那个是用来描述FACADE（外观）?(A) A.为子系统中的一组接口提供一个一致的界面，本模式定义了一个高层接口，这个接 口使得这一子系统更加容易使用。 16.以下意图那个是用来描述FLYWEIGHT（享元）?(B) B.运用共享技术有效地支持大量细粒度的对象。 17.以下意图那个是用来描述PROXY（代理）?(C) C.为其他对象提供一种代理以控制对这个对象的访问。 18.以下意图那个是用来描述CHAIN OF RESPONSIBILITY(职责链)?(D) D.使多个对象都有机会处理请求，从而避免请求的发送者和接收者之间的耦合关系。 19.以下意图那个是用来描述COMMAND（命令）?(A) A.将一个请求封装为一个对象，从而使你可用不同的请求对客户进行参数化；对请求排队或记录请求日志，以及支持可撤消的操作 20.以下意图那个是用来描述INTERPRETER(解释器)?(B) B.给定一个语言，定义它的文法的一种表示，并定义一个解释器，这个解释器使用该表示来解释语言中的句子。 21.以下意图那个是用来描述ITERATOR(迭代器)?(C) 。 C.提供一种方法顺序访问一个聚合对象中各个元素, 而又不需暴露该对象的内部表示。
软件设计模式试题集58887
第5章设计模式 一.选择 1. 设计模式具有的优点（）。 A．适应需求变化 B.程序易于理解 C．减少开发过程中的代码开发工作量 D.简化软件系统的设计 2. 设计模式一般用来解决什么样的问题( )。 A.同一问题的不同表相B不同问题的同一表相 C.不同问题的不同表相 D.以上都不是 3. 设计模式的两大主题是( )。 A.系统的维护与开发 B 对象组合与类的继承 C.系统架构与系统开发 D.系统复用与系统扩展 4. 以下哪些问题通过应用设计模式不能够解决。（） A）指定对象的接口B）针对接口编程 C）确定软件的功能都正确实现D）设计应支持变化 解答: 1. A 2. A 3. D 4. C 二.填空 1. 模式的基本要素包括名称、意图、问题、解决方案、参与者和协作者、（）、实现、G oF参考。 2. 设计模式基本原则包括：开闭原则，（），包容变化原则。 3. 设计模式是一个( )的方案，它可以解决一类问题。 4. 1. 在设计模式群体中，效果是指（）。 解答: 1. 效果 2. 从场景进行设计的原则
3. 抽象 4. 原因和结果 三.判断 1. 适配器模式属于创建型模式。 2. 在设计模式中，“效果”只是指“原因和结果”。 3. 设计模式使代码编制不能真正工程化。 4. 设计模式的两大主题是系统复用与系统扩展。 解答: 1. 错 2. 对 3. 错 4. 对 四.名词解释 1. 设计模式 2. 模板 3. 模式 4. 内聚度 解答: 1. 是一套被反复使用、多数人知晓的、经过分类编目的、代码设计经验的总结。使用设计模式是为了可重用代码、让代码更容易被他人理解、保证代码可靠性 2. 模式定义一个操作中的算法的骨架，而将一些步骤延迟到子类中。 3. 就是解决某一类问题的方法论。把解决某类问题的方法总结归纳到理论高度，那就是模式。 4. 五.简答题 1. 什么是设计模式？设计模式的目标是什么？
几种常用的设计模式介绍
几种常用的设计模式介绍 1. 设计模式的起源 最早提出“设计模式”概念的是建筑设计大师亚力山大Alexander。在1970年他的《建筑的永恒之道》里描述了投计模式的发现，因为它已经存在了千百年之久，而现代才被通过大量的研究而被发现。 在《建筑的永恒之道》里这样描述：模式是一条由三个部分组成的通用规则：它表示了一个特定环境、一类问题和一个解决方案之间的关系。每一个模式描述了一个不断重复发生的问题，以及该问题解决方案的核心设计。 在他的另一本书《建筑模式语言》中提到了现在已经定义了253种模式。比如： 说明城市主要的结构：亚文化区的镶嵌、分散的工作点、城市的魅力、地方交通区 住宅团组：户型混合、公共性的程度、住宅团组、联排式住宅、丘状住宅、老人天地室内环境和室外环境、阴和阳总是一气呵成 针对住宅：夫妻的领域、儿童的领域、朝东的卧室、农家的厨房、私家的沿街露台、个人居室、起居空间的序列、多床卧室、浴室、大储藏室 针对办公室、车间和公共建筑物：灵活办公空间、共同进餐、共同小组、宾至如归、等候场所、小会议室、半私密办公室 尽管亚力山大的著作是针对建筑领域的，但他的观点实际上适用于所有的工程设计领域，其中也包括软件设计领域。“软件设计模式”，这个术语是在1990年代由Erich Gamma等人从建筑设计领域引入到计算机科学中来的。目前主要有23种。 2. 软件设计模式的分类 2.1. 创建型 创建对象时，不再由我们直接实例化对象；而是根据特定场景，由程序来确定创建对象的方式，从而保证更大的性能、更好的架构优势。创建型模式主要有简单工厂模式（并不是23种设计模式之一）、工厂方法、抽象工厂模式、单例模式、生成器模式和原型模式。 2.2. 结构型 用于帮助将多个对象组织成更大的结构。结构型模式主要有适配器模式、桥接模式、组合器模式、装饰器模式、门面模式、亨元模式和代理模式。 2.3. 行为型 用于帮助系统间各对象的通信，以及如何控制复杂系统中流程。行为型模式主要有命令模式、解释器模式、迭代器模式、中介者模式、备忘录模式、观察者模式、状态模式、策略模式、模板模式和访问者模式。
设计模式考试复习题(含答案)
一、1. 设计模式一般用来解决什么样的问题： A.同一问题的不同表相 2. 下列属于面向对象基本原则的是：C.里氏代换 3. Open-Close原则的含义是一个软件实体：A.应当对扩展开放，对修改关闭. 4. 当我们想创建一个具体的对象而又不希望指定具体的类时，使用（A）模式。A.创建型 5. 要依赖于抽象不要依赖于具体。即针对接口编程不要针对实现编程：（D）依赖倒转原则 6. 依据设计模式思想,程序开发中应优先使用的是( A )关系实现复用。A, 委派 7. 设计模式的两大主题是( D ) D.系统复用与系统扩展 8. 单体模式中,两个基本要点(AB)和单体类自己提供单例A .构造函数私有 B.唯一实例 9. 下列模式中,属于行为模式的是( B ) B观察者 10. “不要和陌生人说话”是( D )原则的通俗表述 D.迪米特 1. 软件体系结构是指一个系统的有目的的设计和规划，这个设计规划既不描述活动，也不描述系统怎样开发，它只描述系统的组成元素及其相互的交互协作。 2．一个UML模型只描述了一个系统要做什么，它并没告诉我们系统是怎么做。 3．接口是可以在整个模型中反复使用的一组行为，是一个没有属性而只有方法的类。 4．多重性指的是，某个类有多个对象可以和另一个类的一对象关联。 5．当一个类的对象可以充当多种角色时，自身关联就可能发生。 6．在泛化关系中，子类可以替代父类。后前者出现的可以相同地方。反过来却不成立。 7．最通常的依赖关系是一个类操作的形构中用到了另一个类的定义。 8．组成是强类型的聚集，因为聚集中的每个部分体只能属于一个整体。 9．实现的符号和继承的符号有相似之处，两者的唯一差别是实现关系用虚线表示，继承关系用实线表示。 10. 设计模式中应优先使用对象组合而不是类继承。 1.适配器模式属于创建型模式结构型（F ） 2.在设计模式中，“效果”只是指“原因和结果”（T ） 3.设计模式使代码编制不能真正工程化（T ） 4.面向对象语言编程中的异常处理，可以理解为责任链模式（T ） 5.反模式就是反对在软件开发过程中使用设计模式分析：反模式用来解决问题的带有共性的不良方法（F ） 1.什么是设计模式设计模式目标是什么 答：设计模式是一套被反复使用、多数人知晓的、经过分类编目的、代码设计经验的总结。使用设计模式是为了可重用代码、让代码更容易被他人理解，保证代码可靠性。 2.设计模式中一般都遵循的原则有什么 答：开闭原则、根据场景进行设计原则、优先组合原则、包容变化原则 3.“Gang of Four”针对“创建优秀面向对象设计”建议了哪些策略 答：针对接口编程、优先使用对象组合而不是类继承，找到并封装变化点。 4.面向对象系统中功能复用的两种最常用技术是什么 答：类继承和对象组合，类继承允许你根据其他类的实现来定义一个类的实现。父类的内部细节对子类可见。 类继承是在编译时刻静态定义的，且可直接使用，类继承可以较方便地改变被复用的实现。对象组合是类继承之外的另一种复用选择。新的更复杂的功能可以通过组装或组合对象来获得。对象组合要求被组合的对象具有良好定义的接口。 5.只根据抽象类中定义的接口来操纵对象有什么好处 答：1)客户无须知道他们使用对象的特定类型，只须对象有客户所期望的接口。 2)客户无须知道他们使用的对象是用什么类来实现的，他们只须知道定义接口的抽象类。 五、应用题（分值15） 公司架构：经理、工程师、技师和后勤人员都是公司的雇员，经理管理工程师、技师和后勤人员。高层经理领导较低级别的经理。典型层次图如下：可以使用哪种设计模式实现公司的层级关系并说明为什么 组合模式，第一，其公司关系架构为树形结构；第二，其表示了部分-整体关系（自己扩展）
c设计模式面试
c,,,设计模式,面试 篇一：八设计模式java面试题 八、设计模式基础知识 1、设计模式及框架定义和作用？ 设计模式：设计模式是一种问题的解决思路，是一套被反复使用、多数人知晓的、经过分类编目的、代码设计经验的总结，它已经适用于一个实践环境，并且可以适用于其它环境。 使用设计模式是为了可重用代码、让代码更容易被他人理解、保证代码可靠性，为设计提供共同的词汇，可以节省大量时间，使代码编制真正工程化 框架：框架是构成一类特定软件可复用设计的一组相互协作的类，框架通常定义了应用体系的整体结构类和对象的关系等等设计参数。 框架便于具体应用实现者能集中精力于应用本身的特定细节。框架主要记录软件应用中共同的设计决策，框架强调设计复用，因此框架设计中必然要使用设计模式，设计模式有助于对框架结构的理解，成熟的框架通常使用了多种设计模式
2、开发中都用到了哪些设计模式？(J2EE常用的设计模式？)用在什么场合？ 答：singleton:单例,用来减少垃圾对象和缓存用 factory:工厂模式,用来解耦(其实模式都用来解耦的)facade和decorator:封装接口 command:命令模式，传递 Iterator:用来遍历对象Observer:用来监听状态变化(现在习惯用listener机制替代) templete:模板模式，用来处理相同的操作步骤strategy:策略模式，策略选择 proxy:用来附加功能，属性或隐蔽。 bridge也很实用，用来解耦工厂与产品搭配之类的选择服务定位者模式，前端控制器模式，DAO模式，代理模式，装饰者模式等注：MVC模式准确来说并不是设计模式，而是架构。详解如下： MVC模式是一个复杂的架构模式，其实现也显得非常复杂。但是，我们已经总结出了很多可靠的设计模式，多种设计模式结合在一起，使MVC模式的实现变得相对简单易行。Views可以看作一棵树，显然可以用Composite Pattern(合成模式)来实现。Views和Models之间的关系可以用Observer Pattern(观察者模式)体现。Controller控制
C语言设计模式
目录 1.C语言设计模式（开篇） (2) 2.C语言和设计模式（继承、封装、多态） (3) 2.1继承性 (3) 2.2封装性 (4) 2.3多态 (4) 3.单件模式 (4) 4.工厂模式 (5) 5.抽象工厂模式 (6) 6.访问者模式 (8) 7.状态模式 (9) 8.命令模式 (9) 9.解释器模式 (10) 10.备忘录模式 (11) 11.观察者模式 (12) 12.桥接模式 (12) 13.建造者模式 (13) 14.中介者模式 (14) 15.策略模式 (15) 16.适配器模式 (16) 17.装饰模式 (17) 18.亨元模式 (17) 19.代理模式 (18) 20.外观模式 (19) 21.迭代器模式 (20) 22.责任链模式 (21) 23．模版模式 (22) 24.组合模式 (24) 25.原型模式 (25)
1.C语言设计模式（开篇） 关于软件设计方面的书很多，比如《重构》，比如《设计模式》。至于软件开发方式，那就更多了，什么极限编程、精益方法、敏捷方法。随着时间的推移，很多的方法又会被重新提出来。 其实，就我个人看来，不管什么方法都离不开人。一个人写不出二叉树，你怎么让他写？敏捷吗？你写一行，我写一行。还是迭代？写三行，删掉两行，再写三行。项目的成功是偶然的，但是项目的失败却有很多原因，管理混乱、需求混乱、设计低劣、代码质量差、测试不到位等等。就软件企业而言，没有比优秀的文化和出色的企业人才更重要的了。 从软件设计层面来说，一般来说主要包括三个方面： （1）软件的设计受众，是小孩子、老人、女性，还是专业人士等等； （2）软件的基本设计原则，以人为本、模块分离、层次清晰、简约至上、适用为先、抽象基本业务等等； （3）软件编写模式，比如装饰模式、责任链、单件模式等等。 从某种意义上说，设计思想构成了软件的主题。软件原则是我们在开发中的必须遵循的准绳。软件编写模式是开发过程中的重要经验总结。灵活运用设计模式，一方面利于我们编写高质量的代码，另一方面也方便我们对代码进行维护。毕竟对于广大的软件开发者来说，软件的维护时间要比软件编写的时间要多得多。编写过程中，难免要有新的需求，要和别的模块打交道，要对已有的代码进行复用，那么这时候设计模式就派上了用场。我们讨论的主题其实就是设计模式。 讲到设计模式，人们首先想到的语言就是c#或者是java，最不济也是c++，一般来说没有人会考虑到c语言。其实，我认为设计模式就是一种基本思想，过度美化或者神化其实没有必要。其实阅读过linux kernel的朋友都知道，linux虽然自身支持很多的文件系统，但是linux自身很好地把这些系统的基本操作都抽象出来了，成为了基本的虚拟文件系统。 举个例子来说，现在让你写一个音乐播放器，但是要支持的文件格式很多，什么ogg，wav，mp3啊，统统要支持。这时候，你会怎么编写呢？如果用C++语言，你可能会这么写。 class music_file { HANDLE hFile; public: void music_file() {} virtual ~music_file() {} virtual void read_file() {} virtual void play() {}
c#所有设计模式及源代码
C#设计模式总结 各位亲们，在网上很难找到所有设计模式的说明及源代码，尤其C#更是比较少，本人最近花了点时间罗列了二十多种设计模式，希望能对写程序朋友尤其需要软考的朋友有所帮助，如果有需要源代码和类图的朋友，请到温尔保免费索取，以便我们进行探讨和您对此文档的指正，当然别忘了关顾我的小店哦,谢谢!由于能力有限，对有些模式理解不正确，敬请谅解和指正，愿我们一同进步，一同学习，本人的QQ是1070837561。 一、简单工厂模式 1.概念 从设计模式的类型上来说，简单工厂模式是属于创建型模式，又叫做静态工厂方法（Static Factory Method）模式，但不属于23种GOF设计模式之一。简单工厂模式是由一个工厂对 象决定创建出哪一种产品类的实例。简单工厂模式是工厂模式家族中最简单实用的模式， 可以理解为是不同工厂模式的一个特殊实现。 2.类图 3.使用场景 a)工厂类负责创建的对象比较少； b)客户只知道传入工厂类的参数，对于如何创建对象（逻辑）不关心； c)由于简单工厂很容易违反高内聚责任分配原则，因此一般只在很简单的情况下应用。 4.代码 上温尔保免费索取所有模式的源代码。 二、工厂方法模式 1、概念 工厂方法(Factory Method)模式的意义是定义一个创建产品对象的工厂接口，将实际创建工作推迟到子类当中。核心工厂类不再负责产品的创建，这样核心类成为一个抽象工厂角色，仅负责具体工厂子类必须实现的接口，这样进一步抽象化的好处是使得工厂方法模式可以使系统在不修改具体工厂角色的情况下引进新的产品。 2、类图
3、 使用场景 a) 调用者清楚地知道应该使用哪个具体工厂服务，实例化该具体工厂，生产出具体的产品来; b) 只是需要一种产品，而不想知道也不需要知道究竟是哪个工厂为生产的，即最终选用哪个具体工厂的决定权在生产者一方，它们根据当前系统的情况来实例化一个具体的工厂返回给使用者，而这个决策过程这对于使用者来说是透明的。 4、 代码 上温尔保免费索取所有模式的源代码。 三、 单例模式 1、 概念 单例模式是一种常用的软件设计模式。在它的核心结构中只包含一个被称为单例类的特殊类。通过单例模式可以保证系统中一个类只有一个实例而且该实例易于外界访问，从而方便对实例个数的控制并节约系统资源。如果希望在系统中某个类的对象只能存在一个，单例模式是最好的解决方案。 2、 类图 3、 使用场景 a) 资源共享的情况下，避免由于资源操作时导致的性能或损耗等; b) 控制资源的情况下，方便资源之间的互相通信。 4、 代码 上温尔保免费索取所有模式的源代码。 四、 构建模式 1、 概念 构建模式将一个复杂对象的构建与它的表示分离，使得同样的构建过程可以创建不同的表示，构建模式是一步步创建一个复杂的对象，它允许用户只通过指定复杂对象的类型和内容就可以构建
C语言实现《大话设计模式》中的代理模式例程
C语言实现《大话设计模式》中的代理模式例程 分类：设计模式2012-06-12 11:07 545人阅读评论(0) 收藏举报设计模式语言cstructfunction [cpp]view plainc opyprint? 1.#ifndef __PROXY_H__ 2.#define __PROXY_H__ 3.#include "rtthread.h" 4.#include "finsh.h" 5.//被追求者类 6.typedef struct _SchoolGirl SchoolGirl; 7.struct _SchoolGirl 8.{ 9.char *Name; 10.void (*SchoolGirlDelete)(SchoolGirl *pSchoolGirl); 11.}; 12.static void SchoolGirlDelete(SchoolGirl *pSchoolGirl) 13.{ 14. rt_free(pSchoolGirl); 15.} 16.SchoolGirl *SchoolGirlCreate(char *Name) 17.{ 18. SchoolGirl *pSchoolGirl = (SchoolGirl *)rt_malloc(sizeof(SchoolGirl)); 19. pSchoolGirl->Name = Name; 20. pSchoolGirl->SchoolGirlDelete = SchoolGirlDelete; 21.return pSchoolGirl; 22.} 23.//追求者类 24.typedef struct _Pursuit Pursuit; 25.struct _Pursuit 26.{ 27. SchoolGirl *mm; 28.void (*PursuitDelete)(void *pPursuit); 29.void (*GiveDolls)(Pursuit *pPursuit); 30.void (*GiveFlowers)(Pursuit *pPursuit); 31.void (*GiveChocolate)(Pursuit *pPursuit); 32.}; 33.static void PursuitDelete(void *pPursuit) 34.{ 35. rt_free(pPursuit); 36.} 37.static void PursuitGiveDolls(Pursuit *pPursuit) 38.{
C设计模式
C#设计模式（1） ......................................................................................... 错误!未定义书签。 一、 C# 面向对象程序设计复习......................................................... 错误!未定义书签。 二、设计模式举例 ................................................................................. 错误!未定义书签。 三、先有鸡还是先有蛋？ ..................................................................... 错误!未定义书签。 四、大瓶子套小瓶子还是小瓶子套大瓶子？ ..................................... 错误!未定义书签。 五、 .net本质 ....................................................................................... 错误!未定义书签。C#设计模式（2） ......................................................................................... 错误!未定义书签。 一、"开放－封闭"原则(OCP) .......................................................... 错误!未定义书签。 二、里氏代换原则（LSP） ................................................................ 错误!未定义书签。C#设计模式（3） ......................................................................................... 错误!未定义书签。 三、依赖倒置原则(DIP) .................................................................... 错误!未定义书签。 四、接口隔离原则（ISP） ................................................................. 错误!未定义书签。 五、合成/聚合复用原则（CARP） .................................................. 错误!未定义书签。 六、迪米特法则（LoD）..................................................................... 错误!未定义书签。C#设计模式（4）－Simple Factory Pattern .................................. 错误!未定义书签。 一、简单工厂（Simple Factory）模式........................................ 错误!未定义书签。 二、 Simple Factory模式角色与结构：....................................... 错误!未定义书签。 三、程序举例：..................................................................................... 错误!未定义书签。 四、 Simple Factory模式演化....................................................... 错误!未定义书签。 五、优点与缺点： ................................................................................. 错误!未定义书签。C#设计模式（5）－Factory Method Pattern................................. 错误!未定义书签。 一、工厂方法（Factory Method）模式....................................... 错误!未定义书签。 二、 Factory Method模式角色与结构：...................................... 错误!未定义书签。 三、程序举例： ..................................................................................... 错误!未定义书签。 四、工厂方法模式与简单工厂模式 ..................................................... 错误!未定义书签。 五、 Factory Method模式演化...................................................... 错误!未定义书签。 六、 Factory Method模式与其它模式的关系.............................. 错误!未定义书签。 七、另外一个例子 ................................................................................. 错误!未定义书签。C#设计模式（6）－Abstract Factory Pattern .............................. 错误!未定义书签。 一、抽象工厂（Abstract Factory）模式 .................................... 错误!未定义书签。 二、 Abstract Factory模式的结构： ........................................... 错误!未定义书签。 三、程序举例： ..................................................................................... 错误!未定义书签。 四、在什么情形下使用抽象工厂模式： ............................................. 错误!未定义书签。 五、抽象工厂的起源 ............................................................................. 错误!未定义书签。 六、 Abstract Factory模式在实际系统中的实现 ....................... 错误!未定义书签。 七、 "开放－封闭"原则......................................................................... 错误!未定义书签。C#设计模式（7）－Singleton Pattern .............................................. 错误!未定义书签。 一、单例（Singleton）模式............................................................ 错误!未定义书签。 二、 Singleton模式的结构：........................................................... 错误!未定义书签。 三、程序举例： ..................................................................................... 错误!未定义书签。 四、在什么情形下使用单例模式： ..................................................... 错误!未定义书签。 五、 Singleton模式在实际系统中的实现....................................... 错误!未定义书签。 六、 C#中的Singleton模式............................................................ 错误!未定义书签。C#设计模式（8）－Builder Pattern ................................................... 错误!未定义书签。
设计模式复习题
三、题目预测 填空题： 1.请从外观、组合、工厂方法、模板方法、观察者、单件、抽象工厂、命令、迭代器、代理、适配器模式中选择7种填入下列的空缺中。P610 1) 工厂方法模式中，父类负责定义创建对象的公共接口，子类决定要创建的具体类是哪一个。 2) 抽象工厂模式提供一系列相关或相互依赖对象的接口而无需指定它们具体的类。 3) 单件模式确保某一个类仅有一个实例，并自行实例化并向整个系统提供这个实例。 4) 组合模式将对象组合成树形结构以表示“部分-整体”的层次结构。使得用户对单个对象和组合对象的使用具有一致性。 5) 外观模式定义了一个高层接口，这个接口使得这一子系统更加容易使用，为子系统中的一组接口提供一个一致的界面，简化了一群类的接口。 6) 观察者模式定义对象间的一种一对多的依赖关系,当一个对象的状态发生改变时, 所有依赖于它的对象都得到通知并被自动更新，也就是让对象能在状态改变时被通知。 7) 模板模MVC模型式定义一个操作中的算法的骨架，而将一些步骤延迟到子类中。 8) 迭代器模式在对象的集合之中游走，而不暴露集合的实现。 9) 代理模式包装对象，以控制对比对象的访问。 10) 适配器模式封装对象，并提供不同的接口。 2.工厂模式分为(简单工厂),(工厂方法),(抽象工厂)三种类型。 3.适配器模式，分为类的适配器和对象的适配器两种实现。其中类的适配器采用的是（继承）关系，而对象适配器采用的是（组合聚合）关系。 4.设计模式的基本要素有（名字），（意图），（问题），（解决方案），（参与者与协作者），（实现），（一般性结构）。 5.MVC模型的基本工作原理是基于(观察者)模式，实现是基于（命令）模式 6.面向对象的六条基本原则包括：开闭原则，里式代换原则，合成聚合原则以及（依赖倒转），（迪米特法则）（接口隔离）。 7．当我们想用不同的请求对客户进行参数化时，可以使用（命令）模式。
c23种设计模式4外观模式
外观模式（Facade Pattern) 动机(Motivate): 在软件开发系统中，客户程序经常会与复杂系统的内部子系统之间产生耦合，而导致客户程序随着子系统的变化而变化。那么如何简化客户程序与子系统之间的交互接口？如何将复杂系统的内部子系统与客户程序之间的依赖解耦？ 意图(Intent): 为子系统中的一组接口提供一个一致的界面，Facade模式定义了一个高层接口，这个接口使得这一子系统更加容易使用。 --------《设计模式》GOF 结构图(Struct): 适用性： 1．为一个复杂子系统提供一个简单接口。 2．提高子系统的独立性。 3．在层次化结构中，可以使用Facade模式定义系统中每一层的入口。 生活中的例子：
代码实现： 我们平时的开发中其实已经不知不觉的在用Fa?ade模式，现在来考虑这样一个抵押系统，当有一个客户来时，有如下几件事情需要确认：到银行子系统查询他是否有足够多的存款，到信用子系统查询他是否有良好的信用，到贷款子系统查询他有无贷款劣迹。只有这三个子系统都通过时才可进行抵押。我们先不考虑Fa?ade模式，那么客户程序就要直接访问这些子系统，分别进行判断。类结构图下： 在这个程序中，我们首先要有一个顾客类，它是一个纯数据类，并无任何操作，示意代码： 1//顾客类 2public class Customer 3 { 4private string _name; 5 6public Customer(string name)
7 { 8this._name = name; 9 } 10 11public string Name 12 { 13get { return _name; } 14 } 15 } 下面这三个类均是子系统类，示意代码： 1//银行子系统 2public class Bank 3 { 4public bool HasSufficientSavings(Customer c, int amount) 5 { 6 Console.WriteLine("Check bank for " + https://www.wendangku.net/doc/af2694380.html,); 7return true; 8 } 9 } 10 11//信用子系统 12public class Credit 13 { 14public bool HasGoodCredit(Customer c) 15 { 16 Console.WriteLine("Check credit for " + https://www.wendangku.net/doc/af2694380.html,); 17return true; 18 } 19 } 20 21//贷款子系统 22public class Loan 23 {
设计模式习题及参考答案
《设计模式》复习题 一、单选题 1.不同级别的用户对同一对象拥有不同的访问权利或某个客户端不能直接操作到某 个对象，但又必须和那个对象有所互动，这种情况最好使用什么设计模式( ) A. Bridge模式 B. Facade模式 C. Adapter模式 D. Proxy模式 2.模式常用的基本设计模式可分为( ) A．创建型、结构型和行为型 B．对象型、结构型和行为型 C．过程型、结构型和行为型 D．抽象型、接口型和实现型 3.以下哪个模式是利用一个对象，快速地生成一批对象( ) A. 抽象工厂（Abstract Factory）模式 B. 合成（Composite）模式 C. 原型（Prototype）模式 D. 桥接（Bridge）模式 4.以下不属于结构型模式是( ) A. COMPOSITE（组合） B. ADAPTER（适配器） C. FLYWEIGHT（享元） D. SINGLETON(单例) 5.以下意图那个是用来描述ABSTRACT FACTORY（抽象工厂）模式( ) 。 A.提供一个创建一系列相关或相互依赖对象的接口，而无需指定它们具体的类。 B.定义一个用于创建对象的接口，让子类决定实例化哪一个类。 C.将一个类的接口转换成客户希望的另外一个接口。 D.表示一个作用于某对象结构中的各元素的操作。 6.设计模式的两大主题是( ) A.系统的维护与开发 B 对象组合与类的继承 C.系统架构与系统开发 D.系统复用与系统扩展
7.外观模式的作用是（） A.当不能采用生成子类的方法进行扩充时，动态地给一个对象添加一些额外的功 能。 B.为了系统中的一组功能调用提供一个一致的接口，这个接口使得这一子系统更 加容易使用。 C.保证一个类仅有一个实例，并提供一个访问他的全局访问点。 D.在方法中定义算法的框架，而将算法中的一些操作步骤延迟到子类中实现 某软件公司欲设计一款图像处理软件，帮助用户对拍摄的照片进行后期处理。在软件需求分析阶段，公司的系统分析师识别出了如下3个关键需求： 图像处理软件需要记录用户在处理照片时所有动作，并能够支持用户动作的撤销与重做等行为。 图像处理软件需要根据当前正在处理的照片的不同特征选择合适的处理操作，处理操作与照片特征之间具有较为复杂的逻辑关系。 图像处理软件需要封装各种图像处理算法，用户能够根据需要灵活选择合适的处理算法；软件还要支持高级用户根据一定的规则添加自定义处理算法。 在系统设计阶段，公司的架构师决定采用设计模式满足上述关键需求中对系统灵活性与扩展性的要求。具体来说，为了支持灵活的撤销与重做等行为，采用（）最为合适；为了封装图像操作与照片特征之间的复杂逻辑关系，采用（）最为合适；为了实现图像处理算法的灵活选择与替换，采用（）最为合适。 8. A．工厂模式B．责任链模式C．中介者模式D．命令模式 9. A．状态模式B．适配器模式C．组合模式 D．单例模式 10. A．模板方法模式B．访问者模式C．策略模式D．观察者模式11不同级别的用户对同一对象拥有不同的访问权利或某个客户端不能直接操作到某个对象，但又必须和那个对象有所互动，这种情况最好使用什么设计模式( ) A. Bridge模式 B. Facade模式 C. Adapter模式 D. Proxy模式 12设计模式一般用来解决什么样的问题( )
设计模式考试复习题含答案
一、1. 设计模式一般用来解决什么样的问题：A.同一问题的不同表相 2. 下列属于面向对象基本原则的是：C.里氏代换 3. Open-Close原则的含义是一个软件实体：A.应当对扩展开放，对修改关闭. 4. 当我们想创建一个具体的对象而又不希望指定具体的类时，使用（A）模式。A.创建型 5. 要依赖于抽象不要依赖于具体。即针对接口编程不要针对实现编程：（D）依赖倒转原则 6. 依据设计模式思想,程序开发中应优先使用的是( A )关系实现复用。A, 委派 7. 设计模式的两大主题是( D ) D.系统复用与系统扩展 8. 单体模式中,两个基本要点(AB)和单体类自己提供单例A .构造函数私有 B.唯一实例 9. 下列模式中,属于行为模式的是( B ) B观察者 10. “不要和陌生人说话”是( D )原则的通俗表述 D.迪米特 1. 软件体系结构是指一个系统的有目的的设计和规划，这个设计规划既不描述活动，也不描述系统怎样开发，它只描述系统的组成元素及其相互的交互协作。 2．一个UML模型只描述了一个系统要做什么，它并没告诉我们系统是怎么做。 3．接口是可以在整个模型中反复使用的一组行为，是一个没有属性而只有方法的类。 4．多重性指的是，某个类有多个对象可以和另一个类的一对象关联。 5．当一个类的对象可以充当多种角色时，自身关联就可能发生。 6．在泛化关系中，子类可以替代父类。后前者出现的可以相同地方。反过来却不成立。 7．最通常的依赖关系是一个类操作的形构中用到了另一个类的定义。 8．组成是强类型的聚集，因为聚集中的每个部分体只能属于一个整体。 9．实现的符号和继承的符号有相似之处，两者的唯一差别是实现关系用虚线表示，继承关系用实线表示。 10. 设计模式中应优先使用对象组合而不是类继承。 1.适配器模式属于创建型模式结构型（F ） 2.在设计模式中，“效果”只是指“原因和结果”（T ） 3.设计模式使代码编制不能真正工程化（T ） 4.面向对象语言编程中的异常处理，可以理解为责任链模式（T ） 5.反模式就是反对在软件开发过程中使用设计模式分析：反模式用来解决问题的带有共性的不良方法（F ） 1.什么是设计模式？设计模式目标是什么？ 答：设计模式是一套被反复使用、多数人知晓的、经过分类编目的、代码设计经验的总结。使用设计模式是为了可重用代码、让代码更容易被他人理解，保证代码可靠性。 2.设计模式中一般都遵循的原则有什么？ 答：开闭原则、根据场景进行设计原则、优先组合原则、包容变化原则 3.“Gang of Four”针对“创建优秀面向对象设计”建议了哪些策略？ 答：针对接口编程、优先使用对象组合而不是类继承，找到并封装变化点。 4.面向对象系统中功能复用的两种最常用技术是什么？ 答：类继承和对象组合，类继承允许你根据其他类的实现来定义一个类的实现。父类的部细节对子类可见。类继承是在编译时刻静态定义的，且可直接使用，类继承可以较方便地改变被复用的实现。对象组合是类继承之外的另一种复用选择。新的更复杂的功能可以通过组装或组合对象来获得。对象组合要求被组合的对象具有良好定义的接口。 5.只根据抽象类中定义的接口来操纵对象有什么好处？ 答：1)客户无须知道他们使用对象的特定类型，只须对象有客户所期望的接口。 2)客户无须知道他们使用的对象是用什么类来实现的，他们只须知道定义接口的抽象类。 五、应用题（分值15） 公司架构：经理、工程师、技师和后勤人员都是公司的雇员，经理管理工程师、技师和后勤人员。高层经理领导较低级别的经理。典型层次图如下：可以使用哪种设计模式实现公司的层级关系？并说明为什么？