免费智能真题库 > 历年试卷 > 信息系统监理师 > 2017年下半年 信息系统监理师 上午试卷 综合知识
  第33题      
  知识点:   基本概念   设计过程   设计模式
  关键词:   面向对象   设计模式   系统设计   对象        章/节:   软件与软件工程知识       

 
设计模式是面向对象的系统设计过程中反复出现的问题解决方案,其基本要素不包括( )。
 
 
  A.  模式类型
 
  B.  模式问题
 
  C.  解决方案
 
  D.  模式效果
 
 
 

 
  第35题    2017年上半年  
   64%
(34)不是面向对象技术的基本特征。对象实现了数据和操作的结合,使数据和操作(35)于对象的统一体中。
  第24题    2009年上半年  
   67%
在UML中,图是系统体系结构在某个侧面的表示,所有图在一起组成系统的完整视图。在UML各种图中,(23)是静态图,(24)是动态图。
  第34题    2013年上半年  
   44%
面向对象程序设计将描述事物的数据与(34)封装在一起,作为一个相互依存、不可分割的整体来处理。
   知识点讲解    
   · 基本概念    · 设计过程    · 设计模式
 
       基本概念
        面向对象方法包括面向对象的分析、面向对象的设计和面向对象的程序设计。下面首先介绍面向对象方法的一些基本概念。
               对象
               在计算机系统中,对象是指一组属性及这组属性上的专用操作的封装体。属性可以是一些数据,也可以是另一个对象。每个对象都有它自己的属性值,表示该对象的状态,用户只能看见对象封装界面上的信息,对象的内部实现对用户是隐蔽的。封装的目的是使对象的使用者和生产者分离,使对象的定义和实现分开。一个对象通常可由三部分组成,分别是对象名、属性和操作(方法)。
               类
               类是一组具有相同属性和相同操作的对象的集合。一个类中的每个对象都是这个类的一个实例(instance)。在分析和设计时,通常把注意力集中在类上,而不是具体的对象上。通常把一个类和这个类的所有对象称为类及对象或对象类。
               一个类通常可由三部分组成,分别是类名、属性和操作(方法)。每个类一般都有实例,没有实例的类是抽象类。抽象类不能被实例化,也就是说不能用new关键字去产生对象,抽象方法只需声明,而不需实现。抽象类的子类必须覆盖所有的抽象方法后才能被实例化,否则这个子类还是个抽象类。
               是否建立了丰富的类库是衡量一个面向对象程序设计语言成熟与否的重要标志之一。
               继承
               继承是在某个类的层次关联中不同的类共享属性和操作的一种机制。一个父类可以有多个子类,这些子类都是父类的特例。父类描述了这些子类的公共属性和操作,子类还可以定义它自己的属性和操作。一个子类只有唯一的父类,这种继承称为单一继承。一个子类有多个父类,可以从多个父类中继承特性,这种继承称为多重继承。对于两个类A和B,如果A类是B类的子类,则B类是A类的泛化。继承是面向对象方法区别于其他方法的一个核心思想。
               封装
               面向对象系统中的封装单位是对象,对象之间只能通过接口进行信息交流,外部不能对对象中的数据随意地进行访问,这就造成了对象内部数据结构的不可访问性,也使得数据被隐藏在对象中。封装的优点体现在以下三个方面。
               (1)好的封装能减少耦合。
               (2)类内部的实现可以自由改变。
               (3)一个类有更清楚的接口。
               消息
               消息是对象间通信的手段、一个对象通过向另一个对象发送消息来请求其服务。一个消息通常包括接收对象名、调用的操作名和适当的参数(如有必要)。消息只告诉接收对象需要完成什么操作,并不能指示接收者怎样完成操作。消息完全由接收者解释,接收者独立决定采用什么方法来完成所需的操作。
               多态性
               多态性是指同一个操作作用于不同的对象时可以有不同的解释,并产生不同的执行结果。与多态性密切相关的一个概念就是动态绑定。传统的程序设计语言把过程调用与目标代码的连接放在程序运行前进行,称为静态绑定。而动态绑定则是指把这种连接推迟到运行时才进行。在运行过程中,当一个对象发送消息请求服务时,要根据接收对象的具体情况将请求的操作与实现的方法连接,即动态绑定。
               构件
               构件(组件)是一个功能相对独立的具有可重用价值的软件单元。在面向对象方法中,一个构件由一组对象构成,包含了一些协作的类的集合,它们共同工作来提供一种系统功能。
               可重用性是指系统和(或)其组成部分能在其他系统中重复使用的程度。软件开发的全生命周期都有可重用的价值,包括项目的组织、软件需求、设计、文档、实现、测试方法和测试用例,都是可以被重复利用和借鉴的有效资源。可重用性体现在软件的各个层次,通用的、可复用性高的软件模块往往已经由操作系统或开发工具提供,如通用库、标准组件和标准模板库等,它们并不需要程序员重新开发。
 
       设计过程
        结构化设计的过程如下。
        (1)精化DFD。
        (2)确定DFD的信息流类型(变换流或事务流)。
        (3)根据流类型分别将变换流或事务流转换成程序结构图。
        (4)根据软件设计的原则对程序结构图做优化。
        (5)描述模块功能、接口及全局数据结构。
        (6)复查。
 
       设计模式
        “每一个模式描述了一个在我们周围不断重复发生的问题,以及该问题的解决方案的核心。这样,你就能一次又一次地使用该方案而不必做重复劳动”。设计模式的核心在于提供了相关问题的解决方案。
        设计模式一般有如下4个要素。
        (1)模式名称(pattern name)。模式名称应具有实际的含义,能反映模式的适用性和意图。
        (2)问题(problem)。描述了应该在何时使用模式,解释了设计问题和问题存在的前因后果。可能描述了特定的设计问题,如怎样用对象表示算法等;也可能描述了导致不灵活设计的类或对象结构。有时候,问题部分会包括使用模式必须满足的一系列先决条件。
        (3)解决方案(solution)。描述了设计的组成成分,它们之间的相互关系及各自的职责和协作方式。解决方案并不描述一个特定的具体的设计或实现,而是提供设计问题的抽象描述和怎样用一个具有一般意义的元素组合(类或对象组合)来解决这个问题。
        (4)效果(consequences)。描述了模式应用的效果及使用模式应权衡的问题。因为复用是面向对象设计的要素之一,所以模式效果包括它对系统的灵活性、扩充性或可移植性的影响,显式地列出这些效果对理解和评价这些模式很有帮助。
        设计模式确定了所包含的类和实例,它们的角色、协作方式以及职责分配。每一个设计模式都集中于一个特定的面向对象设计问题或设计要点,描述了什么时候使用它,在另一些设计约束条件下是否还能使用,以及使用的效果和如何取舍。按照设计模式的目的可以分为创建型、结构型和行为型三大类,如下表所示。
        
        设计模式分类
               创建型设计模式
               创建型模式与对象的创建有关,抽象了实例化过程,它们帮助一个系统独立于如何创建、组合和表示它的那些对象。一个类创建型模式使用继承改变被实例化的类,而一个对象创建型模式将实例化委托给另一个对象。
               创建型模式包括面向类和面向对象两种。Factory Method(工厂方法)定义一个用于创建对象的接口,让子类决定实例化哪一个类。Abstract Factory(抽象工厂)提供一个创建一系列相关或相互依赖对象的接口,而无须指定它们具体的类。Builder(生成器)将一个复杂对象的构建与它的表示分离,使得同样的构建过程可以创建不同的表示。Factory Method使一个类的实例化延迟到其子类。Prototype(原型)用原型实例指定创建对象的种类,并且通过复制这些原型创建新的对象。Singleton(单例)模式保证一个类仅有一个实例,并提供一个访问它的全局访问点。
               下面以抽象工厂模式和单例模式为例进行说明。
                      Abstract Factory(抽象工厂)
                      (1)意图。提供一个创建一系列相关或相互依赖对象的接口,而无须指定它们具体的类。
                      (2)结构。抽象工厂模式的结构如下图所示。
                      
                      抽象工厂模式结构图
                      其中:
                      .AbstractFactory声明一个创建抽象产品对象的操作接口。
                      .ConcreteFactory实现创建具体产品对象的操作。
                      .AbstractProduct为一类产品对象声明一个接口。
                      .ConcreteProduct定义一个将被相应的具体工厂创建的产品对象,实现AbstractProduct接口。
                      .Client仅使用由AbstractFactory和AbstractProduct类声明的接口。
                      (3)适用性。Abstract Factory模式适用于:
                      .一个系统要独立于它的产品的创建、组合和表示时。
                      .一个系统要由多个产品系列中的一个来配置时。
                      .当要强调一系列相关的产品对象的设计以便进行联合使用时。
                      .当提供一个产品类库,只想显示它们的接口而不是实现时。
                      Singleton(单例)
                      (1)意图。保证一个类仅有一个实例,并提供一个访问它的全局访问点。
                      (2)结构。单例模式的结构如下图所示。
                      
                      单例模式结构图
                      其中:Singleton指定一个Instance操作,允许客户访问它的唯一实例,Instance是一个类操作;可能负责创建它自己的唯一实例。
                      (3)适用性。Singleton模式适用于:
                      .当类只能有一个实例而且客户可以从一个众所周知的访问点访问它时。
                      .当这个唯一实例应该是通过子类化可扩展的,并且客户无须更改代码就能使用一个扩展的实例时。
               结构型设计模式
               结构型模式处理类或对象的组合,涉及如何组合类和对象以获得更大的结构。结构型类模式采用继承机制来组合接口或实现。一个简单的例子是采用多重继承方法将两个以上的类组合成一个类,结果这个类包含了所有父类的性质。这一模式尤其有助于多个独立开发的类库协同工作。其中一个例子是类形式的Adapter(适配器)模式。一般来说,适配器使得一个接口与其他接口兼容,从而给出了多个不同接口的统一抽象。为此,类Adapter对一个adaptee类进行私有继承。这样,适配器就可以用adaptee的接口表示它的接口。对象Adapter依赖于对象组合。
               下面以适配器模式和代理模式为例进行说明。
                      Adapter(适配器)模式
                      (1)意图。将一个类的接口转换成客户希望的另外一个接口。Adapter模式使得原本由于接口不兼容而不能一起工作的那些类可以一起工作。
                      
                      类适配器结构图
                      (2)结构。类适配器使用多重继承对一个接口与另一个接口进行匹配,其结构如上图所示。对象适配器依赖于对象组合,其结构如下图所示。
                      
                      对象适配器结构图
                      其中:
                      .Target定义Client使用的与特定领域相关的接口。
                      .Client与符合Target接口的对象协同。
                      .Adaptee定义一个已经存在的接口,这个接口需要适配。
                      .Adapter对Adaptee的接口与Target接口进行适配。
                      (3)适用性。Adapter模式适用于:
                      .想使用一个已经存在的类,而它的接口不符合要求。
                      .想创建一个可以服用的类,该类可以与其他不相关的类或不可预见的类(即那些接口可能不一定兼容的类)协同工作。
                      .(仅适用于对象Adapter)想使用一个已经存在的子类,但是不可能对每一个都进行子类化以匹配它们的接口。对象适配器可以适配它的父类接口。
                      Proxy(代理)模式
                      (1)意图。为其他对象提供一种代理以控制对这个对象的访问。
                      (2)结构。代理模式的结构如下图所示。
                      
                      代理模式结构图
                      其中:
                      .Proxy保存一个引用使得代理可以访问实体;提供一个与Subject的接口相同的接口,使代理可以用来代替实体;控制对实体的存取,并可能负责创建和删除它;其他功能依赖于代理的类型:Remote Proxy负责对请求及其参数进行编码,并向不同地址空间中的实体发送已编码的请求;Virtual Proxy可以缓存实体的附加信息,以便延迟对它的访问;Protection Proxy检查调用者是否具有实现一个请求所必需的访问权限。
                      .Subject定义RealSubject和Proxy的共用接口,这样就在任何使用RealSubject的地方都可以使用Proxy。
                      .RealSubject定义Proxy所代表的实体。
                      (3)适用性。Proxy模式适用于在需要比较通用和复杂的对象指针代替简单的指针的时候,常见情况有:
                      .远程代理(Remote Proxy)为一个对象在不同地址空间提供局部代表。
                      .虚代理(Virtual Proxy)根据需要创建开销很大的对象。
                      .保护代理(Protection Proxy)控制对原始对象的访问,用于对象应该有不同的访问权限的时候。
                      .智能引用(Smart Reference)取代了简单的指针,它在访问对象时执行一些附加操作。典型用途包括:对指向实际对象的引用计数,这样当该对象没有引用时,可以被自动释放;当第一次引用一个持久对象时,将它装入内存;在访问一个实际对象前,检查是否已经锁定了它,以确保其他对象不能改变它。
                      结构型对象模式不是对接口和实现进行组合,而是描述了如何对一些对象进行组合,从而实现新功能的一些方法。因为可以在运行时刻改变对象组合关系,所以对象组合方式具有更大的灵活性,而这种机制用静态类组合是不可能实现的。
                      Composite(组合)模式将对象组合成树型结构以表示“部分—整体”的层次结构,使得用户对单个对象和组合对象的使用具有一致性。它描述了如何构造一个类层次式结构,这一结构由两种类型的对象所对应的类构成。其中的组合对象使得用户可以组合基元对象以及其他的组合对象,从而形成任意复杂的结构。proxy(代理)模式为其他对象提供一种代理以控制对这个对象的访问,其中,proxy对象作为其他对象的一个方便的替代或占位符。它的使用可以有多种形式,例如可以在局部空间中代表一个远程地址空间中的对象,也可以表示一个要求被加载的较大的对象,还可以用来保护对敏感对象的访问。proxy模式还提供了对对象的一些特有性质的一定程度上的间接访问,从而可以限制、增强或修改这些性质。Flyweight(享元)模式运用共享技术有效地支持大量细粒度的对象,为了共享对象定义了一个结构。至少有两个原因要求对象共享:效率和一致性。Flyweight的对象共享机制主要强调对象的空间效率。使用很多对象的应用必须考虑每一个对象的开销。使用对象共享而不是进行对象复制,可以节省大量的空间资源。但是,仅当这些对象没有定义与上下文相关的状态时,它们才可以被共享。Flyweight的对象没有这样的状态。任何执行任务时需要的其他一些信息仅当需要时才传递过去。由于不存在与上下文相关的状态,因此Flyweight对象可以被自由地共享。
                      Facade(外观)模式为子系统中的一组接口提供一个一致的界面,定义了一个高层接口,这个接口使得这一子系统更加容易使用。该模式描述了如何用单个对象表示整个子系统。模式中的facade用来表示一组对象,facade的职责是将消息转发给它所表示的对象。Bridge(桥接)模式将对象的抽象和其实现分离,从而可以独立地改变它们。
                      Decorator(装饰)模式描述了如何动态地为对象添加一些额外的职责。该模式采用递归方式组合对象,从而允许添加任意多的对象职责。例如,一个包含用户界面组件的Decorator对象可以将边框或阴影这样的装饰添加到该组件中,或者它可以将窗口滚动和缩放这样的功能添加到组件中。可以将一个Decorator对象嵌套在另外一个对象中,就可以很简单地增加两个装饰,添加其他的装饰也是如此。因此,每个Decorator对象必须与其组件的接口兼容并且保证将消息传递给它。Decorator模式在转发一条信息之前或之后都可以完成它的工作(例如绘制组件的边框)。许多结构型模式在某种程度上具有相关性。
               行为型设计模式
               行为模式对类或对象怎样交互和怎样分配职责进行描述,涉及算法和对象间职责的分配。行为模式不仅描述对象或类的模式,还描述它们之间的通信模式。这些模式刻画了在运行时难以跟踪的复杂的控制流。它们将用户的注意力从控制流转移到对象间的联系方式上来。
               行为类模式使用继承机制在类间分派行为。本章包括两个这样的模式,其中Template Method(模板方法)较为简单和常用。Template Method是一个算法的抽象定义,它逐步地定义该算法,每一步调用一个抽象操作或一个原语操作,子类定义抽象操作以具体实现该算法。另一种行为类模式是Interpreter(解释器)模式,它将一个文法表示为一个类层次,并实现一个解释器作为这些类的实例上的一个操作。
               行为对象模式使用对象复合而不是继承。一些行为对象模式描述了一组对等的对象怎样相互协作以完成其中任一个对象都无法单独完成的任务。这里一个重要的问题是对等的对象。
               如何互相了解对方。对等对象可以保持显式的对对方的引用,但那会增加它们的耦合度。在极端情况下,每一个对象都要了解所有其他的对象。Mediator(中介者)模式用一个中介对象来封装一系列的对象交互,在对等对象间引入一个mediator对象以避免这种情况的出现。mediator提供了松耦合所需的间接性。
               Chain of Responsibility(责任链)使多个对象都有机会处理请求,从而避免请求的发送者和接收者之间的耦合关系,将这些对象连成一条链,并沿着这条链传递该请求,直到有一个对象处理它为止。Chain of Responsibility模式提供更松的耦合,让用户通过一条候选对象链隐式地向一个对象发送请求。根据运行时刻情况任一候选者都可以响应相应的请求。候选者的数目是任意的,可以在运行时刻决定哪些候选者参与到链中。
               Observer(观察者)模式定义对象间的一种一对多的依赖关系,当一个对象的状态发生改变时,所有依赖于它的对象都得到通知并被自动更新。典型的Observer的例子是Smalltalk中的模型/视图/控制器,其中一旦模型的状态发生变化,模型的所有视图都会得到通知。
               其他的行为对象模式常将行为封装在一个对象中并将请求指派给它。Strategy(策略)模式将算法封装在对象中,这样可以方便地指定和改变一个对象所使用的算法。Command(命令)模式将一个请求封装为一个对象,从而使得可以用不同的请求对客户进行参数化;对请求排队或记录请求日志,以及支持可撤销的操作。Memento(备忘录)模式在不破坏封装性的前提下,捕获一个对象的内部状态,并在该对象之外保存这个状态,以便在以后可将该对象恢复到原先保存的状态。State(状态)模式封装一个对象的状态,使得对象在其内部状态改变时可改变它的行为,对象看起来似乎修改了它的类。Visitor(访问者)模式表示一个作用于某对象结构中的各元素的操作,使得在不改变各元素的类的前提下定义作用于这些元素的新操作。Visitor模式封装分布于多个类之间的行为。Iterator(迭代器)模式提供一种方法顺序访问一个聚合对象中的各个元素,且不需要暴露该对象的内部表示。Iterator模式抽象了访问和遍历一个集合中的对象的方式。
               下面以中介者模式和观察者模式为例进行说明。
                      Mediator(中介者)
                      (1)意图。用一个中介对象来封装一系列的对象交互。中介者使各对象不需要显式地相互引用,从而使其耦合松散,而且可以独立地改变它们之间的交互。
                      (2)结构。中介者模式的结构图如下图所示。
                      
                      中介者模式结构图
                      其中:
                      .Mediator(中介者)定义一个接口用于各同事(Colleague)对象通信。
                      .ConcreteMediator(具体中介者)通过协调各同事对象实现协作行为;了解并维护它的各个同事。
                      .Colleague class(同事类)知道它的中介者对象;每一个同事类对象在需要与其他同事通信的时候与它的中介者通信。
                      (3)适用性。Mediator模式适用于:
                      .一组对象以定义良好但是复杂的方式进行通信,产生的相互依赖关系结构混乱且难以理解。
                      .一个对象引用其他很多对象并且直接与这些对象通信,导致难以复用该对象。
                      .想定制一个分布在多个类中的行为,而又不想生成太多的子类。
                      Observer(观察者)
                      (1)意图。定义对象间的一种一对多的依赖关系,当一个对象的状态发生改变时,所有依赖于它的对象都得到通知并被自动更新。
                      (2)结构。观察者模式的结构图如下图所示。
                      
                      观察者模式结构图
                      其中:
                      .Subject(目标)知道它的观察者,可以有任意多个观察者观察同一个目标;提供注册和删除观察者对象的接口。
                      .Observer(观察者)为那些在目标发生改变时需获得通知的对象定义一个更新接口。
                      .ConcreteSubject(具体目标)将有关状态存入各ConcreteObserver对象;当它的状态发生改变时,向它的各个观察者发出通知。
                      .ConcreteObserver(具体观察者)维护一个指向ConcreteSubject对象的引用;存储有关状态,这些状态应与目标的状态保持一致;实现Observer的更新接口,以使自身状态与目标的状态保持一致。
                      (3)适用性。Observer模式适用于:
                      .当一个抽象模型有两个方面,其中一个方面依赖于另一个方面,将这两者封装在独立的对象中以使它们可以各自独立地改变和复用。
                      .当对一个对象的改变需要同时改变其他对象,而不知道具体有多少对象有待改变时。
                      .当一个对象必须通知其他对象,而它又不能假定其他对象是谁,即不希望这些对象是紧耦合的。
   题号导航      2017年下半年 信息系统监理师 上午试卷 综合知识   本试卷我的完整做题情况  
1 /
2 /
3 /
4 /
5 /
6 /
7 /
8 /
9 /
10 /
11 /
12 /
13 /
14 /
15 /
 
16 /
17 /
18 /
19 /
20 /
21 /
22 /
23 /
24 /
25 /
26 /
27 /
28 /
29 /
30 /
 
31 /
32 /
33 /
34 /
35 /
36 /
37 /
38 /
39 /
40 /
41 /
42 /
43 /
44 /
45 /
 
46 /
47 /
48 /
49 /
50 /
51 /
52 /
53 /
54 /
55 /
56 /
57 /
58 /
59 /
60 /
 
61 /
62 /
63 /
64 /
65 /
66 /
67 /
68 /
69 /
70 /
71 /
72 /
73 /
74 /
75 /
 
第33题    在手机中做本题