7.4 Modularity A key point in Secti

7.4 Modularity
A key point in Section 7.2 is that to modify software one must understand the program or at least the pertinent parts of the program. Gaining such an understanding is often difficult enough in the case of small programs and would be close to impossible when dealing with large software systems if it were not for modularity— that is, the division of software into manageable units, generically called modules, each of which deals with only a part of the software’s overall responsibility.

Modular Implementation Modules come in a variety of forms. We have already seen (Chapters 5 and 6), that in the context of the imperative paradigm, modules appear as procedures. In contrast, the object-oriented paradigm uses objects as the basic modular constituents. These distinctions are important because they determine the underlying goal during the initial software design process. Is the goal to represent the overall task as individual, manageable processes or to identify the objects in the system and understand how they interact?

To illustrate, let us consider how the process of developing a simple modular program to simulate a tennis game might progress in the imperative and the object-oriented paradigms. In the imperative paradigm we begin by considering the actions that must take place. Because each volley begins with a player serving the ball, we might start by considering a procedure named Serve that (based on the player’s characteristics and perhaps a bit of probability) would compute the initial speed and direction of the ball. Next we would need to determine the path of the ball. (Will it hit the net? Where will it bounce?) We might plan on placing these computations in another procedure named Computer Path. The next step might be to determine if the other player is able to return the ball, and if so we must compute the ball’s new speed and direction. We might plan on placing these computations in a procedure named Return.

Continuing in this fashion, we might arrive at the modular structure depicted by the structure chart shown in Figure 7.3, in which procedures are represented by rectangles and procedure dependencies (implemented by procedure calls) are represented by arrows. In particular, the chart indicates that the entire game is overseen by a procedure named Control Game, and to perform its task, Control Game calls on the services of the procedures Serve, Return, Computer Path, and Update Score.

Note that the structure chart does not indicate how each procedure is to perform its task. Rather, it merely identifies the procedures and indicates the dependencies among the procedures. In reality, the procedure Control Game might perform its task by first calling the Serve procedure, then repeatedly calling on the procedures Computer Path and Return until one reports a miss, and finally calling on the services of Update Score before repeating the whole process by again calling on Serve. At this stage we have obtained only a very simplistic outline of the desired program, but our point has already been made. In accordance with the imperative paradigm, we have been designing the program by considering the activities that must be performed and are therefore obtaining a design in which the modules are procedures.

Let us now reconsider the program’s design—this time in the context of the object-oriented paradigm. Our first thought might be that there are two players that we should represent by two objects: Player A and Player B. These objects will have the same functionality but different characteristics. (Both should be able to serve and return volleys but may do so with different skill and strength.) Thus ,these objects will be instances of the same class. (Recall that in Chapter 6 we introduced the concept of a class: a template that defines the procedures (called methods) and attributes (called instance variables) that are to be associated with each object.) This class, which we will call Player Class, will contain the methods, serve and return, that simulate the corresponding actions of the player. It will also contain attributes (such as skill and endurance) whose values reflect the player’s characteristics Our design so far is represented by the diagram in Figure 7.4. There we see that Player A and Player B are instances of the class Player Class and that this class contains the attributes skill and endurance as well as the methods serve and return Volley. (Note that in Figure 7.4 we have underlined the names of objects to distinguish them from names of classes.)

Next we need an object to play the role of the official who determines whether the actions performed by the players are legal. For example, did the serve clear the net and land in the appropriate area of the court? For this purpose we might establish an object called Judge that contains the methods evaluate Serve and evaluate Return. If the Judge object determines a serve or return to be acceptable, play continues. Otherwise, the Judge sends a message to another object named Score to record the results accordingly.

At this point the design for our tennis program consists of four objects: Player A, Player B, Judge, and Score. To clarify our design, consider the sequences of events that may occur during a volley as depicted in Figure 7.5 where we have represented the objects involved as rectangles. The figure is intended to present the communication between these objects as the result of calling the serve method within the object Player A. Events appear chronologically as we move down the figure. As depicted by the first horizontal arrow, Player A reports its serve to the object Judge by calling the method evaluate Serve. The Judge then determines that the serve is good and asks Player B to return it by calling Player B’s return Volley method. The volley terminates when the Judge determines that Player A erred and asks the object Score to record the results.

As in the case of our imperative example, our object-oriented program is very simplistic at this stage. However, we have progressed enough to see how the object-oriented paradigm leads to a modular design in which fundamental components are objects.

結果 (中文) 1:

7.4模块化
7.2节中的一个关键点是修改软件，必须了解程序或至少是相关的程序部分。获得这样的理解往往难以足够的小程序的情况下，几乎是不可能的处理，大型软件系统时，如果不是模块化，也就是说，软件的划分成可管理的单位，一般称作模块，其中每个处理软件的整体责任的仅一部分。

模块化实施各种形式的模块。我们已经看到了（第5和第6章），即必须范例的情况下，模块将显示为程序。与此相反，在面向对象的范例使用对象作为基本的模块化成分。这些区别是很重要的，因为他们在最初的软件设计过程中确定的基本目标。的目标是代表整体的任务是单独的，可管理的过程或识别系统中的对象，并了解它们如何相互作用的？

来说明，让我们考虑如何开发一个简单的模块化程序的过程中，模拟网球比赛的进程可能会在必要的和面向对象的范例。在必要的范例中，我们首先考虑必须采取的行动。因为每个凌空开始与玩家服务球，我们可能会开始考虑一个程序命名服务（根据球员的特点，或许还有点儿概率）计算初始速度和方向的球。接下来，我们需要确定球的路径。 （打的净？会反弹呢？），我们打算将这些计算在另一个名为“计算机路径的过程。下一个步骤可能会对确定，如果是其他玩家能够返回球，如果是这样，我们必须计算球的新的速度和方向。我们计划将这些计算的程序命名返回。

继续以这种方式，我们可能到达在模块化结构如图7.3中所示的结构图所示，在其中的程序表示的矩形和程序的依赖关系（由过程调用实现）的箭头表示的。特别是，监督整个游戏的程序的控制游戏，并执行其任务，图表显示，控制游戏要求的服务的程序，服务，收益，计算机路径，并更新得分。

注意，结构图，并不表示每个程序是如何执行其任务。相反，它仅仅识别的程序和表示的程序之间的依赖关系。在现实中，过程控制游戏可能会执行其任务通过先调用发球程序，然后反复调用的程序的计算机的路径，并返回，直到一个报告小姐，终于更新得分的服务，然后重复整个过程的发球局再次呼吁呼吁。在这个阶段，我们已取得所需的程序只是一个非常简单的轮廓，但已经取得了我们的观点。在按照与势在必行范式，我们已经设计程序通过考虑到必须执行的活动，因此，获取模块的一种设计，其中的程序。

现在让我们重新考虑该计划的设计，这一次的背景下，面向对象范型。我们首先想到的可能是有两名球员要代表两个对象：玩家A和玩家B。这些对象将具有相同的功能，但不同的特性。 （都应该是能够发球和截击，但具有不同技能和力量可以这样做。），因此，这些对象是同一个类的实例。 （记得，在第6章中，我们介绍了一类的概念：将包含一个模板，定义的程序（称为方法）和属性（被称为实例变量），要与每个对象相关联）。这个类，我们将调用播放器类，方法，服务和返回，模拟相应的播放器的动作。它也将包含属性（如技巧和耐力），其值反映了球员的特点，我们的设计图7.4图中表示。我们看到该玩家A和玩家B之类的播放器类的实例，这个类包含的属性技巧和耐力的方法以及发球和凌空。 （请注意，在图7中。4我们所强调的对象的名称来区分它们的类名。）

接下来我们需要一个对象发挥作用的正式决定是否受到了玩家的操作是合法的。例如，服务清除净在适当的区域法院和土地吗？为此，我们建立一个对​​象调用的判断，包含评估方法和评估服务回报。如果法官对象确定一个发球或接是可以接受的，比赛继续。否则，判断发送一个消息给另一个目的名为得分记录相应的结果。

在这一点上，我们的网球项目的设计由四个对象：玩家，玩家B，法官和得分。澄清我们的设计，考虑可能发生的事件在我们代表所涉及的对象为矩形图7.5所示的一个凌空抽射的序列。图旨在介绍这些对象之间的通信对象内的球员的发球方法调用的结果。事件出现的时间顺序，我们向下移动的身影。所描述的第一个水平箭头，玩家报告的发球局，以通​​过调用该方法评估服务对象的法官。法官决定，发球好，并要求玩家B返回它通过调用玩家B的回报凌空抽射方法。的凌空抽射结束时，法官决定，一个错误的对象得分，并要求记录结果的球员。

的情况下，我们必须例子，在这个阶段，我们的面向对象的程序是非常简单的。但是，我们有足够的进展怎么看的面向对象范型，导致了模块化设计的基本组成部分的对象。

結果 (中文) 2:

7.4模块化
关键点，7.2部分是修改软件必须理解程序或者至少是相关程序的一部分。获得这种理解往往很难在小程序，是不可能的在处理大型软件系统如果没有模块化，软件成易于管理的单元划分，一般称为模块，每个处理只有一部分软件的整体责任。

模块实现模块来在各种形式。我们已经看到（章节5和6），在这样的形势下，必须范式，模块显示程序。与此相反，面向对象的范例使用对象为基本模块组成。这些区别是重要的，因为他们确定的基本目标，在最初的软件设计过程。目标是代表整体任务作为个人，管理过程，或识别物体的系统和了解它们如何相互作用？

说明，让我们考虑如何发展过程中一个简单的模块化程序模拟网球游戏发展的当务之急和面向对象的范式。在必要的范例，我们首先考虑的行动，必须发生。因为每一球由一个球员发球开始，我们可以开始考虑一个程序命名为（对球员的特点和也许一点的概率）计算的初始速度和球的方向。下一步我们需要确定球的路径。（将它击中净？它会在哪里拍？）我们计划把这些计算在另一个程序命名计算机路径。下一步是确定是否其他球员能够返回球，如果我们要计算球的速度和方向。我们计划把这些计算程序的命名返回。

继续以这种方式，我们可以得出模块化结构描述的结构图如图7.3所示，在这种程序是由矩形和程序依赖（执行的过程调用）由箭头表示。特别是，图表显示，整个游戏都是由一个程序命名控制游戏，并执行其任务，控制游戏调用的服务的服务，回报，计算机的路径，并更新评分。

注意结构图并没有显示每个程序是执行任务。相反，它只是确定程序和显示之间的相依程序。在现实中，程序控制的游戏可能会完成其任务的第一个电话服务程序，然后反复呼吁程序路径和返回到报告小姐，最后呼吁服务更新评分重复之前的整个过程，再次呼吁服务。在这个阶段，我们获得一个非常简单的概述所需的计划，但我们已经取得。依照命令模式，我们已设计程序考虑的必须完成的活动，因此获得的设计中的模块程序。

现在让我们重新考虑计划的design-this时间范围内的面向对象的范例。我们可能首先想到的是有一个球员，我们应该代表的物体：球员和球员的B这些对象将具有相同的功能，但不同的特点。（两者都能服务和回报齐射但是这么做可能具有不同的技能和实力。）因此，这些对象将同一类的实例。（记得，在6章，我们介绍的概念类：模板定义的程序（称为方法）和属性（称为实例变量），是与每个对象。）这类，我们会打电话给玩家等级，将包含方法，服务和回报，模拟相应的行动的球员。它也将包含属性（如技能和耐力）其值反映球员的特点，我们的设计到目前为止是由图7.4。我们看到，玩家和玩家乙类的实例的球员类，这个类包含的属性技能和耐力以及方法和回击。（注意，在图7。4我们强调的对象的名称区分他们的类名称。）

接下来我们需要一个对象发挥作用的官员决定是否进行行动的球员是合法的。例如，没有明确的服务网络和土地在适当区域法院？为此，我们可以建立一个对象为法官，包含评估方法和评估回报。如果法官对象确定发球或回是可以接受的，游戏继续。否则，法官将消息发送到另一个对象命名分数记录的结果，因此。

就此为我们设计的网球计划由四个对象：玩家，乙，法官，和评分。澄清我们的设计，考虑了序列的事件可能发生在一个凌空如图7.5所示，我们代表的参与对象为矩形。这个数字是目前通信之间的这些对象的方法调用的结果，服务对象范围内的玩家事件的出现顺序为我们向下移动人物。所描述的第一水平箭头，玩家报告其服务对象判断通过调用该方法评估服务。法官决定，服务好，问乙返回调用播放器的回击方法。凌空终止时，法官决定，球员犯错并要求对象的评分结果记录。

如同我们势在必行的例子，我们的面向对象的程序是非常简单的在这个阶段。然而，我们有足够的进展，看看如何面向对象的范式导致模块化设计的基本组成部分是对象。

結果 (中文) 3:

7.4 模块化
7.2 节中的关键点是若要修改软件之一必须了解该程序或至少该程序的相关部分。获得这种理解是往往很困难，在小程序的情况下，将会几乎不可能的如果不是模块化处理大型软件系统时 — — 即，软件划分为易于管理的单位，笼统地称为模块，每个处理仅软件的总体责任的一部分。

模块执行模块来以各种各样的形式。我们已经看到 （第章 5 和 6），必须范式的上下文，在模块显示作为程序。相比之下，面向对象的范例使用对象作为基本模块化成分。这些区别是重要的因为他们在初始软件设计过程中确定的根本目标。是以个别的、 易于管理的流程作为代表的总体任务或在识别系统中的对象并了解它们是如何交互的目标吗？

为了举例说明，让我们考虑如何开发一个简单的模块化程序来模拟一个网球游戏的过程可能进展必须和面向对象的范例。在我们开始考虑必须采取的行动的必要范式发生。因为每个凌空以发球，玩家开始我们可能会先考虑一个名为服务过程 （基于玩家的特点和也许有点概率），将计算的初始速度和球的方向。下一步我们将需要确定球的路径。（将它击中网吗？凡将它反弹?)我们可能计划将这些计算放在另一个名为计算机路径的过程中。下一步可能是确定其他玩家是否能够返回球，以及如果是这样我们必须计算球的新速度和方向。我们可能计划将这些计算放在名为返回的过程中。

继续以这种方式，我们可能会得出图 7.3，所示的结构图表所描绘的模块化结构在哪个程序由矩形和过程 （由过程调用实现） 的依赖项都由箭头表示。尤其是，该图表指示整个游戏由一个名为控制游戏，过程监督和执行其任务，控制游戏调用的服务程序的服务，回报、 计算机路径和更新分数。

请注意结构图表并不表示每个过程是如何执行其任务。相反，它只是用于标识程序和指示程序之间的依赖关系。在现实中，控制游戏过程可能通过首先调用服务过程，然后反复调用程序，计算机路径并返回上一个报告小姐，直到执行其任务和最后调用的服务更新分数之前通过再次调用在发球上重复整个过程。在这一阶段我们所得的所需的程序，只有非常简单的大纲，但已经取得我们点。根据的当务之急的范式，我们一直在设计程序所考虑的活动，必须执行，并因此获得了一个模块在程序的设计。

让我们现在重新考虑该程序的设计 — — 这次是在面向对象的范例的上下文。我们首先想到可能会有我们应该代表的两个对象的两个球员： 玩家 A 和玩家 B。这些对象将具有相同的功能，但不同的特点。（两者应该能够为服务和返回齐射，但可能这样做具有不同技能和强度）。因此，这些对象将是同一类的实例。(记得第 6 章中，我们介绍一类的概念：一个定义的过程 （称为方法） 模板和属性 （称为的实例变量），并将与每个对象相关联。）此类中，我们将调用播放器类，将包含方法、 服务和返回，能模拟出的相应行动的玩家。它还将包含的属性 （如技能和耐力） 其值反映玩家的特征到目前为止我们的设计由图 7.4 中的关系图。我们会看到类播放器类的实例是玩家 A 和玩家 B 和此类包含的属性技巧和耐力，以及方法为服务和返回截击。（注意，在图 7 中。4 我们强调的对象来区分它们的类的名称的名称)。

接下来我们需要发挥的作用的官员确定是否是合法的球员所执行的操作的对象。例如，在发球并未清除净和法院的相应的区域的土地吗？为此目的，我们可能会建立一个称为法官包含方法的对象评估服务，并评估回报。如果法官对象确定服务或返回可以接受，比赛继续进行。否则，法官向名为分数，因此记录结果的另一个对象发送消息。

在这一点上设计为我们的网球节目组成的四个对象： 玩家 A，玩家 B、 法官，并得分。为了澄清我们的设计，考虑截击我们那里代表涉及为矩形的对象图 7.5 所示，可能会发生的事件的序列。图被打算提出这些对象作为球员 A.对象内的服务方法调用的结果之间的通信正如我们将下移，图，按时间顺序显示事件。所描述的第一水平箭头，玩家 A 报告通过调用方法的对象法官对其服务评估服务。然后，法官确定的发球很好，并且询问玩家 B，以使其返回由调用玩家 B 返回凌空方法。当法官确定的玩家 A 错误，并且询问该对象时，就会终止凌空得分来记录结果。

在我们当务之急的示例，我们面向对象的程序是非常简单化在这一阶段。不过，我们已取得的进展足以看到的面向对象的范例是如何导致的基本组件是对象的模块化设计。