Building Block Things in the UML

Structural Things Behavioral Things Grouping Things Annotational Things

Relationships In the UML Diagrams

The vocabulary of the UML encompasses three kind of building blocks:

Things Relationship Diagrams

There are four kinds of things in the UML:

Structural things Behavioral things Grouping things Annotational things

These things are the basic object-oriented building blocks Of the UML. You use them to write well-formed models.

Structural things are the noun of the UML models. These are the mostly static parts of a model, representing

elements that are either conceptual or physical. There are seven kind of structural things. It Include:

Classes Interface Active classes Collaboration Use case Components Nodes

A class is a description of a set of objects that share the same attributes, operations, relationship, and semantics.

Graphically, a class is rendered as a rectangle, usually including its name, attributes and operations.

Class

Class Name

Attributes

Operations

An interface is a collection of operations that specify a service of a class or components.

An interface defines a set of operations specifications but never a set of operation implementation.

Graphically, an interface is rendered as a circle together with its name.

Interface

A collaboration defines an interaction and is a society of roles and other elements that work together to provide some cooperative behavior that’s bibber than the sum of all the elements.

A given class might participate in several collaboration.

Graphically, collaboration is rendered as an ellipse with dashed lines, usually including only its name.

A use case is a coherent piece of functionality that a system can provide by interacting with actors.

Graphically, a use case is rendered as an ellipse with solid lines, usually including only its name, as in figure:

Place Order

Actor Use case

An active class is a class whose object own one or more processes or threads and therefore can initiate control activity.

An activity class is just like a class except that its objects represents elements whose behavior is concurrent with other elements.

Graphically, an active class is rendered just like a class, but with heavy lines, usually including its name, attributes and operations as in figure:

A component is a physical and replaceable part of a system that

conforms to and provides the realization of a set of interfaces.

Notation:

Component

A physical element that exists at run-time and represents a computational resource (typically, hardware resources).

Notation:Print

Server

BACK

Behavioral things are the dynamic parts of UML models.

There are two primary kind of behavioral things.

Interaction

State Machine

Interaction:-An interaction is a behavior that comprises a set of messages exchanged among a set of objects within a particular context to accomplish a specific purpose.

Notation:-

State Machine:- A behavior 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:-

Display

WaitingBACK

Grouping things are the organizational parts of UML models. These are the boxes into which a model can be decomposed.

There is one primary kind of grouping thing: Package

Package:-A package is a general-purpose mechanism for organizing elements into

groups. Structural things, behavioral things and even other grouping things may be placed in a package.

Notation:- AccountsDepartment

BACK

Annotational things are the explanatory parts of UML models. These are the comments you may apply to describe , illuminate and

remark about any element in a model. There is one primary kind of Annotational thing:

Note

Note:-A note is simply a symbol for rendering constraints and comments attached to an element or a collection of elements.

Notation:- Note is added here for additional information

BACK

A relationship is a connection among 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:-

Generalization:-A relationship between a general thing (called “parent” or “super class”)

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 super class)

Realization:-A semantic relationship between two things wherein one specifies the

behavior to be carried out, and the other carries out the behavior.

Notation:-

(arrow-head points to the thing being realized)

BACK

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

State chart Diagram Activity Diagram Component Diagram Deployment Diagram

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.

Sequence Diagram - models the flow of control by time-ordering; 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.

State chart Diagram - shows the different state machines and the events

that leads to each of these state machines. State chart diagrams show the

flow of control from state to state.

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.

BACK

BACK