﻿<?xml version="1.0" encoding="utf-8" standalone="yes"?><rss version="2.0" xmlns:dc="http://purl.org/dc/elements/1.1/" xmlns:trackback="http://madskills.com/public/xml/rss/module/trackback/" xmlns:wfw="http://wellformedweb.org/CommentAPI/" xmlns:slash="http://purl.org/rss/1.0/modules/slash/"><channel><title>BlogJava-昊天-随笔分类-UML</title><link>http://www.blogjava.net/hao446tian/category/48675.html</link><description /><language>zh-cn</language><lastBuildDate>Tue, 25 Oct 2011 13:38:25 GMT</lastBuildDate><pubDate>Tue, 25 Oct 2011 13:38:25 GMT</pubDate><ttl>60</ttl><item><title>UML 基础: 类图</title><link>http://www.blogjava.net/hao446tian/archive/2011/10/25/362011.html</link><dc:creator>昊天</dc:creator><author>昊天</author><pubDate>Tue, 25 Oct 2011 07:23:00 GMT</pubDate><guid>http://www.blogjava.net/hao446tian/archive/2011/10/25/362011.html</guid><wfw:comment>http://www.blogjava.net/hao446tian/comments/362011.html</wfw:comment><comments>http://www.blogjava.net/hao446tian/archive/2011/10/25/362011.html#Feedback</comments><slash:comments>0</slash:comments><wfw:commentRss>http://www.blogjava.net/hao446tian/comments/commentRss/362011.html</wfw:commentRss><trackback:ping>http://www.blogjava.net/hao446tian/services/trackbacks/362011.html</trackback:ping><description><![CDATA[<p sizset="94" sizcache="25"><a name="N1012D"><span class="atitle">基础</span></a></p>
<p>如先前所提到的，类图的目的是显示建模系统的类型。在大多数的 UML 模型中这些类型包括：</p>
<ul><li>类</li><li>接口</li><li>数据类型</li><li>组件 </li></ul>
<p>UML 为这些类型起了一个特别的名字：&#8220;分类器&#8221;。通常地，你可以把分类器当做类，但在技术上，分类器是更为普遍的术语，它还是引用上面的其它三种类型为好。</p>
<p><strong>类名</strong> </p>
<p>类的 UML 表示是一个长方形，垂直地分为三个区，如图 1 所示。顶部区域显示类的名字。中间的区域列出类的属性。底部的区域列出类的操作。当在一个类图上画一个类元素时，你必须要有顶端的区域，下面的二个区域是可选择的（当图描述仅仅用于显示分类器间关系的高层细节时，下面的两个区域是不必要的）。图 1 显示一个航线班机如何作为 UML 类建模。正如我们所能见到的，名字是 <em>Flight</em>，我们可以在中间区域看到Flight类的3个属性：flightNumber，departureTime 和 flightDuration。在底部区域中我们可以看到Flight类有两个操作：delayFlight 和 getArrivalTime。</p><img height="128" alt="图 1: Flight类的类图" src="http://www.ibm.com/developerworks/cn/rational/rationaledge/content/feb05/bell/bell_fig1.jpg" width="288" border="0" /> 
<p><strong>图 1: Flight类的类图</strong> </p>
<p><strong>类属性列表</strong> </p>
<p>类的属性节（中部区域）在分隔线上列出每一个类的属性。属性节是可选择的，要是一用它，就包含类的列表显示的每个属性。该线用如下格式：</p>
<blockquote sizset="3" sizcache="2">
<table cellspacing="0" cellpadding="0" width="400" border="0" sizset="3" sizcache="2">
<tbody sizset="3" sizcache="1">
<tr>
<td class="code-outline"><pre class="displaycode">name : attribute type</pre></td></tr></tbody></table><br /></blockquote>
<blockquote sizset="4" sizcache="2">
<table cellspacing="0" cellpadding="0" width="400" border="0" sizset="4" sizcache="2">
<tbody sizset="4" sizcache="1">
<tr>
<td class="code-outline"><pre class="displaycode">flightNumber : Integer</pre></td></tr></tbody></table><br /></blockquote>
<p>继续我们的Flight类的例子，我们可以使用属性类型信息来描述类的属性，如表 1 所示。</p>
<p><strong>表 1：具有关联类型的Flight类的属性名字</strong> </p>
<table class="ibm-data-table" cellspacing="0" cellpadding="0" width="100%" border="0" sizset="5" sizcache="2">
<tbody sizset="5" sizcache="1">
<tr class="" jquery1319526928718="5">
<td>
<table class="ibm-data-table" width="100%" border="0" sizset="6" sizcache="2">
<tbody sizset="6" sizcache="1">
<tr class="" jquery1319526928718="6">
<th>属性名称</th>
<th>属性类型</th></tr>
<tr jquery1319526928718="7">
<td class="tb-row">flightNumber</td>
<td>Integer</td></tr>
<tr jquery1319526928718="8">
<td class="tb-row">departureTime</td>
<td>Date</td></tr>
<tr jquery1319526928718="9">
<td class="tb-row">flightDuration</td>
<td>Minutes</td></tr></tbody></table></td></tr></tbody></table>
<p>在业务类图中，属性类型通常与单位相符，这对于图的可能读者是有意义的（例如，分钟，美元，等等）。然而，用于生成代码的类图，要求类的属性类型必须限制在由程序语言提供的类型之中，或包含于在系统中实现的、模型的类型之中。</p>
<p>在类图上显示具有默认值的特定属性，有时是有用的（例如，在银行账户应用程序中，一个新的银行账户会以零为初始值）。UML 规范允许在属性列表节中，通过使用如下的记号作为默认值的标识：</p>
<blockquote sizset="10" sizcache="2">
<table cellspacing="0" cellpadding="0" width="400" border="0" sizset="10" sizcache="2">
<tbody sizset="10" sizcache="1">
<tr>
<td class="code-outline"><pre class="displaycode">name : attribute type = default value</pre></td></tr></tbody></table><br /></blockquote>
<p>举例来说：</p>
<blockquote sizset="11" sizcache="2">
<table cellspacing="0" cellpadding="0" width="400" border="0" sizset="11" sizcache="2">
<tbody sizset="11" sizcache="1">
<tr>
<td class="code-outline"><pre class="displaycode">balance : Dollars = 0</pre></td></tr></tbody></table><br /></blockquote>
<p>显示属性默认值是可选择的；图 2 显示一个银行账户类具有一个名为 <em>balance</em>的类型，它的默认值为0。</p><img height="113" alt="图 2：显示默认为0美元的balance属性值的银行账户类图。" src="http://www.ibm.com/developerworks/cn/rational/rationaledge/content/feb05/bell/bell_fig2.jpg" width="212" border="0" /> 
<p><strong>图 2：显示默认为0美元的balance属性值的银行账户类图。</strong> </p>
<p><strong>类操作列表</strong> </p>
<p>类操作记录在类图长方形的第三个（最低的）区域中，它也是可选择的。和属性一样，类的操作以列表格式显示，每个操作在它自己线上。操作使用下列记号表现：</p>
<blockquote sizset="12" sizcache="2">
<table cellspacing="0" cellpadding="0" width="400" border="0" sizset="12" sizcache="2">
<tbody sizset="12" sizcache="1">
<tr>
<td class="code-outline"><pre class="displaycode">	name(parameter list) : type of value returned</pre></td></tr></tbody></table><br /></blockquote>
<p>下面的表 2 中Flight类操作的映射。</p>
<p><strong>表 2：从图 2 映射的Flight类的操作</strong> </p>
<table class="ibm-data-table" cellspacing="0" cellpadding="0" width="100%" border="0" sizset="13" sizcache="2">
<tbody sizset="13" sizcache="1">
<tr class="" jquery1319526928718="10">
<td>
<table class="ibm-data-table" width="100%" border="0" sizset="14" sizcache="2">
<tbody sizset="14" sizcache="1">
<tr class="" valign="top" align="left" jquery1319526928718="11">
<th><strong>操作名称</strong> </th>
<th><strong>返回参数</strong> </th>
<th><strong>值类型</strong> </th></tr>
<tr class="" valign="top" align="left" jquery1319526928718="12">
<td class="tb-row">delayFlight</td>
<td>
<table class="ibm-data-table" cellspacing="2" cellpadding="5" width="100%" border="0" sizset="16" sizcache="2">
<tbody sizset="16" sizcache="1">
<tr class="" jquery1319526928718="13">
<td><strong>Name</strong> </td>
<td><strong>Type</strong> </td></tr>
<tr jquery1319526928718="14">
<td>numberOfMinutes </td>
<td>Minutes</td></tr></tbody></table></td>
<td>N/A</td></tr>
<tr valign="top" align="left" jquery1319526928718="15">
<td class="tb-row">getArrivalTime </td>
<td>N/A </td>
<td>Date</td></tr></tbody></table></td></tr></tbody></table>
<p sizset="95" sizcache="25">图3显示，delayFlight 操作有一个Minutes类型的输入参数 -- numberOfMinutes。然而，delayFlight 操作没有返回值。<a href="http://www.ibm.com/developerworks/cn/rational/rationaledge/content/feb05/bell/#notes"><font color="#996699"> </font><sup><font color="#666666">1</font></sup><font color="#996699"> </font></a>当一个操作有参数时，参数被放在操作的括号内；每个参数都使用这样的格式：&#8220;参数名：参数类型&#8221;。</p><img height="129" alt="图 3：Flight类操作参数，包括可选择的&#8220;in&#8221;标识。" src="http://www.ibm.com/developerworks/cn/rational/rationaledge/content/feb05/bell/bell_fig3.jpg" width="279" border="0" /> 
<p><strong>图 3：Flight类操作参数，包括可选择的&#8220;in&#8221;标识。</strong> </p>
<p>当文档化操作参数时，你可能使用一个可选择的指示器，以显示参数到操作的输入参数、或输出参数。这个可选择的指示器以&#8220;in&#8221;或&#8220;out&#8221;出现，如图3中的操作区域所示。一般来说，除非将使用一种早期的程序编程语言，如Fortran ，这些指示器可能会有所帮助，否则它们是不必要的。然而，在 C++和Java中，所有的参数是&#8220;in&#8221;参数，而且按照UML规范，既然&#8220;in&#8221;是参数的默认类型，大多数人将会遗漏输入/输出指示器。</p>
<p><strong>继承</strong> </p>
<p>在面向对象的设计中一个非常重要的概念，<em>继承</em>，指的是一个类（子类）<em>继承</em>另外的一个类（超类）的同一功能，并增加它自己的新功能（一个非技术性的比喻，想象我继承了我母亲的一般的音乐能力，但是在我的家里，我是唯一一个玩电吉他的人）的能力。为了在一个类图上建模继承，从子类（要继承行为的类）拉出一条闭合的，单键头（或三角形）的实线指向超类。考虑银行账户的类型：图 4 显示 CheckingAccount 和 SavingsAccount 类如何从 BankAccount 类继承而来。</p><img height="335" alt="图 4: 继承通过指向超类的一条闭合的，单箭头的实线表示。" src="http://www.ibm.com/developerworks/cn/rational/rationaledge/content/feb05/bell/bell_fig4.jpg" width="563" border="0" /> 
<p><strong>图 4: 继承通过指向超类的一条闭合的，单箭头的实线表示。</strong> </p>
<p>在图 4 中，继承关系由每个超类的单独的线画出，这是在IBM Rational Rose和IBM Rational XDE中使用的方法。然而，有一种称为 <em>树标记</em>的备选方法可以画出继承关系。当存在两个或更多子类时，如图 4 中所示，除了继承线象树枝一样混在一起外，你可以使用树形记号。图 5 是重绘的与图 4 一样的继承，但是这次使用了树形记号。</p><img height="335" alt="图 5: 一个使用树形记号的继承实例" src="http://www.ibm.com/developerworks/cn/rational/rationaledge/content/feb05/bell/bell_fig5.jpg" width="563" border="0" /> 
<p><strong>图 5: 一个使用树形记号的继承实例</strong> </p>
<p><strong>抽象类及操作</strong> <br />细心的读者会注意到，在图 4 和 图5 中的图中,类名BankAccount和withdrawal操作使用斜体。这表示，BankAccount 类是一个抽象类，而withdrawal方法是抽象的操作。换句话说，BankAccount 类使用withdrawal规定抽象操作，并且CheckingAccount 和 SavingsAccount 两个子类都分别地执行它们各自版本的操作。</p>
<p>然而，超类（父类）不一定要是抽象类。标准类作为超类是正常的。</p>
<p><strong>关联</strong> <br />当你系统建模时，特定的对象间将会彼此关联，而且这些关联本身需要被清晰地建模。有五种关联。在这一部分中，我将会讨论它们中的两个 -- 双向的关联和单向的关联，而且我将会在<em>Beyond the basics</em>部分讨论剩下的三种关联类型。请注意，关于何时该使用每种类型关联的详细讨论，不属于本文的范围。相反的，我将会把重点集中在每种关联的用途，并说明如何在类图上画出关联。</p>
<p><strong>双向（标准）的关联</strong> <br />关联是两个类间的联接。关联总是被假定是双向的；这意味着，两个类彼此知道它们间的联系，除非你限定一些其它类型的关联。回顾一下Flight 的例子，图 6 显示了在Flight类和Plane类之间的一个标准类型的关联。</p><img height="145" alt="图 6：在一个Flight类和Plane类之间的双向关联的实例" src="http://www.ibm.com/developerworks/cn/rational/rationaledge/content/feb05/bell/bell_fig6.jpg" width="572" border="0" /> 
<p><strong>图 6：在一个Flight类和Plane类之间的双向关联的实例</strong> </p>
<p>一个双向关联用两个类间的实线表示。在线的任一端，你放置一个角色名和多重值。图 6 显示Flight与一个特定的Plane相关联，而且Flight类知道这个关联。因为角色名以Plane类表示，所以Plane承担关联中的&#8220;assignedPlane&#8221;角色。紧接于Plane类后面的多重值描述0...1表示，当一个Flight实体存在时，可以有一个或没有Plane与之关联（也就是，Plane可能还没有被分配）。图 6 也显示Plane知道它与Flight类的关联。在这个关联中，Flight承担&#8220;assignedFlights&#8221;角色；图 6 的图告诉我们，Plane实体可以不与flight关联（例如，它是一架全新的飞机）或与没有上限的flight（例如，一架已经服役5年的飞机）关联。</p>
<p>由于对那些在关联尾部可能出现的多重值描述感到疑惑，下面的表3列出了一些多重值及它们含义的例子。</p>
<p><strong>表 3: 多重值和它们的表示</strong> </p>
<table class="ibm-data-table" cellspacing="0" cellpadding="0" width="15%" border="0" sizset="19" sizcache="2">
<tbody sizset="19" sizcache="1">
<tr class="" jquery1319526928718="16">
<td>
<table class="ibm-data-table" cellspacing="2" cellpadding="5" width="100%" border="0" sizset="20" sizcache="2">
<tbody sizset="20" sizcache="1">
<tr jquery1319526928718="17">
<td colspan="2">可能的多重值描述</td></tr>
<tr jquery1319526928718="18">
<th>表示</th>
<th>含义</th></tr>
<tr class="" jquery1319526928718="19">
<td>0..1 </td>
<td>0个或1个</td></tr>
<tr class="" jquery1319526928718="20">
<td class="tb-row">1</td>
<td>只能1个</td></tr>
<tr class="" jquery1319526928718="21">
<td class="tb-row">0..*</td>
<td>0个或多个</td></tr>
<tr jquery1319526928718="22">
<td class="tb-row">* </td>
<td>0个或多个</td></tr>
<tr class="" jquery1319526928718="23">
<td class="tb-row">1..*</td>
<td>1个或我个</td></tr>
<tr class="" jquery1319526928718="24">
<td class="tb-row">3</td>
<td>只能3个</td></tr>
<tr class="" jquery1319526928718="25">
<td class="tb-row">0..5</td>
<td>0到5个</td></tr>
<tr class="" jquery1319526928718="26">
<td class="tb-row">5..15 </td>
<td>5到15个</td></tr></tbody></table></td></tr></tbody></table>
<p><strong>单向关联</strong> <br />在一个单向关联中，两个类是相关的，但是只有一个类知道这种联系的存在。图 7 显示单向关联的透支财务报告的一个实例。</p><img height="108" alt="图 7: 单向关联一个实例：OverdrawnAccountsReport 类 BankAccount 类，而 BankAccount 类则对关联一无所知。" src="http://www.ibm.com/developerworks/cn/rational/rationaledge/content/feb05/bell/bell_fig7.jpg" width="572" border="0" /> 
<p><strong>图 7: 单向关联一个实例：OverdrawnAccountsReport 类 BankAccount 类，而 BankAccount 类则对关联一无所知。</strong> </p>
<p sizset="96" sizcache="25">一个单向的关联，表示为一条带有指向已知类的开放箭头（不关闭的箭头或三角形，用于标志继承）的实线。如同标准关联，单向关联包括一个角色名和一个多重值描述，但是与标准的双向关联不同的时，单向关联只包含已知类的角色名和多重值描述。在图 7 中的例子中，OverdrawnAccountsReport 知道 BankAccount 类，而且知道 BankAccount 类扮演&#8220;overdrawnAccounts&#8221;的角色。然而，和标准关联不同，BankAccount 类并不知道它与 OverdrawnAccountsReport 相关联。<a href="http://www.ibm.com/developerworks/cn/rational/rationaledge/content/feb05/bell/#notes"><font color="#996699"> </font><sup><font color="#666666">2</font></sup><font color="#996699"> </font></a></p>
<p sizset="97" sizcache="25"><strong>软件包</strong> <br />不可避免，如果你正在为一个大的系统或大的业务领域建模，在你的模型中将会有许多不同的分类器。管理所有的类将是一件令人生畏的任务；所以，UML 提供一个称为 <em>软件包</em>的组织元素。软件包使建模者能够组织模型分类器到名字空间中，这有些象文件系统中的文件夹。把一个系统分为多个软件包使系统变成容易理解，尤其是在每个软件包都表现系统的一个特定部分时。<a href="http://www.ibm.com/developerworks/cn/rational/rationaledge/content/feb05/bell/#notes"><font color="#996699"> </font><sup><font color="#666666">3</font></sup><font color="#996699"> </font></a></p>
<p>在图中存在两种方法表示软件包。并没有规则要求使用哪种标记，除了用你个人的判断：哪种更便于阅读你画的类图。两种方法都是由一个较小的长方形（用于定位）嵌套在一个大的长方形中开始的，如图 8 所示。但是建模者必须决定包的成员如何表示，如下：</p>
<ul sizset="98" sizcache="25"><li sizset="98" sizcache="25">如果建模者决定在大长方形中显示软件包的成员，则所有的那些成员<a href="http://www.ibm.com/developerworks/cn/rational/rationaledge/content/feb05/bell/#notes"><font color="#996699"> </font><sup><font color="#666666">4</font></sup><font color="#996699"> </font></a>需要被放置在长方形里面。另外，所有软件包的名字需要放在软件包的较小长方形之内（如图 8 的显示）。<br /><br /></li><li>如果建模者决定在大的长方形之外显示软件包成员，则所有将会在图上显示的成员都需要被置于长方形之外。为了显示属于软件包的分类器属于，从每个分类器画一条线到里面有加号的圆周，这些圆周粘附在软件包之上（图9）。 </li></ul><img height="407" alt="图 8：在软件包的长方形内显示软件包成员的软件包元素例子" src="http://www.ibm.com/developerworks/cn/rational/rationaledge/content/feb05/bell/bell_fig8.jpg" width="572" border="0" /> 
<p><strong>图 8：在软件包的长方形内显示软件包成员的软件包元素例子</strong> </p><img height="622" alt="图 9：一个通过连接线表现软件包成员的软件包例子" src="http://www.ibm.com/developerworks/cn/rational/rationaledge/content/feb05/bell/bell_fig9.jpg" width="551" border="0" /> 
<p><strong>图 9：一个通过连接线表现软件包成员的软件包例子</strong> </p>
<p><strong>了解基础重要性</strong> </p>
<p>在 UML 2 中，了解类图的基础更为重要。这是因为类图为所有的其他结构图提供基本的构建块。如组件或对象图（仅仅是举了些例子）。</p>
<div class="ibm-alternate-rule">
<hr />
</div>
<p class="ibm-ind-link ibm-back-to-top" sizset="99" sizcache="25"><a class="ibm-anchor-up-link" href="http://www.ibm.com/developerworks/cn/rational/rationaledge/content/feb05/bell/#ibm-pcon"><strong><font color="#996699">回页首</font></strong></a></p>
<p sizset="100" sizcache="25"><a name="N103F7"><span class="atitle">超过基础</span></a></p>
<p>到此为止，我已经介绍了类图的基础，但是请继续往下读！在下面的部分中，我将会引导你到你会使用的类图的更重要的方面。这些包括UML 2 规范中的接口，其它的三种关联类型，可见性和其他补充。</p>
<p><strong>接口</strong> <br />在本文的前面，我建议你以类来考虑<em>分类器</em>。事实上，分类器是一个更为一般的概念，它包括数据类型和接口。</p>
<p>关于何时、以及如何高效地在系统结构图中使用数据类型和接口的完整讨论，不在本文的讨论范围之内。既然这样，我为什么要在这里提及数据类型和接口呢？你可能想在结构图上模仿这些分类器类型，在这个时候，使用正确的记号来表示，或者至少知道这些分类器类型是重要的。不正确地绘制这些分类器，很有可能将使你的结构图读者感到混乱，以后的系统将不能适应需求。</p>
<p sizset="101" sizcache="25">一个类和一个接口不同：一个类可以有它形态的真实实例，然而一个接口必须至少有一个类来实现它。在 UML 2 中，一个接口被认为是类建模元素的特殊化。因此，接口就象类那样绘制，但是长方形的顶部区域也有文本&#8220;interface&#8221;，如图 10 所示。<a href="http://www.ibm.com/developerworks/cn/rational/rationaledge/content/feb05/bell/#notes"><font color="#996699"> </font><sup><font color="#666666">5</font></sup><font color="#996699"> </font></a></p><font color="#996699"><img height="262" alt="图 10：Professor类和Student类实现Person接口的类图实例" src="http://www.ibm.com/developerworks/cn/rational/rationaledge/content/feb05/bell/bell_fig10.gif" width="325" border="0" /></font> 
<p><strong>图 10：Professor类和Student类实现Person接口的类图实例</strong> </p>
<p>在图 10 中显示的图中，Professor和Student类都实现了Person的接口，但并不从它继承。我们知道这一点是由于下面两个原因：1) Person对象作为接口被定义 -- 它在对象的名字区域中有&#8220;interface&#8221;文本，而且我们看到由于Professor和Student对象根据画类对象的规则（在它们的名字区域中没有额外的分类器文本）标示，所以它们是 <em>类</em>对象。 2) 我们知道继承在这里没有被显示，因为与带箭头的线是点线而不是实线。如图 10 所示，一条带有闭合的单向箭头的<em>点</em> 线意味着实现（或实施）；正如我们在图 4 中所见到的，一条带有闭合单向箭头的<em>实</em>线表示继承。</p>
<p><strong>更多的关联</strong> <br />在上面，我讨论了双向关联和单向关联。现在，我将会介绍剩下的三种类型的关联。</p>
<p><strong>关联类</strong> <br />在关联建模中，存在一些情况下，你需要包括其它类，因为它包含了关于关联的有价值的信息。对于这种情况，你会使用 <em>关联类</em> 来绑定你的基本关联。关联类和一般类一样表示。不同的是，主类和关联类之间用一条相交的点线连接。图 11 显示一个航空工业实例的关联类。</p><img height="184" alt="图 11：增加关联类 MileageCredit" src="http://www.ibm.com/developerworks/cn/rational/rationaledge/content/feb05/bell/bell_fig11.jpg" width="572" border="0" /> 
<p><strong>图 11：增加关联类 MileageCredit</strong> </p>
<p>在图 11 中显示的类图中，在Flight类和 FrequentFlyer 类之间的关联，产生了称为 MileageCredit的关联类。这意味当Flight类的一个实例关联到 FrequentFlyer 类的一个实例时，将会产生 MileageCredit 类的一个实例。</p>
<p><strong>聚合</strong> <br />聚合是一种特别类型的关联，用于描述&#8220;总体到局部&#8221;的关系。在基本的聚合关系中， <em>部分类</em> 的生命周期独立于 <em>整体类</em> 的生命周期。</p>
<p>举例来说，我们可以想象，<em>车</em> 是一个整体实体，而 <em>车轮</em> 轮胎是整辆车的一部分。轮胎可以在安置到车时的前几个星期被制造，并放置于仓库中。在这个实例中，Wheel类实例清楚地独立地Car类实例而存在。然而，有些情况下， <em>部分</em> 类的生命周期并 <em>不</em> 独立于 <em>整体</em> 类的生命周期 -- 这称为合成聚合。举例来说，考虑公司与部门的关系。 <em>公司和部门</em> 都建模成类，在公司存在之前，部门不能存在。这里Department类的实例依赖于Company类的实例而存在。</p>
<p>让我们更进一步探讨基本聚合和组合聚合。</p>
<p><strong><em>基本聚合</em> </strong><br />有聚合关系的关联指出，某个类是另外某个类的一部分。在一个聚合关系中，子类实例可以比父类存在更长的时间。为了表现一个聚合关系，你画一条从父类到部分类的实线，并在父类的关联末端画一个未填充棱形。图 12 显示车和轮胎间的聚合关系的例子。</p><img height="49" alt="图 12: 一个聚合关联的例子" src="http://www.ibm.com/developerworks/cn/rational/rationaledge/content/feb05/bell/bell_fig12.jpg" width="291" border="0" /> 
<p><strong>图 12: 一个聚合关联的例子</strong> </p>
<p><strong><em>组合聚合</em> </strong><br />组合聚合关系是聚合关系的另一种形式，但是子类实例的生命周期依赖于父类实例的生命周期。在图13中，显示了Company类和Department类之间的组合关系，注意组合关系如聚合关系一样绘制，不过这次菱形是被填充的。</p><img height="47" alt="图 13: 一个组合关系的例子" src="http://www.ibm.com/developerworks/cn/rational/rationaledge/content/feb05/bell/bell_fig13.jpg" width="341" border="0" /> 
<p><strong>图 13: 一个组合关系的例子</strong> </p>
<p>在图 13 中的关系建模中，一个Company类实例至少总有一个Department类实例。因为关系是组合关系，当Company实例被移除/销毁时，Department实例也将自动地被移除/销毁。组合聚合的另一个重要功能是部分类只能与父类的实例相关（举例来说，我们例子中的Company类）。</p>
<p><strong>反射关联</strong> <br />现在我们已经讨论了所有的关联类型。就如你可能注意到的，我们的所有例子已经显示了两个不同类之间的关系。然而，类也可以使用反射关联与它本身相关联。起先，这可能没有意义，但是记住，类是抽象的。图 14 显示一个Employee类如何通过manager / manages角色与它本身相关。当一个类关联到它本身时，这并不意味着类的实例与它本身相关，而是类的一个实例与类的另一个实例相关。</p><img height="114" alt="图 14：一个反射关联关系的实例" src="http://www.ibm.com/developerworks/cn/rational/rationaledge/content/feb05/bell/bell_fig14.gif" width="193" border="0" /> 
<p><strong>图 14：一个反射关联关系的实例</strong> </p>
<p>图 14 描绘的关系说明一个Employee实例可能是另外一个Employee实例的经理。然而，因为&#8220;manages&#8221;的关系角色有 0..*的多重性描述；一个雇员可能不受任何其他雇员管理。</p>
<p><strong>可见性</strong> <br />在面向对象的设计中，存在属性及操作可见性的记号。UML 识别四种类型的可见性：public，protected，private及package。</p>
<p>UML 规范并不要求属性及操作可见性必须显示在类图上，但是它要求为每个属性及操作定义可见性。为了在类图上的显示可见性，放置可见性标志于属性或操作的名字之前。虽然 UML 指定四种可见性类型，但是实际的编程语言可能增加额外的可见性，或不支持 UML 定义的可见性。表4显示了 UML 支持的可见性类型的不同标志。</p>
<p><strong>表 4：UML 支持的可见性类型的标志</strong> </p>
<table class="ibm-data-table" cellspacing="0" cellpadding="0" width="100%" border="0" sizset="30" sizcache="2">
<tbody sizset="30" sizcache="1">
<tr class="" jquery1319526928718="27">
<td>
<table class="ibm-data-table" width="100%" border="0" sizset="31" sizcache="2">
<tbody sizset="31" sizcache="1">
<tr jquery1319526928718="28">
<th>标志</th>
<th>可见性类型</th></tr>
<tr jquery1319526928718="29">
<td class="tb-row">+</td>
<td>Public</td></tr>
<tr class="" jquery1319526928718="30">
<td class="tb-row"># </td>
<td>Protected</td></tr>
<tr class="" jquery1319526928718="31">
<td class="tb-row">- </td>
<td>Private</td></tr>
<tr jquery1319526928718="32">
<td class="tb-row">~</td>
<td>Package</td></tr></tbody></table></td></tr></tbody></table>
<p>现在，让我们看一个类，以说明属性及操作的可见性类型。在图 15 中，所有的属性及操作都是public，除了 updateBalance 操作。updateBalance 操作是protected。</p><img height="129" alt="图 15：一个 BankAccount 类说明它的属性及操作的可见性" src="http://www.ibm.com/developerworks/cn/rational/rationaledge/content/feb05/bell/bell_fig15.jpg" width="276" border="0" /> 
<p><strong>图 15：一个 BankAccount 类说明它的属性及操作的可见性</strong> </p>
<div class="ibm-alternate-rule">
<hr />
</div>
<p class="ibm-ind-link ibm-back-to-top" sizset="102" sizcache="25"><a class="ibm-anchor-up-link" href="http://www.ibm.com/developerworks/cn/rational/rationaledge/content/feb05/bell/#ibm-pcon"><strong><font color="#996699">回页首</font></strong></a></p>
<p sizset="103" sizcache="25"><a name="N1053C"><span class="atitle">UML 2 补充</span></a></p>
<p>既然我们已经覆盖了基础和高级主题，我们将覆盖一些由UML 1. x增加的类图的新记号。</p>
<p><strong>实例</strong> <br />当一个系统结构建模时，显示例子类实例有时候是有用的。为了这种结构建模，UML 2 提供 <em>实例规范</em> 元素，它显示在系统中使用例子（或现实）实例的值得注意的信息。</p>
<p>实例的记号和类一样，但是取代顶端区域中仅有的类名，它的名字是经过拼接的:</p>
<blockquote sizset="36" sizcache="2">
<table cellspacing="0" cellpadding="0" width="400" border="0" sizset="36" sizcache="2">
<tbody sizset="36" sizcache="1">
<tr>
<td class="code-outline"><pre class="displaycode">Instance Name : Class Name</pre></td></tr></tbody></table><br /></blockquote>
<p>举例来说：</p>
<blockquote sizset="37" sizcache="2">
<table cellspacing="0" cellpadding="0" width="400" border="0" sizset="37" sizcache="2">
<tbody sizset="37" sizcache="1">
<tr>
<td class="code-outline"><pre class="displaycode">Donald : Person</pre></td></tr></tbody></table><br /></blockquote>
<p>因为显示实例的目的是显示值得注意的或相关的信息，没必要在你的模型中包含整个实体属性及操作。相反地，仅仅显示感兴趣的属性及其值是完全恰当的。如图16所描述。</p><img height="90" alt="图 16：Plane类的一个实例例子（只显示感兴趣的属性值）" src="http://www.ibm.com/developerworks/cn/rational/rationaledge/content/feb05/bell/bell_fig16.jpg" width="176" border="0" /> 
<p><strong>图 16：Plane类的一个实例例子（只显示感兴趣的属性值）</strong> </p>
<p>然而，仅仅表现一些实例而没有它们的关系不太实用；因此，UML 2 也允许在实体层的关系/关联建模。绘制关联与一般的类关系的规则一样，除了在建模关联时有一个附加的要求。附加的限制是，关联关系必须与类图的关系相一致，而且关联的角色名字也必须与类图相一致。它的一个例子显示于图 17 中。在这个例子中，实例是图 6 中类图的例子实例。</p><img height="245" alt="图 17：图 6 中用实例代替类的例子" src="http://www.ibm.com/developerworks/cn/rational/rationaledge/content/feb05/bell/bell_fig17.jpg" width="572" border="0" /> 
<p><strong>图 17：图 6 中用实例代替类的例子</strong> </p>
<p>图 17 有Flight类的二个实例，因为类图指出了在Plane类和Flight类之间的关系是 <em>0或多</em>。因此，我们的例子给出了两个与NX0337 Plane实例相关的Flight实例。</p>
<p><strong>角色</strong> <br />建模类的实例有时比期望的更为详细。有时，你可能仅仅想要在一个较多的一般层次做类关系的模型。在这种情况下，你应该使用 <em>角色</em> 记号。角色记号类似于实例记号。为了建立类的角色模型，你画一个方格，并在内部放置类的角色名及类名，作为实体记号，但是在这情况你不能加下划线。图 18 显示一个由图 14 中图描述的雇员类扮演的角色实例。在图 18 中，我们可以认为，即使雇员类与它本身相关，关系确实是关于雇员之间扮演经理及团队成员的角色。</p><img height="73" alt="图 18：一个类图显示图14中扮演不同角色的类" src="http://www.ibm.com/developerworks/cn/rational/rationaledge/content/feb05/bell/bell_fig18.gif" width="506" border="0" /> 
<p><strong>图 18：一个类图显示图14中扮演不同角色的类</strong> </p>
<p>注意，你不能在纯粹类图中做类角色的建模，即使图 18显示你可以这么做。为了使用角色记号，你将会需要使用下面讨论的内部结构记号。</p>
<p><strong>内部的结构</strong> <br />UML 2 结构图的更有用的功能之一是新的内部结构记号。它允许你显示一个类或另外的一个分类器如何在内部构成。这在 UML 1. x 中是不可能的，因为记号限制你只能显示一个类所拥有的聚合关系。现在，在 UML 2 中，内部的结构记号让你更清楚地显示类的各个部分如何保持关系。</p>
<p>让我们看一个实例。在图 18 中我们有一个类图以表现一个Plane类如何由四个引擎和两个控制软件对象组成。从这个图中省略的东西是显示关于飞机部件如何被装配的一些信息。从图 18 的图，你无法说明，是每个控制软件对象控制两个引擎，还是一个控制软件对象控制三个引擎，而另一个控制一个引擎。</p><img height="197" alt="图 19: 只显示对象之间关系的类图" src="http://www.ibm.com/developerworks/cn/rational/rationaledge/content/feb05/bell/bell_fig19.gif" width="415" border="0" /> 
<p><strong>图 19: 只显示对象之间关系的类图</strong> </p>
<p>绘制类的内在结构将会改善这种状态。开始时，你通过用二个区域画一个方格。最顶端的区域包含类名字，而较低的区域包含类的内部结构，显示在它们父类中承担不同角色的部分类，角色中的每个部分类也关系到其它类。图 19 显示了Plane类的内部结构；注意内部结构如何澄清混乱性。</p><img height="274" alt="图 20：Plane类的内部结构例子。" src="http://www.ibm.com/developerworks/cn/rational/rationaledge/content/feb05/bell/bell_fig20.gif" width="572" border="0" /> 
<p><strong>图 20：Plane类的内部结构例子。</strong> </p>
<p>在图 20 中Plane有两个 ControlSoftware 对象，而且每个控制二个引擎。在图左边上的 ControlSoftware（control1）控制引擎 1 和 2 。在图右边的 ControlSoftware（control2）控制引擎 3 和 4 。</p>
<div class="ibm-alternate-rule">
<hr />
</div>
<p class="ibm-ind-link ibm-back-to-top" sizset="104" sizcache="25"><a class="ibm-anchor-up-link" href="http://www.ibm.com/developerworks/cn/rational/rationaledge/content/feb05/bell/#ibm-pcon"><strong><font color="#996699">回页首</font></strong></a></p>
<p sizset="105" sizcache="25"><a name="N105DE"><span class="atitle">结论</span></a></p>
<p>至少存在两个了解类图的重要理由。第一个是它显示系统分类器的静态结构；第二个理由是图为UML描述的其他结构图提供了基本记号。开发者将会认为类图是为他们特别建立的；但是其他的团队成员将发现它们也是有用的。业务分析师可以用类图，为系统的业务远景建模。正如我们将会在本系列关于 UML 基础的文章中见到的，其他的图 -- 包括活动图，序列图和状态图&#8212;&#8212;参考类图中的类建模和文档化。</p>
<p>关于&#8220;UML 基础&#8221;的本系列的后面的元件图。</p><img src ="http://www.blogjava.net/hao446tian/aggbug/362011.html" width = "1" height = "1" /><br><br><div align=right><a style="text-decoration:none;" href="http://www.blogjava.net/hao446tian/" target="_blank">昊天</a> 2011-10-25 15:23 <a href="http://www.blogjava.net/hao446tian/archive/2011/10/25/362011.html#Feedback" target="_blank" style="text-decoration:none;">发表评论</a></div>]]></description></item><item><title>UML基础: 统一建模语言简介</title><link>http://www.blogjava.net/hao446tian/archive/2011/05/24/350942.html</link><dc:creator>昊天</dc:creator><author>昊天</author><pubDate>Tue, 24 May 2011 09:08:00 GMT</pubDate><guid>http://www.blogjava.net/hao446tian/archive/2011/05/24/350942.html</guid><wfw:comment>http://www.blogjava.net/hao446tian/comments/350942.html</wfw:comment><comments>http://www.blogjava.net/hao446tian/archive/2011/05/24/350942.html#Feedback</comments><slash:comments>0</slash:comments><wfw:commentRss>http://www.blogjava.net/hao446tian/comments/commentRss/350942.html</wfw:commentRss><trackback:ping>http://www.blogjava.net/hao446tian/services/trackbacks/350942.html</trackback:ping><description><![CDATA[<p>到了21世纪--准确地说是2003年，UML已经获得了业界的认同。在我所见过的专业人员的简历中，75%都声称具备UML的知识。然而，在同绝大多数求职人员面谈之后，可以明显地看出他们并不真正了解UML。通常地，他们将UML用作一个术语，或对UML一知半解。大家对UML缺乏理解的这种状况，促进我撰写这篇关于UML 1.4的快速入门文章。当阅读完本文时，您还不具备足够的知识可以在简历上声称自己掌握了UML，但是您已具有了进一步钻研该语言的良好起点。 </p>
<div class="ibm-container ibm-alt-header dw-container-sidebar" sizcache="20" sizset="75"><a name="1"><span class="atitle"><br />一些背景知识</span></a></div>
<p><br />正如前面曾提到过的，UML的本意是要成为一种标准的统一语言，使得IT专业人员能够进行计算机应用程序的建模。UML的主要创始人是Jim Rumbaugh、Ivar Jacobson和Grady Booch，他们最初都有自己的建模方法（OMT、OOSE和Booch），彼此之间存在着竞争。最终，他们联合起来创造了一种开放的标准。（听起来是不是很熟悉？这个现象类似J2EE、SOAP和Linux的诞生。）UML成为"标准"建模语言的原因之一在于，它与程序设计语言无关。（IBM Rational的UML建模工具被广泛应用于J2EE和.NET开发。）而且，UML符号集只是一种语言而不是一种方法学。这点很重要，因为语言与方法学不同，它可以在不做任何更改的情况下很容易地适应任何公司的业务运作方式。 </p>
<p>既然UML不是一种方法学，它就不需要任何正式的工作产品（即IBM Rational Unified Process?术语中所定义的"工件"）。而且它还提供了多种类型的模型描述图（diagram），当在某种给定的方法学中使用这些图时，它使得开发中的应用程序的更易理解。UML的内涵远不只是这些模型描述图，但是对于入门来说，这些图对这门语言及其用法背后的基本原理提供了很好的介绍。通过把标准的UML图放进您的工作产品中，精通UML的人员就更加容易加入您的项目并迅速进入角色。最常用的UML图包括：用例图、类图、序列图、状态图、活动图、组件图和部署图。</p>
<p>深入讨论每类图的细节问题已超出了这篇入门文章的范围。因此，下面仅给出了每类图的简要说明，更详细的信息将在以后的文章中探讨。 </p>
<div class="ibm-alternate-rule">
<hr />
</div>
<p class="ibm-ind-link ibm-back-to-top" sizcache="20" sizset="88"><a class="ibm-anchor-up-link" href="http://www.ibm.com/developerworks/cn/rational/r-uml/#ibm-pcon"><strong><font color="#996699"></font></strong></a>&nbsp;</p>
<p sizcache="20" sizset="89"><a name="2"><span class="atitle">用例图</span></a></p>
<p><br />用例图描述了系统提供的一个功能单元。用例图的主要目的是帮助开发团队以一种可视化的方式理解系统的功能需求，包括基于基本流程的"角色"（actors，也就是与系统交互的其他实体）关系，以及系统内用例之间的关系。用例图一般表示出用例的组织关系--要么是整个系统的全部用例，要么是完成具有功能（例如，所有安全管理相关的用例）的一组用例。要在用例图上显示某个用例，可绘制一个椭圆，然后将用例的名称放在椭圆的中心或椭圆下面的中间位置。要在用例图上绘制一个角色（表示一个系统用户），可绘制一个人形符号。角色和用例之间的关系使用简单的线段来描述，如图1所示。 </p><br /><img height="442" alt="示例用例图" src="http://www.ibm.com/developerworks/cn/rational/r-uml/image001.gif" width="553" /> <br />
<p><strong>图1：示例用例图</strong> </p>
<p><strong>图字（从上到下）：CD销售系统；查看乐队CD的销售统计；乐队经理；查看Billboard 200排行榜报告；唱片经理；查看特定CD的销售统计；检索最新的Billboard 200排行榜报告；排行榜报告服务</strong> </p>
<p>用例图通常用于表达系统或者系统范畴的高级功能。如图1所示，可以很容易看出该系统所提供的功能。这个系统允许乐队经理查看乐队CD的销售统计报告以及Billboard 200排行榜报告。它也允许唱片经理查看特定CD的销售统计报告和这些CD在Billboard 200排行榜的报告。这个图还告诉我们，系统将通过一个名为"排行榜报告服务"的外部系统提供Billboard排行榜报告。 </p>
<p>此外，在用例图中，没有列出的用例表明了该系统不能完成的功能。例如，它不能提供给乐队经理收听Billboard 200上不同专辑中的歌曲的途径 -- 也就是说，系统没有引用一个叫做"收听Billboard 200上的歌曲"的用例。这种缺少不是一件小事。在用例图中提供清楚的、简要的用例描述，项目赞助商就很容易看出系统是否提供了必须的功能。 </p>
<div class="ibm-alternate-rule">
<hr />
</div>
<p class="ibm-ind-link ibm-back-to-top" sizcache="20" sizset="90"><a class="ibm-anchor-up-link" href="http://www.ibm.com/developerworks/cn/rational/r-uml/#ibm-pcon"><strong><font color="#996699"></font></strong></a>&nbsp;</p>
<p sizcache="20" sizset="91"><a name="3"><span class="atitle">类图</span></a></p>
<p><br />类图表示不同的实体（人、事物和数据）如何彼此相关；换句话说，它显示了系统的静态结构。类图可用于表示逻辑类，逻辑类通常就是业务人员所谈及的事物种类--摇滚乐队、CD、广播剧；或者贷款、住房抵押、汽车信贷以及利率。类图还可用于表示实现类，实现类就是程序员处理的实体。实现类图或许会与逻辑类图显示一些相同的类。然而，实现类图不会使用相同的属性来描述，因为它很可能具有对诸如Vector和HashMap这种事物的引用。 </p>
<p>类在类图上使用包含三个部分的矩形来描述，如图2所示。最上面的部分显示类的名称，中间部分包含类的属性，最下面的部分包含类的操作（或者说"方法"）。 </p><br /><img height="106" alt="类图中的示例类对象" src="http://www.ibm.com/developerworks/cn/rational/r-uml/image002.gif" width="174" /> <br />
<p><strong>图2：类图中的示例类对象</strong> </p>
<p>根据我的经验，几乎每个开发人员都知道这个类图是什么，但是我发现大多数程序员都不能正确地描述类的关系。对于像图3这样的类图，您应该使用带有顶点指向父类的箭头的线段来绘制继承关系1，并且箭头应该是一个完全的三角形。如果两个类都彼此知道对方，则应该使用实线来表示关联关系；如果只有其中一个类知道该关联关系，则使用开箭头表示。 </p><br /><img height="224" alt="一个完整的类图" src="http://www.ibm.com/developerworks/cn/rational/r-uml/image003.gif" width="553" /> <br />
<p><strong>图3：一个完整的类图，包括了图2所示的类对象</strong> </p>
<p>在图3中，我们同时看到了继承关系和两个关联关系。CDSalesReport类继承自Report类。一个CDSalesReport类与一个CD类关联，但是CD类并不知道关于CDSalesReport类的任何信息。CD类和Band类都彼此知道对方，两个类彼此都可以与一个或者多个对方类相关联。 </p>
<p>一个类图可以整合其他许多概念，这将在本系列文章的后续文章中介绍。 </p>
<div class="ibm-alternate-rule">
<hr />
</div>
<p class="ibm-ind-link ibm-back-to-top" sizcache="20" sizset="92"><a class="ibm-anchor-up-link" href="http://www.ibm.com/developerworks/cn/rational/r-uml/#ibm-pcon"><strong><font color="#996699"></font></strong></a>&nbsp;</p>
<p sizcache="20" sizset="93"><a name="4"><span class="atitle">序列图</span></a></p>
<p><br />序列图显示具体用例（或者是用例的一部分）的详细流程。它几乎是自描述的，并且显示了流程中中不同对象之间的调用关系，同时还可以很详细地显示对不同对象的不同调用。 </p>
<p>序列图有两个维度：垂直维度以发生的时间顺序显示消息/调用的序列；水平维度显示消息被发送到的对象实例。 </p>
<p>序列图的绘制非常简单。横跨图的顶部，每个框（参见图4）表示每个类的实例（对象）。在框中，类实例名称和类名称之间用空格/冒号/空格来分隔，例如，myReportGenerator : ReportGenerator。如果某个类实例向另一个类实例发送一条消息，则绘制一条具有指向接收类实例的开箭头的连线，并把消息/方法的名称放在连线上面。对于某些特别重要的消息，您可以绘制一条具有指向发起类实例的开箭头的虚线，将返回值标注在虚线上。就我而言，我总喜欢绘制出包括返回值的虚线，这些额外的信息可以使得序列图更易于阅读。 </p>
<p>阅读序列图也非常简单。从左上角启动序列的"驱动"类实例开始，然后顺着每条消息往下阅读。记住：虽然图4所示的例子序列图显示了每条被发送消息的返回消息，但这只是可选的。 </p><br /><img height="337" alt="一个示例序列图" src="http://www.ibm.com/developerworks/cn/rational/r-uml/image004.gif" width="553" /> <br />
<p><strong>图4：一个示例序列图</strong> </p>
<p>通过阅读图4中的示例序列图，您可以明白如何创建一个CD销售报告（CD Sales Report）。其中的aServlet对象表示驱动类实例。aServlet向名为gen的ReportGenerator类实例发送一条消息。该消息被标为generateCDSalesReport，表示ReportGenerator对象实现了这个消息处理程序。进一步理解可发现，generateCDSalesReport消息标签在括号中包括了一个cdId，表明aServlet随该消息传递一个名为cdId的参数。当gen实例接收到一条generateCDSalesReport消息时，它会接着调用CDSalesReport类，并返回一个aCDReport的实例。然后gen实例对返回的aCDReport实例进行调用，在每次消息调用时向它传递参数。在该序列的结尾，gen实例向它的调用者aServlet返回一个aCDReport。 </p>
<p>请注意：图4中的序列图相对于典型的序列图来说太详细了。然而，我认为它才是足够易于理解的，并且它显示了如何表示嵌套的调用。对于初级开发人员来说，有时把一个序列分解到这种详细程度是很有必要的，这有助于他们理解相关的内容。 </p>
<div class="ibm-alternate-rule">
<hr />
</div>
<p class="ibm-ind-link ibm-back-to-top" sizcache="20" sizset="94"><a class="ibm-anchor-up-link" href="http://www.ibm.com/developerworks/cn/rational/r-uml/#ibm-pcon"><strong><font color="#996699"></font></strong></a>&nbsp;</p>
<p sizcache="20" sizset="95"><a name="5"><span class="atitle">状态图</span></a></p>
<p><br />状态图表示某个类所处的不同状态和该类的状态转换信息。有人可能会争论说每个类都有状态，但不是每个类都应该有一个状态图。只对"感兴趣的"状态的类（也就是说，在系统活动期间具有三个或更多潜在状态的类）才进行状态图描述。 </p>
<p>如图5所示，状态图的符号集包括5个基本元素：初始起点，它使用实心圆来绘制；状态之间的转换，它使用具有开箭头的线段来绘制；状态，它使用圆角矩形来绘制；判断点，它使用空心圆来绘制；以及一个或者多个终止点，它们使用内部包含实心圆的圆来绘制。要绘制状态图，首先绘制起点和一条指向该类的初始状态的转换线段。状态本身可以在图上的任意位置绘制，然后只需使用状态转换线条将它们连接起来。 </p><br /><img height="298" alt="显示类通过某个功能系统的各种状态的状态图" src="http://www.ibm.com/developerworks/cn/rational/r-uml/image005.gif" width="554" /> <br />
<p><strong>图5：显示类通过某个功能系统的各种状态的状态图</strong> </p>
<p>图5中的状态图显示了它们可以表达的一些潜在信息。例如，从中可以看出贷款处理系统最初处于Loan Application状态。当批准前（pre-approval）过程完成时，根据该过程的结果，或者转到Loan Pre-approved状态，或者转到Loan Rejected状态。这个判断（它是在转换过程期间做出的）使用一个判断点来表示--即转换线条间的空心圆。通过该状态图可知，如果没有经过Loan Closing状态，贷款不可能从Loan Pre-Approved状态进入Loan in Maintenance状态。而且，所有贷款都将结束于Loan Rejected或者Loan in Maintenance状态。 </p>
<div class="ibm-alternate-rule">
<hr />
</div>
<p class="ibm-ind-link ibm-back-to-top" sizcache="20" sizset="96"><a class="ibm-anchor-up-link" href="http://www.ibm.com/developerworks/cn/rational/r-uml/#ibm-pcon"><strong><font color="#996699"></font></strong></a>&nbsp;</p>
<p sizcache="20" sizset="97"><a name="6"><span class="atitle">活动图</span></a></p>
<p><br />活动图表示在处理某个活动时，两个或者更多类对象之间的过程控制流。活动图可用于在业务单元的级别上对更高级别的业务过程进行建模，或者对低级别的内部类操作进行建模。根据我的经验，活动图最适合用于对较高级别的过程建模，比如公司当前在如何运作业务，或者业务如何运作等。这是因为与序列图相比，活动图在表示上"不够技术性的"，但有业务头脑的人们往往能够更快速地理解它们。 </p>
<p>活动图的符号集与状态图中使用的符号集类似。像状态图一样，活动图也从一个连接到初始活动的实心圆开始。活动是通过一个圆角矩形（活动的名称包含在其内）来表示的。活动可以通过转换线段连接到其他活动，或者连接到判断点，这些判断点连接到由判断点的条件所保护的不同活动。结束过程的活动连接到一个终止点（就像在状态图中一样）。作为一种选择，活动可以分组为泳道（swimlane），泳道用于表示实际执行活动的对象，如图6所示。</p><br /><img height="598" alt="活动图" src="http://www.ibm.com/developerworks/cn/rational/r-uml/image006.gif" width="504" /> <br />
<p><strong>图6：活动图，具有两个泳道，表示两个对象的活动控制：乐队经理，以及报告工具</strong> </p>
<p>图字（沿箭头方向）：乐队经理；报告工具；选择"查看乐队的销售报告"；检索该乐队经理所管理的乐队；显示报告条件选择屏幕；选择要查看其销售报告的乐队；从销售数据库检索销售数据；显示销售报告。 </p>
<p>该活动图中有两个泳道，因为有两个对象控制着各自的活动：乐队经理和报告工具。整个过程首先从乐队经理选择查看他的乐队销售报告开始。然后报告工具检索并显示他管理的所有乐队，并要求他从中选择一个乐队。在乐队经理选择一个乐队之后，报告工具就检索销售信息并显示销售报告。该活动图表明，显示报告是整个过程中的最后一步。</p>
<div class="ibm-alternate-rule">
<hr />
</div>
<p class="ibm-ind-link ibm-back-to-top" sizcache="20" sizset="98"><a class="ibm-anchor-up-link" href="http://www.ibm.com/developerworks/cn/rational/r-uml/#ibm-pcon"><strong><font color="#996699"></font></strong></a>&nbsp;</p>
<p sizcache="20" sizset="99"><a name="7"><span class="atitle">组件图</span></a></p>
<p><br />组件图提供系统的物理视图。它的用途是显示系统中的软件对其他软件组件（例如，库函数）的依赖关系。组件图可以在一个非常高的层次上显示，从而仅显示粗粒度的组件，也可以在组件包层次2上显示。 </p>
<p>组件图的建模最适合通过例子来描述。图7显示了4个组件：Reporting Tool、Billboard Service、Servlet 2.2 API和JDBC API。从Reporting Tool组件指向Billboard Service、Servlet 2.2 API和JDBC API组件的带箭头的线段，表示Reporting Tool依赖于那三个组件。 </p><br /><img height="179" alt="组件图显示了系统中各种软件组件的依赖关系" src="http://www.ibm.com/developerworks/cn/rational/r-uml/image007.gif" width="552" /> <br />
<p><strong>图7：组件图显示了系统中各种软件组件的依赖关系</strong> </p>
<div class="ibm-alternate-rule">
<hr />
</div>
<p class="ibm-ind-link ibm-back-to-top" sizcache="20" sizset="100"><a class="ibm-anchor-up-link" href="http://www.ibm.com/developerworks/cn/rational/r-uml/#ibm-pcon"><strong><font color="#996699"></font></strong></a>&nbsp;</p>
<p sizcache="20" sizset="101"><a name="8"><span class="atitle">部署图</span></a></p>
<p><br />部署图表示该软件系统如何部署到硬件环境中。它的用途是显示该系统不同的组件将在何处物理地运行，以及它们将如何彼此通信。因为部署图是对物理运行情况进行建模，系统的生产人员就可以很好地利用这种图。 </p>
<p>部署图中的符号包括组件图中所使用的符号元素，另外还增加了几个符号，包括节点的概念。一个节点可以代表一台物理机器，或代表一个虚拟机器节点（例如，一个大型机节点）。要对节点进行建模，只需绘制一个三维立方体，节点的名称位于立方体的顶部。所使用的命名约定与序列图中相同：[实例名称] : [实例类型]（例如，"w3reporting.myco.com : Application Server"）。 </p><br /><img height="179" alt="部署图" src="http://www.ibm.com/developerworks/cn/rational/r-uml/image007.gif" width="552" /> <br />
<p><strong>图8：部署图。由于Reporting Tool组件绘制在IBM WebSphere内部，后者又绘制在节点w3.reporting.myco.com内部，因而我们知道，用户将通过运行在本地机器上的浏览器来访问Reporting Tool，浏览器通过公司intranet上的HTTP协议与Reporting Tool建立连接。 </strong></p>
<p>图8中的部署图表明，用户使用运行在本地机器上的浏览器访问Reporting Tool，并通过公司intranet上的HTTP协议连接到Reporting Tool组件。这个工具实际运行在名为w3reporting.myco.com的Application Server上。这个图还表明Reporting Tool组件绘制在IBM WebSphere内部，后者又绘制在w3.reporting.myco.com节点内部。Reporting Tool使用Java语言通过IBM DB2数据库的JDBC接口连接到它的报告数据库上，然后该接口又使用本地DB2通信方式，与运行在名为db1.myco.com的服务器上实际的DB2数据库通信。除了与报告数据库通信外，Report Tool组件还通过HTTPS上的SOAP与Billboard Service进行通信。 </p><img src ="http://www.blogjava.net/hao446tian/aggbug/350942.html" width = "1" height = "1" /><br><br><div align=right><a style="text-decoration:none;" href="http://www.blogjava.net/hao446tian/" target="_blank">昊天</a> 2011-05-24 17:08 <a href="http://www.blogjava.net/hao446tian/archive/2011/05/24/350942.html#Feedback" target="_blank" style="text-decoration:none;">发表评论</a></div>]]></description></item></channel></rss>