8-UML Building Blocks

UML Building Blocks
Things
Structural Behavioral Grouping Annotational
Diagrams
Class Diagram Object Diagram Use Case Diagram Behaviour Diagram Implementation Diagram
Relationships
Dependency Association Generalisation Realization
Structural Things
The nouns of UML models; usually the static parts of the system in question.
Class - an abstraction of a set of things in the problemdomain that have similar properties and/or functionality. Notation:
customer
Interface - a collection of operations that specify the services rendered

by a class or component.
Notation:
Structural Things (contd.)

Collaboration - a collection of UML building blocks
(classes, interfaces, relationships) that work together to provide some functionality within the system. Notation:
Accounts System
Use Case - an abstraction of a set of functions that the system performs; a

use case is realized by a collaboration. Process Order
Notation:

Active Class - a class whose instance is an active object;
an active object is an object that owns a process or thread (units of execution) Notation:
eventManager
Component - a physical part (typically manifests itself as a piece of

software) of the system.
Notation:
DML_Parser.C

Node - a physical element that exists at run-time and
represents a computational resource (typically, hardware resources).
PrintServer
Notation:
Behavioral Things
The verbs of UML models; usually the dynamic parts of the system in question.
Interaction - some behaviour constituted by messages

exchanged among objects; the exchange of messages is with a view to achieving some purpose. Notation: Parse
Behavioral Things (contd.)

State machine - a behaviour that specifies the sequence
of states an object goes through, during its lifetime. A state is a condition or situation during the lifetime of an object during which it exhibits certain characteristics and/or performs some function.
Notation:
Engine Idling
Grouping Things
The organisational part of the UML model; provides a higher level of abstraction (granularity).
Package - a general-purpose element that comprises UML

elements - structural, behavioral or even grouping things. Packages are conceptual groupings of the system and need not necessarily be implemented as cohesive software modules.
Notation:
Accounts Department
Annotational Things
The explanatory part of the UML model; adds information/meaning to the model elements.
Note - a graphical notation for attaching constraints and/or

comments to elements of the model.
Parses user-query and builds expression stack (or invokes ErrorHandler)
Notation:
Relationships
Articulates the meaning of the links between things.
Dependency - a semantic relationship where a change in

one thing (the independent thing) causes a change in the semantics of the other thing (the dependent thing). Notation: (arrow-head points to the independent thing)
Association - a structural relationship that describes the connection

between two things.
Notation:
Relationships (contd.)
Generalisation - a relationship between a general thing
(called parent or superclass) and a more specific kind of that thing (called the child or subclass), such that the latter can substitute the former. Notation: (arrow-head points to the superclass)
Relationships (contd.)
Realization - a semantic relationship between two things
wherein one specifies the behaviour to be carried out, and the other carries out the behaviour. a collaboration realizes a Use Case the Use Case specifies the behaviour (functionality) to be carried out (provided), and the collaboration actually implements that behaviour. Notation: (arrow-head points to the thing being realized)
Diagrams
The graphical presentation of the model. Represented as a connected graph - vertices (things) connected by arcs (relationships). UML includes nine diagrams - each capturing a different dimension of a software-system architecture. Class Diagram Object Diagram Use Case Diagram Sequence Diagram Collaboration Diagram Statechart Diagram Activity Diagram Component Diagram Deployment Diagram
More on Diagrams...
Class Diagram - the most common diagram found in
OOAD, shows a set of classes, interfaces, collaborations and their relationships. Models the static view of the system.
Object Diagram - a snapshot of a class diagram; models

the instances of things contained in a class diagram.
Use Case Diagram - shows a set of Use Cases (sets of

functionality performed by the system), the actors (typically, people/systems that interact with this system[problem-domain]) and their relationships. Models WHAT the system is expected to do.
More on Diagrams...
Sequence Diagram - models the flow of control by timeordering; depicts the interaction between various objects by of messages passed, with a temporal dimension to it.
Collaboration Diagram - models the interaction

between objects, without the temporal dimension; merely depicts the messages passed between objects.
Statechart Diagram - shows the different state machines

and the events that leads to each of these state machines. Statechart diagrams show the flow of control from state to state.
More on Diagrams...
Activity Diagram - shows the flow from activity to
activity; an activity is an ongoing non-atomic execution within a state machine.
Component Diagram - shows the physical packaging of

software in terms of components and the dependencies between them.
Deployment Diagram - shows the configuration of the

processing nodes at run-time and the components that live on them.
Dimensions...
. . .of Software Architecture
Structural Implementation View View Class Diagrams Object Diagrams Component Diagrams
User View
Sequence Diagrams Deployment Diagrams Collaboration Diagrams Statechart Diagrams Activity Diagrams Behavioral Environment View View Use Case Diagrams
Rules
Specify what a well-formed model should look like. The UML has semantic rules for
Names Scope Visibility Integrity Execution
Common Mechanisms
Mechanisms/elements that apply consistently throughout the language:
Specifications Adornments
(Notes)
Common Divisions Extensibility Mechanisms

Stereotypes Tagged values Constraints
Adornments
Adorn the model - i.e., enhance the model. Adds to the meaning and/or semantics of the element to which it pertains. Notes are the mechanism provided by UML for adorning a model:
graphical symbol to render constraints, comments, etc. a note that renders only a comment has no semantic impact on the element it is adorning; at most adds meaning to it and/or provides guidelines for implementation.
Stereotypes
Used to create new building blocks from existing blocks. New building blocks are domain-specific. A particular abstraction is marked as a stereotype and this stereotype is then used at other places in the model to denote the associated abstraction.
Notation: metaclass
Tagged Values
Used to add to the information of the element (not of its instances). Stereotypes help create new building blocks; tagged values help create new attributes. Commonly used to specify information relevant to code generation, configuration management, etc.
Notation: {version=1.4}
Constraints
Used to create rules for the model. Rules that impact the semantics of the model, and specify conditions that must be met. Can apply to any element in the model attributes of a class, relationship, etc.
Notation: { incomplete, disjoint }

8-UML Building Blocks

Uploaded by

Copyright:

Available Formats

8-UML Building Blocks

Uploaded by

Document Information

Copyright

Available Formats

Share this document

Share or Embed Document

Sharing Options

Did you find this document useful?

Is this content inappropriate?

Copyright:

Available Formats

8-UML Building Blocks

Uploaded by

Copyright:

Available Formats

UML Building Blocks

 Interface - a collection of operations that specify the services rendered

Structural Things (contd.)

 Use Case - an abstraction of a set of functions that the system performs; a

Structural Things (contd.)

 Component - a physical part (typically manifests itself as a piece of

Structural Things (contd.)

 Interaction - some behaviour constituted by messages

Behavioral Things (contd.)

Package - a general-purpose element that comprises UML

 Note - a graphical notation for attaching constraints and/or

Dependency - a semantic relationship where a change in

 Association - a structural relationship that describes the connection

 Object Diagram - a snapshot of a class diagram; models

 Use Case Diagram - shows a set of Use Cases (sets of

 Collaboration Diagram - models the interaction

 Statechart Diagram - shows the different state machines

 Component Diagram - shows the physical packaging of

 Deployment Diagram - shows the configuration of the

Common Divisions Extensibility Mechanisms

Stereotypes Tagged values Constraints

You might also like

Interface - a collection of operations that specify the services rendered

Use Case - an abstraction of a set of functions that the system performs; a

Component - a physical part (typically manifests itself as a piece of

Interaction - some behaviour constituted by messages

Note - a graphical notation for attaching constraints and/or

Association - a structural relationship that describes the connection

Object Diagram - a snapshot of a class diagram; models

Use Case Diagram - shows a set of Use Cases (sets of

Collaboration Diagram - models the interaction

Statechart Diagram - shows the different state machines

Component Diagram - shows the physical packaging of

Deployment Diagram - shows the configuration of the