About UML Class Diagrams
About UML Class Diagrams
Introduction |
|
The Unified Modeling Language (UML) is a graphical language for
creating diagrams that are useful in the software development process. The UML provides a set of standard
graphical symbols and the rules for combining them. The UML is process and implementation
language independent.
The UML provides
symbols to support various views of the system. In all, there are nine diagram types
included in the UML:
· Class diagrams,
· Object diagrams,
· Use case diagrams,
· Sequence diagrams,
· Collaboration diagrams,
· State-chart diagrams,
· Activity diagrams,
· Component diagrams, and
·
Deployment diagrams.
In this guide,
we will be concerned with class diagrams, which provide a structural view of
the system.
|
|
|
|
Class Diagrams |
|
Class diagrams are perhaps the most common type of diagram used in
modeling object‑oriented systems. A
class diagram shows a set of classes, interfaces, collaborations, and
dependencies. In addition, notes and
constraints can appear on a class diagram. You use class diagrams to show the
static structure of your system.
A class is
represented by a box that is divided horizontally into three sections. The top section contains the class name,
the middle section contains the class attributes and the bottom section
contains the class methods. An example
of a class diagram for a Time class is shown below.
|
|
|
|
Class Name |
|
The class name appears in the top section of the class box and
consists of text. The class name is a
noun or noun phrase. Typically, the
first letter of each word in the phrase is capitalized.
|
|
|
|
Class Attributes |
|
The middle
section of the class box contains the class attributes. An attribute represents some property of
the class. The attribute name consists
of text and is a noun or noun phrase.
Typically, the first letter of each word in the phrase is capitalized,
except the first. You can, optionally, specify the type of the attribute and
possibly a default value. For example,
to specify that the attribute hour is of type integer and has an initial value of 12, replace hour in the above diagram
with hour
: Integer = 12 .
Collections (or arrays) of attributes are indicated by giving the
multiplicity. Refer to the discussion
of multiplicity in the Association section below. Nota
Bene: By specifying the
type and default values, you are increasing the information content of the
diagram at the possible expense of cluttering the diagram. This same comment is applicable to other
optional information.
|
|
|
|
Class Methods |
|
The bottom section of the class box contains the class
methods. A method is an abstraction of
something that an object can do, or have done to it. The method name consists of text and is a
verb or verb phrase, followed by left and right parenthesis. Typically, you capitalize the first letter
of each word in the name, except the first.
You can, optionally, specify the names, types and default of all
method arguments as well as the return type of functions. For example, a full
specification of the setTime() method might look like
setTime( newHour : Integer = 12, newMinute : Integer =
0, newSecond : Integer = 0 )
|
|
|
|
Visibility |
|
The UML provides
symbols to indicate the visibility of attributes and methods. The following symbols, when place
immediately before either an attribute name or method name, define the
visibility of the attribute or name:
+ public
- private
# protected
For example, to give the attribute minute protected visibility, you would write # minute.
|
|
|
|
Scope |
|
You can specify the scope of an attribute using the UML. By default, an attribute has instance
scope. That is, each object created
from the class has its own value for the attribute. You can give an attribute class scope, by
underlining the attribute name (and type and default value if present). The most common use for class scope is to
share a private variable among all instances of the class. You might do this, for example, if you
needed to give each instance a unique identifier.
|
|
|
|
Relationships |
|
The UML provides
graphic symbols to represent the following relationships:
· Dependency
· Association
· Generalization
between classes.
|
|
|
|
Dependency |
|
A dependency is
a relationship between two classes in which a change to one, called the
independent class, causes a change in the other, called the dependent
class. A dependency is represented by
a dashed line from the dependent class to the independent class. For example,
if you have a CDPlayer
player class and a RemoteControl class, you would indicate the dependency by the following diagram
|
|
|
|
Association
|
|
An association
is a relationship that specifies that the objects of one class are connected
to objects of another class. An association is represented by a solid line
connecting the two classes. For
example, suppose you have an Employee class and a Company class. An association is
depicted by the following diagram
The notations
above the solid connecting line indicate the multiplicity, or how many. The above diagram indicates that an
instance of the Employee class can work for many companies and that an instance of the Company class has one or
more employees. Some examples of
multiplicities and their meaning are:
4 exactly four
1 .. 3 one to three
* many
The same notation is used to indicate a collection or array of
attributes. For example,
port[4]
: SerialOPort
indicates that there are 4 ports
of type SerialOPort
One particular one-to-many association (aggregation) frequently
arises in object-oriented modeling: the “whole/part” relationship. An aggregation is represented by a solid
line connecting the two classes, with an open diamond at the end of the line
adjacent to the “whole” class. An example is the aggregation of family members
within a household. The UML diagram is
shown below.
There is a variation of aggregation, which is called
composition. Composition is a
relationship that has strong ownership and simultaneity of lifetimes of the classes. That is, if the part class belongs to just
one whole class and cannot exist outside the whole object, the relationship
is composition. An aggregation is represented by a solid line connecting the
two classes, with an solid diamond at the end of the line adjacent to
the “whole” class. An example of composition is the
relationship between a college and its departments. The UML diagram is shown below.....
|
0 commentaires: