免费智能真题库 > 历年试卷 > 程序员 > 2017年上半年 程序员 上午试卷 综合知识
  第46题      
  知识点：   继承   结构型设计模式   类和对象   设计模式
  关键词：   对象   继承   接口   模式描述   设计模式        章/节：   系统分析和设计基础知识       

 
结构型设计模式涉及如何组合类和对象以获得更大的结构，分为结构型类模式和结构型对象模式。其中，结构型类模式采用继承机制来组合接口或实现，而结构型对象模式描述了如何对一些对象进行组合，从而实现新功能的一些方法。以下（ ）模式是结构型对象模式。
 
 
  A.  中介者 (Mediator)
 
  B.  构建器（Builder）
 
  C.  解释器（Interpreter）
 
  D.  组合（Composite）
 
 
 

 
  第46题    2013年上半年  
   41%
在统一建模语言（UML)中，(45)展现了一组对象以及它们之间的关系，给出了系统的静态设计视图或静态进程视图，描述了（46)中所建立..
  第46题    2021年下半年  
   59%
进行面向对象系统分析时，必须完成的任务中不包括()。
  第45题    2011年上半年  
   52%
在统一建模语言（UML)中，(45)用于描述系统与外部系统及用户之间的交互。
   知识点讲解    
   · 继承    · 结构型设计模式    · 类和对象    · 设计模式
 
       继承
        C++最重要的性能之一是代码重用。但是，为了具有可进化性，我们应当能够做比复制代码更多的工作。在C的方法中，这个问题未能得到很好的解决。而用C++，可以用类的方法解决，通过创建新类重用代码，而不是从头创建它们。这样，就可以使用其他人已经创建并调试过的类。创建一个新类作为一个已存在类的类型，采取这个已存在类的形式，对它增加代码，但不修改它。这个有趣的活动被称为继承，其中大量的工作由编译器完成。继承是面向对象程序设计的基石。
        继承的一般形式如下：
        
        访问权限是访问控制说明符，它可以是public、private或protected。派生类与基类是有一定联系的，基类描述一个事物的一般特征，而派生类有比基类更丰富的属性和行为。如果需要，派生类可以从多个基类继承，也就是多重继承。通过继承，派生类自动得到了除基类私有成员以外的其他所有数据成员和成员函数，在派生类中可以直接访问，从而实现了代码的复用。派生类对象生成时，要调用构造函数进行初始化。编译器的调用过程是先调用基类的构造函数，对派生类中的基类数据进行初始化，然后再调用派生类自己的构造函数，对派生类的数据进行初始化工作。当然，在派生类中也可以更改基类的数据，只要它有访问权限。每个派生类只需要编写与基类行为不同或扩展的方面。
        例如：A是基类，B是A的派生类，那么B将继承A的数据和函数。代码如下：
        
        这个简单的示例程序也说明了：C++的"继承"特性可以大大提高程序的可复用性。
 
       结构型设计模式
        结构型模式处理类或对象的组合，涉及如何组合类和对象以获得更大的结构。结构型类模式采用继承机制来组合接口或实现。一个简单的例子是采用多重继承方法将两个以上的类组合成一个类，结果这个类包含了所有父类的性质。这一模式尤其有助于多个独立开发的类库协同工作。其中一个例子是类形式的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模式在转发一条信息之前或之后都可以完成它的工作（例如绘制组件的边框）。许多结构型模式在某种程度上具有相关性。
 
       类和对象
        1）类的概念
        类是数据以及用于操纵该数据的方法（函数）的集合，是逻辑上相关函数与数据的封装。它是对所要处理问题的抽象描述，它把数据（事物的属性）和函数（事物的行为／操作）封装为一个整体。
        2）类的定义格式
        类的定义格式如下：
        
        其中，private、 public、 protected称为访问权限控制关键字，其作用是限制"可见性"。在类的定义中，以上3种关键字出现的次数和先后次序都没有限制，默认被认为是private。这3种关键字对应的访问可见性如下。
        .private：私有成员，只能在成员函数内访问。
        .public：公有成员，可以在对象的外部访问。
        .protected：保护成员，只能由对象内部或其派生类对象访问。
        面向对象的思想是对对象的属性（成员变量）进行操作，应该通过对象的方法（成员函数）来进行，对象的方法是对象和外部的接口。将类的成员变量声明为private，能保证对该成员的操作都是通过类的方法来进行的。这样可以避免出错（如对成员变量不恰当地赋值），也便于修改程序。在修改类的定义时，只要修改类的成员函数就可以了，不需要修改使用该类成员的代码。如果某些成员函数只被其他成员函数调用，不作为对象的界面，那么也可以将它声明为private。
        成员函数定义通常在类的说明之后进行，其格式如下：
        
        其中，运算符"：："称为作用域解析运算符，它指出该函数是属于哪一个类的成员函数。当然也可以在类的定义中直接定义函数。
        3）对象
        对象即类的实例（Instance）。
        创建类的对象可以有两种常用方法。
        （1）第一种是直接定义类的对象。如CGoodsCar这个定义创建了CGoods类的一个对象Car，同时为它分配了属于它自己的存储块，用来存放数据和对这些数据实施操作的成员函数（代码）。与变量定义一样，一个对象只在定义它的域中有效。第一种方法通过"对象名．成员名"方式访问对象成员。
        （2）第二种是采用动态创建类的对象的方法，当然变量也同样可动态创建。所谓动态，是指在程序运行时建立对象。而第一种方法是在编译时（程序运行前）建立。第二种方法通过对象指针访问对象成员。
 
       设计模式
        “每一个模式描述了一个在我们周围不断重复发生的问题，以及该问题的解决方案的核心。这样，你就能一次又一次地使用该方案而不必做重复劳动”。设计模式的核心在于提供了相关问题的解决方案。
        设计模式一般有如下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 /
 
第46题    在手机中做本题