题型：选择题30分，程序填空题60分，模式编程10。
*设计模式的关键元素包括以下四个方面：
模式名称(Pattern name)
问题(Problem)
解决方案(Solution)
效果(Consequences)
*常用的描述设计模式的格式有：意图、动机、适用性、结构（模式动机、模式定义、模式结构、模式分析、模式优缺点、模式适用环境）
*设计模式的两大主题是系统复用与系统拓展。
*常用的面向对象设计原则包括7个，这些原则并不是孤立存在的，它们相互依赖，相互补充:
*创建型模式(Creational Pattern)对类的实例化过程进行了抽象，能够将软件模块中对象的创建和对象的使用分离。
*结构型模式是描述如何将类对象结合在一起，形成一个更大的结构，结构模式描述两种不同的东西：类与类的实例。故可以分为类结构模式和对象结构模式。
*行为型模式描述类或对象如何交互及如何分配职责，它主要涉及通过合理的处理方法，达到使系统升级性和维护性提高的目的。
1.简单工厂模式：又称为静态工厂方法(Static Factory Method)模式，根据参数的不同返回不同类的实例。简单工厂模式专门定义一个类来负责创建其他类的实例，被创建的实例通常都具有共同的父类。简单工厂模式属于创建型模式。
简单工厂模式包含如下角色：
Factory：工厂角色
Product：抽象产品角色
ConcreteProduct：具体产品角色
public abstract class AbstractPay//抽象支付类
{
public abstract void pay();
}
public class CashPay extends AbstractPay//具体支付类
{
public void pay()
{
//现金支付处理代码
}
}
public class CreditcardPay extends AbstractPay//具体支付类
{
public void pay()
{
//信用卡支付处理代码
}
}
public class PayMethodFactory//支付工厂
{
public static AbstractPaygetPayMethod(String type)
{
if(type.equalsIgnoreCase("cash"))
{
return new CashPay(); //根据参数创建具体产品}
else if(type.equalsIgnoreCase("creditcard"))
{
return new CreditcardPay(); //根据参数创建具体产品 } …… } }
实例一：简单电视机工厂
某电视机厂专为各知名电视机品牌代工生产各类电视机，当需要海尔牌电视机时只需要在调用该工厂的工厂方法时传入参数“Haier ”，需要海信电视机时只需要传入参数“Hisense ”，工厂可以根据传入的不同参数返回不同品牌的电视机。现使用简单工厂模式来模拟该电视机工厂的生产过程。
2.工厂方法模式(Factory Method Pattern)：又称为工厂模式，也叫虚拟构造器(Virtual Constructor)模式或者多态工厂(Polymorphic Factory)模式。在工厂方法模式中，工厂父类负责定义创建产品对象的公共接口，而工厂子类则负责生成具体的产品对象，目的是将产品类的实例化操作延迟到工厂子类中完成，即通过工厂子类来确定究竟应该实例化哪一个具体产品类。工厂方法模式属于类创建型模式。
工厂方法模式包含如下角色： Product ：抽象产品
ConcreteProduct ：具体产品 Factory ：抽象工厂
ConcreteFactory ：具体工厂
public abstract class PayMethodFactory //抽象工厂类 {
public abstract AbstractPay getPayMethod();
HisenseTV
+play ()...
: void
TV
+play ()...
: void TVFactory
+produceTV (String brand)...
: TV HaierTV +play ()...
: void ConcreteProduct
Product ConcreteFactory +factoryMethod ()...
: Product Factory
+factoryMethod ()...
: Product
}
public class CashPayFactory extends PayMethodFactory//具体工厂类
{
public AbstractPaygetPayMethod()
{
return new CashPay();
}
}
public abstract class AbstractPay//抽象支付类
{
public abstract void pay();
}
public class CashPay extends AbstractPay//具体支付类
{
public void pay()
{
//现金支付处理代码
}
}
PayMethodFactory factory; //客户类代码片段
AbstractPay payMethod;
factory=new CashPayFactory();
payMethod =factory.getPayMethod();
payMethod.pay();
实例一：电视机工厂
将原有的工厂进行分割，为每种品牌的电视机提供一个子工厂，海尔工厂专门负责生产海尔电视机，海信工厂专门负责生产海信电视机，如果需要生产TCL电视机或创维电视机，只需要对应增加一个新的TCL 工厂或创维工厂即可，原有的工厂无须做任何修改，使得整个系统具有更加的灵活性和可扩展性。
3.抽象工厂模式(Abstract Factory Pattern)：称为Kit 模式，提供一个创建一系列相关或相互依赖对象的接口，而无须指定它们具体的类。抽象工厂模式属于对象创建型模式。
HaierTVFactory +produceTV ()...
: TV TVFactory +produceTV ()...
: TV HaierTV +play ()...
: void TV
+play ()...
: void Client
HisenseTVFactory +produceTV ()...
: TV HisenseTV +play ()...
: void
抽象工厂模式包含如下角色：
AbstractFactory：抽象工厂
ConcreteFactory：具体工厂
AbstractProduct：抽象产品
Product：具体产品
public abstract class AbstractFactory//抽象工厂类的典型代码
{
public abstract AbstractProductA createProductA();
public abstract AbstractProductB createProductB();
}
public class ConcreteFactory1 extends AbstractFactory //具体工厂类的典型代码
{
public AbstractProductA createProductA()
{
return new ConcreteProductA1();
}
public AbstractProductB createProductB()
{
return new ConcreteProductB1();
}
}
实例一：电器工厂
一个电器工厂可以产生多种类型的电器，如海尔工厂可以生产海尔电视机、海尔空调等，TCL工厂可以生产TCL电视机、TCL空调等，相同品牌的电器构成一个产品族，而相同类型的电器构成了一个产品等级结构，现使用抽象工厂模式模拟该场景。
4.原型模式(Prototype Pattern)：用原型实例指定创建对象的种类，并且通过复制这些原型创建新的对象。
基本工作原理是通过将一个原型对象传给那个要发动创建的对象，这个要发动创建的对象通过请求原型对象拷贝原型自己来实现创建过程。原型模式是一种对象创建型模式。
原型模式包含如下角色： Prototype ：抽象原型类
ConcretePrototype ：具体原型类 Client ：客户类
public class PrototypeDemo implements Cloneable //示例代码 {
……
public Object clone () {
Object object = null; try {
object = super.clone();
} catch (CloneNotSupportedException exception) { System.err.println("Not support cloneable"); }
return object ; } …… }
*浅克隆(Shallow Clone)：当原型对象被复制时，只复制它本身和其中包含的值类型的成员变量，而引用类型的成员变量并没有复制。
*深克隆(Deep Clone)：除了对象本身被复制外，对象所包含的所有成员变量也将被复制。 实例一：邮件复制（浅克隆）
由于邮件对象包含的内容较多（如发送者、接收者、标题、内容、日期、附件等），某系统中现需要提供一个邮件复制功能，对于已经创建好的邮件对象，可以通过复制的方式创建一个新的邮件对象，如果需要改变某部分内容，无须修改原始的邮件对象，只需要修改复制后得到的邮件对象即可。使用原型模式设计该系统。在本实例中使用浅克隆实现邮件复制，即复制邮件(Email)的同时不复制附件(Attachment)。 邮件复制（浅克隆）：
Client
--prototype copy : Prototype : Prototype +operation ()...
Prototype
+clone ()...
: Prototype ConcretePrototypeA
+clone ()...
: Prototype ConcretePrototypeB +clone ()...
: Prototype
邮件复制（深克隆）：
5.单例模式(Singleton Pattern)：单例模式确保某一个类只有一个实例，而且自行实例化并向整个系统提供这个实例，这个类称为单例类，它提供全局访问的方法。单例模式是一种对象创建型模式。
单例模式包含如下角色： Singleton ：单例
public class Singleton //单例模式的实现代 { private static Singleton instance=null; //静态私有成员变量 //私有构造函数
Object +clone ()...
: Object Attachment +download ()...
: void Email
-attachment : Attachment
++++Email ()clone ()display ()getAttachment ()...
: Object : void
: Attachment Cloneable
Attachment +download ()...
: void Email
-attachment : Attachment
++++Email ()
deepClone ()display ()getAttachment ()...
: Object : void
: Attachment
Serializable
Singleton
-instance : Singleton -+Singleton ()
getInstance ()...
: Singleton
private Singleton() { }
//静态公有工厂方法，返回唯一实例 public static Singleton getInstance() { if(instance==null) instance=new Singleton(); return instance ; } }
实例一：身份证号码
在现实生活中，居民身份证号码具有唯一性，同一个人不允许有多个身份证号码，第一次申请身份证时将给居民分配一个身份证号码，如果之后因为遗失等原因补办时，还是使用原来的身份证号码，不会产生新的号码。现使用单例模式模拟该场景。
实例二：打印池
在操作系统中，打印池(Print Spooler)是一个用于管理打印任务的应用程序，通过打印池用户可以删除、中止或者改变打印任务的优先级，在一个系统中只允许运行一个打印池对象，如果重复创建打印池则抛出异常。现使用单例模式来模拟实现打印池的设计。
饿汉式单例类：
IdentityCardNo
--instance no : IdentityCardNo : String -+-+IdentityCardNo ()getInstance ()setIdentityCardNo (String no)getIdentityCardNo ()...: IdentityCardNo : void : String PrintSpoolerSingleton
-instance : PrintSpoolerSingleton -++PrintSpoolerSingleton ()getInstance ()manageJobs ()...
: PrintSpoolerSingleton : void PrintSpoolerException
+PrintSpoolerException (String message)...
懒汉式单例类：
6.适配器模式(Adapter Pattern) ：将一个接口转换成客户希望的另一个接口，适配器模式使接口不兼容的那些类可以一起工作，其别名为包装器(Wrapper)。适配器模式既可以作为类结构型模式，也可以作为对象结构型模式。 类适配器：
对象适配器：
EagerSingleton
-instance : EagerSingleton = new EagerSingleton()-+EagerSingleton ()getInstance ()...
: EagerSingleton LazySingleton
-instance : LazySingleton = null -+LazySingleton ()getInstance ()...
: LazySingleton Adapter +request ()...
Target +request ()...
Adaptee +specificRequest ()...
Client
适配器模式包含如下角色： Target ：目标抽象类 Adapter ：适配器类 Adaptee ：适配者类 Client ：客户类
public class Adapter extends Adaptee implements Target //典型的类适配器代码 { public void request() { specificRequest(); } }
public class Adapter extends Target //典型的对象适配器代码 { private Adaptee adaptee; public Adapter(Adaptee adaptee ) { this.adaptee=adaptee ; } public void request() { adaptee.specificRequest(); } }
实例一：仿生机器人
Adapter +request ()...
Adaptee +specificRequest ()...
Client Target +request ()...
实例二：在为某学校开发教务管理系统时，开发人员发现需要对学生成绩进行排序和查找，该系统的设
计人员已经开发了一个成绩操作接口ScoreOperation ，在该接口中声明了排序方法Sort(int[]) 和查找方法
Search(int[], int)，为了提高排序和查找的效率，开发人员决定重用现有算法库中的快速排序算法类QuickSortClass 和二分查找算法类BinarySearchClass ，其中QuickSortClass 的QuickSort(int[])方法实现了快速排序，BinarySearchClass 的BinarySearch (int[], int)方法实现了二分查找。
由于某些原因，开发人员已经找不到该算法库的源代码，无法直接通过复制和粘贴操作来重用其中的代码；而且部分开发人员已经针对ScoreOperation 接口编程，如果再要求对该接口进行修改或要求大家直接使用QuickSortClass 类和BinarySearchClass 类将导致大量代码需要修改。
现使用适配器模式设计一个系统，在不修改已有代码的前提下将类QuickSortClass 和类BinarySearchClass 的相关方法适配到ScoreOperation 接口中。
算法库重用结构图
7.桥接模式(Bridge Pattern)：将抽象部分与它的实现部分分离，使它们都可以独立地变化。它是一种对象结构型模式，又称为柄体(Handle and Body)模式或接口(Interface)模式。
DogAdapter
++cry ()move ()...: void : void
Robot ++cry ()move ()...
: void : void Dog ++wang ()run ()...
: void : void OperationAdapter
--sortObj searchObj : QuickSortClass : BinarySearchClass +++OperationAdapter ()Sort (int[] array)Search (int[] array, int key)...
: int[]: int ScoreOperation
++Sort (int[] array)Search (int[] array, int key)...
: int[]: int QuickSortClass
++++
QuickSort (int[] array)
Sort (int[] array, int p, int r)Partition (int[] a, int p, int r)Swap (int[] a, int i, int j)...
: int[]: void : int : void
BinarySearchClass
+BinarySearch (int[] array, int key)...
: int
Client
桥接模式包含如下角色： Abstraction ：抽象类
RefinedAbstraction ：扩充抽象类 Implementor ：实现类接口
ConcreteImplementor ：具体实现类
public interfaceImplementor //典型的实现类接口代码 { public void operationImpl(); }
public abstract class Abstraction //典型的抽象类代码 { protectedImplementor impl; public void setImpl(Implementor impl ) { this.impl=impl ; } public abstract void operation(); }
public class RefinedAbstraction extends Abstraction //典型的扩充抽象类代码 { public void operation() { //代码 impl.operationImpl(); //代码 } }
实例一：模拟毛笔
现需要提供大中小3种型号的画笔，能够绘制5种不同颜色，如果使用蜡笔，我们需要准备3*5=15支蜡笔，也就是说必须准备15个具体的蜡笔类。而如果使用毛笔的话，只需要3种型号的毛笔，外加5
Client
Abstraction +operation ()...
Implementor +operationImpl ()...
RefinedAbstraction +operation ()...ConcreteImplementorA +operationImpl ()...ConcreteImplementorB
+operationImpl ()
...
个颜料盒，用3+5=8个类就可以实现15支蜡笔的功能。本实例使用桥接模式来模拟毛笔的使用过程。
8.外观模式(Facade Pattern)：外部与一个子系统的通信必须通过一个统一的外观对象进行，为子系统中的一组接口提供一个一致的界面，外观模式定义了一个高层接口，这个接口使得这一子系统更加容易使用。外观模式又称为门面模式，它是一种对象结构型模式。
外观模式包含如下角色： Facade : 外观角色
SubSystem :子系统角色
public class Facade //典型的外观角色代码 {
private SubSystemA obj1 = new SubSystemA(); private SubSystemB obj2 = new SubSystemB(); private SubSystemC obj3 = new SubSystemC(); public void method() {
obj1.method();
obj2.method(); obj3.method();
Pen
{abstract}
#color : Color
++setColor (Color color)draw (String name)...
: void : void Color
+bepaint (String penType, String name)...
: void SmallPen
+draw (String name)...
: void Red
+bepaint (String penType, String name)...
: void MiddlePen
+draw (String name)...
: void BigPen
+draw (String name)...
: void Green +bepaint (String penType, String name)...
: void Blue
+bepaint (String penType, String name)...
: void White +bepaint (String penType, String name)...
: void Black
+bepaint (String penType, String name)...
: void Client
Facade
SubSystemA SubSystemB SubSystemC
} }
实例一：文件加密
某系统需要提供一个文件加密模块，加密流程包括三个操作，分别是读取源文件、加密、保存加密之后的文件。读取文件和保存文件使用流来实现，这三个操作相对独立，其业务代码封装在三个不同的类中。现在需要提供一个统一的加密外观类，用户可以直接使用该加密外观类完成文件的读取、加密和保存三
抽象外观类：
EncryptFacade
---reader cipher writer : FileReader : CipherMachine : FileWriter ++EncryptFacade ()
fileEncrypt (String fileNameSrc, String fileNameDes)...
: void FileReader
+read (String fileNameSrc)...
: String CipherMachine
+encrypt (String plainText)...
: String FileWriter
+write (String encryptText, String fileNameDes)...
: void ConcreteFacade1++method1 ()method2 ()...
: void : void SubSystem1SubSystem2SubSystem3AbstractFacade ++method1 ()method2 ()...
: void : void SubSystem4SubSystem5
ConcreteFacade2++method1 ()method2 ()...
: void : void Client
9.代理模式(Proxy Pattern) ：给某一个对象提供一个代理，并由代理对象控制对原对象的引用。代理模式的英文叫做Proxy 或Surrogate ，它是一种对象结构型模式。
代理模式包含如下角色： Subject : 抽象主题角色 Proxy : 代理主题角色
RealSubject : 真实主题角色
public class Proxy implements Subject //典型的代理类实现代码 {
privateRealSubject realSubject = new RealSubject(); public void preRequest() {…...}
public void request() {
preRequest();
realSubject.request(); postRequest(); }
public void postRequest() {……} }
实例一：论坛权限控制代理
在一个论坛中已注册用户和游客的权限不同，已注册的用户拥有发帖、修改自己的注册信息、修改自己的帖子等功能；而游客只能看到别人发的帖子，没有其他权限。使用代理模式来设计该权限管理模块。 在本实例中我们使用代理模式中的保护代理，该代理用于控制对一个对象的访问，可以给不同的用户提供不同级别的使用权限。
Subject
+request ()...
Proxy
-realSubject : RealSubject +++preRequest ()request ()
postRequest ()...
RealSubject
+request ()...
Client
10.命令模式(Command Pattern)：将一个请求封装为一个对象，从而使我们可用不同的请求对客户进行参数化；对请求排队或者记录请求日志，以及支持可撤销的操作。命令模式是一种对象行为型模式，其别名为动作(Action)模式或事务(Transaction)模式。
命令模式包含如下角色： Command : 抽象命令类
ConcreteCommand : 具体命令类 Invoker : 调用者 Receiver : 接收者 Client :客户类
public abstract class Command //典型的抽象命令类代码 { public abstract void execute(); }
public class Invoker //典型的调用者代码 { private Command command; public Invoker (Command command )
PermissionProxy
--permission level : RealPermission : int = new RealPermission() = 0+++++modifyUserInfo ()viewNote ()publishNote ()modifyNote ()setLevel (int level): void : void : void : void : void
RealPermission
+++++
modifyUserInfo ()viewNote ()publishNote ()modifyNote ()
setLevel (int level)...
: void : void : void : void : void
AbstractPermission +++++
modifyUserInfo ()viewNote ()publishNote ()modifyNote ()
setLevel (int level)
: void : void : void : void : void
Client
Invoker
Command +execute ()...
ConcreteCommand
-state : +execute ()...
Receiver +action ()...Client
{
https://www.doczj.com/doc/a614113708.html,mand=command;
}
public void setCommand(Command command)
{
https://www.doczj.com/doc/a614113708.html,mand=command;
}
//业务方法，用于调用命令类的方法
public void call()
{
command.execute();
}
}
public class ConcreteCommand extends Command//典型的具体命令类代码{
private Receiver receiver;
public void execute()
{
receiver.action();
}
}
public class Receiver//典型的请求接收者代码
{
public void action()
{
//具体操作
}
}
命令模式顺序图：
实例一：电视机遥控器
电视机是请求的接收者，遥控器是请求的发送者，遥控器上有一些按钮，不同的按钮对应电视机的不同操作。抽象命令角色由一个命令接口来扮演，有三个具体的命令类实现了抽象命令接口，这三个具体命令类分别代表三种操作：打开电视机、关闭电视机和切换频道。显然，电视机遥控器就是一个典型的命令模式应用实例。
11.迭代器模式(Iterator Pattern) ：提供一种方法来访问聚合对象，而不用暴露这个对象的内部表示，其别名为游标(Cursor)。迭代器模式是一种对象行为型模式。
迭代器模式包含如下角色： Iterator : 抽象迭代器
ConcreteIterator : 具体迭代器 Aggregate : 抽象聚合类
ConcreteAggregate : 具体聚合类 实例：电视机遥控器
电视机遥控器就是一个迭代器的实例，通过它可以实现对电视机频道集合的遍历操作，本实例我们将模拟电视机遥控器的实现。
tv
Controller
---openCommand closeCommand changeCommand : AbstractCommand : AbstractCommand : AbstractCommand
++++Controller (AbstractCommand openCommand, AbstractCommand closeCommand, AbstractCommand changeCommand)open ()close ()change ()...
: void : void : void AbstractCommand +execute ()...
: void TVOpenCommand -tv : Television
++TVOpenCommand ()execute ()...
: void Television
+++open ()close ()changeChannel ()...
: void : void : void TVCloseCommand -tv : Television
++TVCloseCommand ()execute ()...
: void TVChangeCommand -tv : Television
++TVChangeCommand ()execute ()...
: void tv.close();
ConcreteAggregate +createIterator ()...
Aggregate
+createIterator ()
ConcreteIterator
++++
first ()next ()hasNext ()currentItem ()
Iterator
++++
first ()next ()hasNext ()currentItem ()
12.观察者模式(Observer Pattern)：定义对象间的一种一对多依赖关系，使得每当一个对象状态发生改变时，其相关依赖对象皆得到通知并被自动更新。观察者模式又叫做发布-订阅（Publish/Subscribe）模式、模型-视图（Model/View）模式、源-监听器（Source/Listener）模式或从属者（Dependents）模式。观察者模式是一种对象行为型模式。
观察者模式包含如下角色：
Subject: 目标（被观察者）
ConcreteSubject: 具体目标
Observer: 观察者
ConcreteObserver: 具体观察者
设计模式期中考试试题 一：单项选择（共20道，每道2分） 1、设计模式一般用来解决什么样的问题( ) A.同一问题的不同表相B不同问题的同一表相 C.不同问题的不同表相 D.以上都不是 2、下列属于面向对象基本原则的是( ) A.继承 B.封装 C.里氏代换D都不是 3、Open-Close原则的含义是一个软件实体( ) A.应当对扩展开放，对修改关闭. B.应当对修改开放，对扩展关闭 C.应当对继承开放，对修改关闭 D.以上都不对 4、当我们想创建一个具体的对象而又不希望指定具体的类时，可以使用（）模式。 A.创建型 B.结构型C行为型D.以上都可以 5、要依赖于抽象，不要依赖于具体。即针对接口编程，不要针对实现编程,是( )的表述 A.开-闭原则 B.接口隔离原则 C.里氏代换原则 D.依赖倒转原则 6、设计模式的两大主题是( ) A.系统的维护与开发 B 对象组合与类的继承 C.系统架构与系统开发 D.系统复用与系统扩展 7、“不要和陌生人说话” 是( )原则的通俗表述 A.接口隔离 B.里氏代换 C.依赖倒转 D.迪米特：一个对象应对其他对象尽可能少的了解 8、构造者的的退化模式是通过合并（）角色完成退化的。 A.抽象产品B产品C创建者D使用者 9、以下关于简单工厂模式叙述错误的是（） A 它属于GoF23种设计模式 B 它是最简单的设计模式之一 C 它是学习其他创建型模式的基础 D 它只需要记住一个简单的参数即可获得所需对象的实例 E 它类中的方法通常为静态方法 F 它返回的类都有一个公共的父类和公共的方法 10、对象适配器模式是（）原则的典型应用。 A.合成聚合复用原则 B.里式代换原则 C.依赖倒转原则 D.迪米特法则 D.以上表述全部错误。 11.对于依赖倒转的表述错误的是（） A.依赖于抽象而不依赖于具体，也就是针对接口编程。 B.依赖倒转的接口并非语法意义上的接口，而是，一个类对其他对象进行调用时，所知道的方法集合。 C.从选项B的角度论述，一个对象可以有多个接口。 D.实现了同一接口的对象，可以在运行期间，顺利地进行替换。而且不必知道所示用的对象是那个实现类的实例。 E.此题没有正确答案。 12. 现有5个产品族，分布于3各不同的产品等级结构，只要指明一个产品所处的产品族以及它所在的等级结构，就可以唯一地确认这个产品。那么使用抽象工厂方法模式只需要提供
设计模式复习提纲 第一章 1.状态图的定义 状态图用来描述一个特定对象的所有可能状态及其引起状态转移的事件。 第二章 1.软件的可维护性和可复用性（？） 软件可维护性，即维护人员对该软件进行维护的难易程度,具体包括理解、改正、改动和改进该软件的难易程度。 可复用性：复用又叫重用，是重复使用的意思。 2.面向对象设计原则 （1）单一职责原则 （2）开闭原则 （3）里氏代换原则 （4）依赖倒转原则 （5）接口隔离原则 （6）合成复用原则 （7）迪米特法则 3.单一职责原则定义 单一职责原则定义：一个对象应该只包含单一的职责，并且该职责被完整地封装在一个类中。 另一种定义：就一个类而言，应该仅有一个引起它变化的原因。 4.开闭原则定义 开闭原则定义：一个软件实体应当对扩展开放，对修改关闭。 5.里氏代换原则定义 里氏代换原则有两种定义方式。 第一种定义方式相对严格，其定义如下： 如果对每一个类型为S的对象o1，都有类型为T的对象o2，使得以T定义的所有程序P 在所有的对象o1都代换成o2时，程序P的行为没有变化，那么类型S是类型T的子类型。第二种更容易理解的定义方式如下： 所有引用基类（父类）的地方必须能透明地使用其子类的对象。 6.依赖倒转原则定义 依赖倒转原则定义：高层模块不应该依赖低层模块，它们都应该依赖抽象。抽象不应该依赖于细节，细节应该依赖于抽象。 另一种表述为：要针对接口编程，不要针对实现编程。 7.接口隔离原则定义 接口隔离原则定义：客户端不应该依赖那些它不需要的接口。注意：在该定义中的接口指的是所定义的方法。
另一种定义方法：一旦一个接口太大，则需要将它分割成一些更细小的接口，使用该接口的客户端仅需知道与之相关的方法即可。 8.合成复用原则定义 合成复用原则，又称为组合/聚合复用原则，其定义如下：尽量使用对象组合，而不是继承来达到复用的目的。 9.迪米特法则定义 迪米特法则，又称为最少知识原则，它有多种定义方法，其中几种典型定义如下： (1)不要和“陌生人”说话。 (2)只与你的直接朋友通信。 (3)每一个软件单位对其他的单位都只有最少的知识，而且局限于那些与本单位密切相关的软件单位。 第三章 1.模式的定义 每个模式都描述了一个在我们的环境中不断出现的问题，然后描述了该问题的解决方案的核心，通过这种方式，我们可以无数次地重用那些已有的解决方案，无需再重复相同的工作。可以用一句话简单表示为：模式是在特定环境中解决问题的一种方案。 2.设计模式的定义 设计模式是一套被反复使用、多数人知晓的、经过分类编目的、代码设计经验的总结，使用设计模式是为了可重用代码、让代码更容易被他人理解、保证代码可靠性。 3.设计模式的基本要素 设计模式一般有如下几个基本要素：模式名称、问题、目的、解决方案、效果、实例代码和相关设计模式，其中的关键元素包括以下四个方面：模式名称、问题、解决方案、效果。 4.设计模式的分类 （1）根据其目的（模式是用来做什么的）可分为创建型、结构型和行为型三种： ①创建型模式主要用于创建对象。 ②结构型模式主要用于处理类或对象的组合。 ③行为型模式主要用于描述对类或对象怎样交互和怎样分配职责。 （2）根据范围，即模式主要是用于处理类之间关系还是处理对象之间的关系，可分为类模式和对象模式两种： ①类模式处理类和子类之间的关系，这些关系通过继承建立，在编译时刻就被确定下来，是属于静态的。 ②对象模式处理对象间的关系，这些关系在运行时刻变化，更具动态性。 5.GoF设计模式简介 GoF 最先将模式的概念引入软件工程领域，他们归纳发表了23种在软件开发中使用频率较高的设计模式，旨在用模式来统一沟通面向对象方法在分析、设计和实现间的鸿沟。
创建型结构型行为型 类Factory Method Adapter In terpreter Template Method 对象 Abstract Factory Builder Prototype Si ngleto n Apapter(对象) Bridge Composite Decorator Fa?ade Flyweight Proxy Chain of Resp on sibility Comma nd Iterator Mediator Meme nto Observer State Strategy Visitor （抽象工厂） 提供一个创建一系列相关或互相依赖对象的接口，而无须制定它们具体的类。 图10-25抽象工厂模式结构图 Abstract Factory 抽象工厂 class Program { static void Main(string[] args) { AbstractFactory factory1 = new Con creteFactory1(); Clie nt c1 = new Clie nt(factory1); c1.Ru n(); AbstractFactory factory2 = new Con creteFactory2(); Clie nt c2 = new Clie nt(factory2); c2.Ru n(); Co nsole.Read(); abstract class AbstractFactory { public abstract AbstractProductA CreateProductA(); public abstract AbstractProductB
实验2 设计模式实验一 实验学时： 4 每组人数： 1 实验类型： 3 （1：基础性2：综合性3：设计性4：研究性） 实验要求： 1 （1：必修2：选修3：其它） 实验类别： 3 （1：基础2：专业基础3：专业4：其它） 一、实验目的 1．熟练使用面向对象设计原则对系统进行重构； 2．熟练使用PowerDesigner和任意一种面向对象编程语言实现几种常见的创建型设计模式和结构型设计模式，包括简单工厂模式、工厂方法模式、抽象工厂模式、单例模式、适配器模式、桥接模式和组合模式，理解每一种设计模式的模式动机，掌握模式结构，学习如何使用代码实现这些模式。 二、实验内容 1．在某图形库API中提供了多种矢量图模板，用户可以基于这些矢量图创建不同的显示图形，图形库设计人员设计的初始类图如下所示： Circle + + + + +init () setColor () fill () setSize () display () ... : void : void : void : void : void Triangle + + + + + init () setColor () fill () setSize () display () ... : void : void : void : void : void Rectangle + + + + + init () setColor () fill () setSize () display () ... : void : void : void : void : void Client 在该图形库中，每个图形类（如Circle、Triangle等）的init()方法用于初始化所创建的图形，setColor()方法用于给图形设置边框颜色，fill()方法用于给图形设置填充颜色，setSize()方法用于设置图形的大小，display()方法用于显示图形。 客户类(Client)在使用该图形库时发现存在如下问题： ①由于在创建窗口时每次只需要使用图形库中的一种图形，因此在更换图形时需要修改客户类源代码；
设计模式试题 一.选择 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. 设计模式一般用来解决什么样的问题： 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） 公司架构：经理、工程师、技师和后勤人员都是公司的雇员，经理管理工程师、技师和后勤人员。高层经理领导较低级别的经理。典型层次图如下：可以使用哪种设计模式实现公司的层级关系？并说明为什么？ 组合模式，第一，其公司关系架构为树形结构；第二，其表示了部分-整体关系（自己扩展）
Java设计模式之心得 UML 1.案例图:系统角色和使用案例和它们之间的关系 2.类图: 类图中的关系 1.一般化关系：继承,接口 2.关联关系：类与类之间的联系Driver中的Car 3.聚合关系：整体与个体之间的关系 4.合成关系：强关联，整体包含部分，整体代表部分的生命周期，不能共享 5.依赖关系：类与类之间的连接，如Person包含Car和House 3.时序图： 每个步骤的流程图 4.状态图：一系列对象的内部状态及状态变化和转移 5.合作图：相互关系图 6.构建图：部署的软件构件之间的关系 7.活动图： 8.部署图： 面向对象的设计原则： 1.设计目标：可扩展性、可维护性、可插入性、可复用性 2.设计原则：开闭原则、里氏替换原则、依赖倒转原则、接口隔离原则、组合\聚合复用原则、迪米特法则 开闭原则：
OCP作为OO的高层原则，主张使用“抽象(Abstraction)”和“多态(Polymorphism)”将设计中的静态结构改为动态结构，维持设计的封闭性。 一句话：“Closed for Modification;Open for Extension”——“对变更关闭；对扩展开放”。开闭原则其实没什么好讲的，我将其归结为一个高层次的设计总则。OCP的动机很简单：软件是变化的。不论是优质的设计还是低劣的设计都无法回避这一问题。OCP说明了软件设计应该尽可能地使架构稳定而又容易满足不同的需求。 重要的步骤： 1.抽象化 2.对可变性的封装原则 里氏替换原则： 1.分析对象时必须明确是Is-a还是Has-a的关系,任何基类适应的地方，子类一定适用依赖倒转原则： 要依赖于抽象，不要依赖于具体。简单的说，依赖倒置原则要求客户端依赖于抽象耦合。原则表述：抽象不应当依赖于细节；细节应当依赖于抽象；要针对接口编程，不针对实现编程。 接口隔离原则： 使用多个专门的接口比使用单一的总接口要好。广义的接口：一个接口相当于剧本中的一种角色，而此角色在一个舞台上由哪一个演员来演则相当于接口的实现。因此一个接口应当简单的代表一个角色，而不是一个角色。，如果系统设计多个角色的话，则应当每一个角色都由一个特定的接口代表。狭义的接口（Interface）:接口隔离原则讲的就是同一个角色提供宽、窄不同的接口，以对付不同的客户端。 组合\聚合复用原则： 要尽量使用组合/聚合，而不是使用继承来达到目的 原因： 继承复用的缺点：静态复用 什么使用使用继承：a.满足is-a的关系，而不是has-a的关系 b.满足lsp原则 优点：a.简洁 b.父类修改某个方法，子类能获得 迪米特法则： 一个对象或模块应该和其它对象和模块尽量少的通信（高内聚），涉及的模式有：门面模式，调停者模式，前端控制器模式，业务代表模式，dao模式
实验二设计模式实验一 一、实验目的 熟练使用PowerDesigner和任意一种面向对象编程语言实现几种常见的设计模式，包括简单工厂模式、工厂方法模式、抽象工厂模式、单例模式和适配器模式，理解每一种设计模式的模式动机，掌握模式结构，学习如何使用代码实现这些模式，并学会分析这些模式的使用效果。 二、实验内容 使用PowerDesigner和任意一种面向对象编程语言实现简单工厂模式、工厂方法模式、抽象工厂模式、单例模式和适配器模式，包括根据实例绘制模式结构图、编写模式实例实现代码，运行并测试模式实例代码。 (1) 简单工厂模式 使用简单工厂模式设计一个可以创建不同几何形状(Shape)的绘图工具类，如可创建圆形(Circle)、方形(Rectangle)和三角形(Triangle) 对象，每个几何图形都要有绘制draw()和擦除erase()两个方法，要求在绘制不支持的几何图形时，提示一个UnsupportedShapeException，绘制类图并编程实现。 (2) 简单工厂模式 使用简单工厂模式模拟女娲(Nvwa)造人(Person)，如果传入参数“M”，则返回一个Man 对象，如果传入参数“W”，则返回一个Woman对象，使用任意一种面向对象编程语言实现该场景。现需要增加一个新的Robot类，如果传入参数“R”，则返回一个Robot对象，对代码进行修改并注意女娲的变化。 (3) 工厂方法模式 某系统日志记录器要求支持多种日志记录方式，如文件记录、数据库记录等，且用户可以根据要求动态选择日志记录方式，现使用工厂方法模式设计该系统。用代码实现日志记录器实例，如果在系统中增加一个中的日志记录方式——控制台日志记录(ConsoleLog)，绘制类图并修改代码，注意增加新日志记录方式过程中原有代码的变化。
建造者模式 课后第一题： 产品类： public class GamePerson { private String face; private String gender; private String cloth; public String getFace() { return face; } public void setFace(String face) { this.face = face; } public String getGender() { return gender; } public void setGender(String gender) { this.gender = gender; } public String getCloth() { return cloth; } public void setCloth(String cloth) { this.cloth = cloth; } } 抽象建造类： public abstract class PersonCreate { protected GamePerson person=new GamePerson(); public abstract void createFace(); public abstract void createGender(); public abstract void createCloth(); public GamePerson getPerson(){ return person; } }
具体建造者类： public class PersonType1 extends PersonCreate { public void createFace() { person.setFace("瓜子脸"); } public void createGender() { person.setGender("美女"); } public void createCloth() { person.setCloth("洛丽塔"); } } 具体建造类： public class PersonType2 extends PersonCreate { public void createFace() { person.setFace("国字脸"); } public void createGender() { person.setGender("帅哥"); } public void createCloth() { person.setCloth("西装革履"); } } 指挥者类： public class GamePlayer { private PersonCreate pc; public void choseType(PersonCreate pc){ this.pc=pc; } public GamePerson create(){ pc.createCloth(); pc.createFace(); pc.createGender(); return pc.getPerson(); } } 测试类： public class Test { public static void main(String[] args) { PersonCreate pc=new PersonType1();
总复习题 复习参考资料： 1.GoF 设计模式 2.设计模式解析 3.易学设计模式 4.大话设计模式 5.深入浅出设计模式 以参考资料为主，模拟试题1-5中有些题答案在一些附加资料中 模拟试题1 一、选择题（分值20） 1. 设计模式一般用来解决什么样的问题( ) A.同一问题的不同表相 B不同问题的同一表相 C.不同问题的不同表相 D.以上都不是 2. 下列属于面向对象基本原则的是( ) A.继承 B.封装 C.里氏代换 D都不是 3. Open-Close原则的含义是一个软件实体( ) A.应当对扩展开放，对修改关闭. B.应当对修改开放，对扩展关闭 C.应当对继承开放，对修改关闭 D.以上都不对 4. 当我们想创建一个具体的对象而又不希望指定具体的类时，可以使用（）模式。 A.创建型 B.结构型 C行为型 D.以上都可以 5. 要依赖于抽象，不要依赖于具体。即针对接口编程，不要针对实现编程,是( )的表述 A. 开-闭原则 B. 接口隔离原则 C. 里氏代换原则 D. 依赖倒转原则 6. 依据设计模式思想,程序开发中应优先使用的是( )关系实现复用。 A, 委派 B.继承 C创建 D.以上都不对 7. 设计模式的两大主题是( ) A.系统的维护与开发 B 对象组合与类的继承 C.系统架构与系统开发 D.系统复用与系统扩展 8. 单体模式中,两个基本要点( )和单体类自己提供单例 A .构造函数私有 B.唯一实例 C.静态工厂方法 D.以上都不对 9. 下列模式中,属于行为模式的是( ) A.工厂模式 B观察者 C适配器以上都是 10. “不要和陌生人说话”是( )原则的通俗表述
设计模式心得体会 7月初的一个周末，准确的说应该是7月1号周六，在网上看到一本《大话设计模式》的书，而且看到很多很好的评论，于是乎，下载了电子书看看，一下子看了几章之后，对设计模式有了个了解，于是继续上网搜些其他资料，进一步了解设计模式。。。最终结论：设计模式是个好东西，具体怎么好，一两句话是无法概括的，也是从那天起，我就决定学习设计模式，于是就看《大话设计模式》，至七月十多号，大概看了一百多页后，感觉有点难，有点看不下去的感觉，于是上网找其他的好方法，无意间发现了李建忠老师的《c#设计模式纵横谈》系列讲座，微软的web cast课程，主要讲解gof的23个设计模式，每个一讲，加上一头一尾，共25讲，试听了一节课后，感觉很有用，于是就抽时间去边听课边看书，并在我的博客里写下笔记，依赖加深印象，二来可以督促我的进度。。。 三个月以来，总算把设计模式学完一遍了，原计划是两个月学完（一星期三个模式），由于。。。计划两个月学完实际花了三个月，感触多多，收获多多——对c#语言有了更进一步的认识，对oo的思想有了更全面的了解。。。 下一步在设计模式方面的计划：巩固并运用设计模式，巩固：把《大话设计模式》，《设计模式》，《设计模式——可
复用的面向对象基础》，《敏捷软件开发：原则、模式与实践》这些书再结合起来系统的看一看，当然还会去买一些我手头上没有的关于设计模式的书；运用：部门前几天也提倡用c#来改版vb程序，我想这是一个很好的平台，正好有机会把理论的东西在实际中应用，理论加实际——唯一的学习方法。。。 下面对各个模式再简单总结一下： 1、创建型模式： singleton：解决的是实例化对象的个数的问题，比如抽象工厂中的工厂、对象池等，除了singleton之外，其他创建型模式解决的都是 new 所带来的耦合关系。 abstract factory：创建一系列相互依赖对象，并能在运行时改变系列。 factory method：创建单个对象，在abstract factory 有使用到。 prototype：通过拷贝原型来创建新的对象。 factory method，abstract factory, builder都需要一个额外的工厂类来负责实例化“一边对象”，而prototype 则是通过原型（一个特殊的工厂类）来克隆“易变对象”。 如果遇到“易变类”，起初的设计通常从factory method 开始，当遇到更多的复杂变化时，再考虑重构为其他三种工
设计模式实验二 实验报告书 专业班级软件 0703 学号 3901070324 姓名吉亚云 指导老师刘伟 时间 2010年4月 24日 中南大学软件学院
实验二设计模式上机实验二 一、实验目的 使用PowerDesigner和任意一种面向对象编程语言实现几种常用的设计模式，加深对这些模式的理解，包括装饰模式、外观模式、代理模式、职责链模式、命令模式、迭代器模式、观察者模式、状态模式、策略模式和模板方法模式。 二、实验内容 使用PowerDesigner和任意一种面向对象编程语言实现装饰模式、外观模式、代理模式、职责链模式、命令模式、迭代器模式、观察者模式、状态模式、策略模式和模板方法模式，包括根据实例绘制相应的模式结构图、编写模式实现代码，运行并测试模式实例代码。 三、实验要求 1. 正确无误绘制装饰模式、外观模式、代理模式、职责链模式、命令模式、迭代器模式、观察者模式、状态模式、策略模式和模板方法模式的模式结构图； 2. 使用任意一种面向对象编程语言实现装饰模式、外观模式、代理模式、职责链模式、命令模式、迭代器模式、观察者模式、状态模式、策略模式和模板方法模式，代码运行正确无误。 四、实验步骤 1. 使用PowerDesigner绘制装饰模式结构图并用面向对象编程语言实现该模式； 2. 使用PowerDesigner绘制外观模式结构图并用面向对象编程语言实现该模式； 3. 使用PowerDesigner绘制代理模式结构图并用面向对象编程语言实现该模式； 4. 使用PowerDesigner绘制职责链模式结构图并用面向对象编程语言实现该模式； 5. 使用PowerDesigner绘制命令模式结构图并用面向对象编程语言实现该模式； 6. 使用PowerDesigner绘制迭代器模式结构图并用面向对象编程语言实现该模式； 7. 使用PowerDesigner绘制观察者模式结构图并用面向对象编程语言实现该模式； 8. 使用PowerDesigner绘制状态模式结构图并用面向对象编程语言实现该模式； 9. 使用PowerDesigner绘制策略模式结构图并用面向对象编程语言实现该模式； 10. 使用PowerDesigner绘制模板方法模式结构图并用面向对象编程语言实现该模式。 五、实验报告要求 1. 提供装饰模式结构图及实现代码； 2. 提供外观模式结构图及实现代码；
第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. 什么是设计模式？设计模式的目标是什么？
设计模式总结 一、创建型模式 简单工厂 简单工厂最大优点在于工厂类中包含了必要的逻辑判断（switch），根据客户端的选择条件动态实例化相关的类，对于客户端来说，去除了与具体产品的依赖。 工厂方法 工厂方法模式（Factory Method），定义一个用于创建对象的接口，让子类决定实例化哪一个类。工厂方法使一个类的实例化延迟到其子类。 工厂方法模式实现时，客户端要觉定实例化哪一个工厂来实现运算类，选择判断的问题还是存在的，也就是说，工厂方法把简单工厂的内部逻辑判断移到了客户端代码来进行。你想要加功能，本来是改工厂类的，而现在时修改客户端。 抽象工厂 抽象工程模式（Abstract Factory），提供一个创建一系列相关或相互依赖对象的接口，而无需制定它们具体的类。 原型模式 原型模式（Prototype）,用原型实例指定创建对象的种类，并且通过拷贝这些原型创建新的对象。 原型模式其实就是从一个对象再创建另外一个可定制的对象，而且不需要知道任何创建的细节。（拷贝对象的引用地址《浅表副本》）。.NET在System命名空间中提供了ICloneable接口（里面唯一的方法Clone()）,只要实现这个接口就可以完成原型模式。 建造者模式 建造者模式（Builder）,将一个复杂对象的构造过程与它的表示分离，使得同样的构造过程可以创建不同的表示。
如果使用建造者模式，那么用户就只需建造的类型就可以得到它们，而具体建造的过程和细节就不需要知道了。——抽象不应该依赖细节，细节应该依赖于抽象。建造者模式主要用于创建一些复杂的对象，这些对象内部构建间的建造顺序通常是稳定的，但对象内部的构建通常面临着复杂的变化。 单例模式 单例模式（Singleton），保证一个类仅有一个实例，并提供一个访问它的全局访问点。 二、行为型模式 观察者模式 观察者模式（Observer），定义了一种一对多的依赖关系，让多个观察者对象同时监听某一个主题对象。这个主题对象在状态发生改变时，会通知所有观察者对象，使它们能自动更新自己。 当一个对象的改变需要同时改变其他对象的时候，而且他不知道具体有多少对象有待改变，应该考虑使用观察者模式。观察者模式所做的工作其实就是在解除耦合，让耦合的双方都依赖于抽象，而不依赖于具体，从而使得各自的变化都不会影响另一边的变化。 模板方法模式 模板方法模式（TemplateMethod），定义一个操作中的算法的骨架，而将一些步骤延迟到子类中。模板方法使得子类可以不改变一个算法的结构可重复定义该算法的某些特定的步骤。 模板方法模式是通过把不变行为搬移到超类，去除子类中德重复代码来体现它的优势。模板方法模式就是提供了一个很好的代码复用平台。 状态模式 状态模式（State），当一个对象的内在状态发生改变时允许改变其行为，这个对象看起来像是改变了其类。
实验3创建型设计模式实验 实验学时： 2 每组人数： 1 实验类型： 3 (1 : 基础性 2： 综合性 3: 设计性 4 :研究性) 实验要求： 1 (1 : 必修 2： 选修 3: 其它) 实验类别： 3 (1 : 基础 2： 专业基础 3: 专业 4:其它) 、实验目的 1 ?熟练使用面向对象设计原则对系统进行重构； 2. 熟练使用 PowerDesigner 和 任意一种面向对象编程语言实现几种常见的创建型设计 模式，包括简单工厂模式、工厂方法模式、抽象工厂模式和单例模式， 理解每一种设计模式 的模式动机，掌握模式结构，学习如何使用代码实现这些模式。 、实验内容 1 ?在某图形库 API 中提供了多种矢量图模板，用户可以基于这些矢量图创建不同的显 示图形，图形库 设计人员设计的初始类图如下所示： _______ V Trian gle + in it () : void + setColor () : void + fill () : void + setSize () : void + display () : void 在该图形库中，每个图形类(如 Circle 、Triangle 等)的init()方法用于初始化所创建的 图形，setColor()方法用于给图形设置边框颜色，fill()方法用于给图形设置填充颜色，setSize() 方法用于设置图形的大小， display()方法用于显示图形。 客户类(Client)在使用该图形库时发现存在如下问题： ① 由于在创建窗口时每次只需要使用图形库中的一种图形，因此在更换图形时需要修 改客户类源代码; + ini t () :void + setColor () :void + fill () :void + setSize () :void + display () :void Circle Recta ngle
设计模式分为三种类型，共23种。 创建型模式：单例模式、抽象工厂模式、建造者模式、工厂模式、原型模式。 结构型模式：适配器模式、桥接模式、装饰模式、组合模式、外观模式、享元模式、代理模式。 行为型模式：模版方法模式、命令模式、迭代器模式、观察者模式、中介者模式、备忘录模式、解释器模式（Interpreter模式）、状态模式、策略模式、职责链模式(责任链模式)、访问者模式。 工厂模式（Factory） 意图 定义一个用于创建对象的接口，让子类决定实例化哪一个类。Factory Method 使一个类的实例化延迟到其子类。 适用性 ●当一个类不知道它所必须创建的对象的类的时候。 ●当一个类希望由它的子类来指定它所创建的对象的时候。 ●当类将创建对象的职责委托给多个帮助子类中的某一个，并且你希望将哪一个帮助子类是代理者这一 信息局部化的时候。 抽象工厂模式（Abstract Factory） 意图 提供一个创建一系列相关或相互依赖对象的接口，而无需指定它们具体的类。 适用性 ●一个系统要独立于它的产品的创建、组合和表示时。 ●一个系统要由多个产品系列中的一个来配置时。 ●当你要强调一系列相关的产品对象的设计以便进行联合使用时。 ●当你提供一个产品类库，而只想显示它们的接口而不是实现时。 建造者模式Builder 意图 将一个复杂对象的构建与它的表示分离，使得同样的构建过程可以创建不同的表示。 适用性 ●当创建复杂对象的算法应该独立于该对象的组成部分以及它们的装配方式时。 ●当构造过程必须允许被构造的对象有不同的表示时。 原型模式Prototype 意图 用原型实例指定创建对象的种类，并且通过拷贝这些原型创建新的对象。 适用性 ●当要实例化的类是在运行时刻指定时，例如，通过动态装载；或者 ●为了避免创建一个与产品类层次平行的工厂类层次时；或者 ●当一个类的实例只能有几个不同状态组合中的一种时。建立相应数目的原型并克隆它们可能比每次用 合适的状态手工实例化该类更方便一些。 单例模式Singleton 意图 保证一个类仅有一个实例，并提供一个访问它的全局访问点。 适用性 ●当类只能有一个实例而且客户可以从一个众所周知的访问点访问它时。 ●当这个唯一实例应该是通过子类化可扩展的，并且客户应该无需更改代码就能使用一个扩展的实例 时。 适配器模式Adapter
《JAVA设计模式》复习资料 一、单项选择题 1．设计模式起源于（） A、机械设计 B、建筑工程设计 D、工业电力化设计C、水利工程设计 2．“不要和陌生人说话”是（）原则的通俗表述。 B、里氏替换、接口隔离 C、依赖倒置 D、迪米特A3．目前常见的设计模式主要有（）种。、28、B23 A、、21 C32 D4．以下关于单一职责原则的叙述不正确的是（）。 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． C、将一个类的接口转换成客户希望的另外一个接口，使得原本由于接口不兼容而不能一起工作的那些类可以一起工作。 D、动态地给一个对象增加一些额外的职责。
实验一单例模式的应用 1 实验目的 1) 掌握单例模式（Singleton）的特点 2) 分析具体问题，使用单例模式进行设计。 2 实验内容和要求 很多应用项目都有配置文件，这些配置文件里面定义一些应用需要的参数数据。 通常客户端使用这个类是通过new一个AppConfig的实例来得到一个操作配置文件内容的对象。如果在系统运行中，有很多地方都需要使用配置文件的内容，系统中会同时存在多份配置文件的内容，这会严重浪费内存资源。 事实上，对于AppConfig类，在运行期间，只需要一个对象实例就够了。那么应该怎么实现呢？用C#控制台应用程序实现该单例模式。绘制该模式的UML 图。 3 实验代码 using System; using System.Collections.Generic; using System.Linq; using System.Text; using System.Threading.Tasks; namespace AppConfig { publicclass Singleton { privatestatic Singleton instance; private Singleton() {
} publicstatic Singleton GetInstance() { if (instance == null) { instance = new Singleton(); } return instance; } } class Program { staticvoid Main(string[] args) { Singleton singletonOne = Singleton.GetInstance(); Singleton singletonTwo = Singleton.GetInstance(); if (singletonOne.Equals(singletonTwo)) { Console.WriteLine("singletonOne 和 singletonTwo 代表的是同一个实例"); } else { Console.WriteLine("singletonOne 和 singletonTwo 代表的是不同实例"); } Console.ReadKey(); } } } 4 实验结果