Design Patterns

Engr. Abdul-Rahman Mahmood

DPM, MCP, QMR(ISO9001:2000)

armahmood786@yahoo.com alphasecure@gmail.com
alphapeeler.sf.net/pubkeys/pkey.htm http://alphapeeler.sourceforge.net
pk.linkedin.com/in/armahmood http://alphapeeler.tumblr.com
www.twitter.com/alphapeeler armahmood786@jabber.org
www.facebook.com/alphapeeler alphapeeler@aim.com
abdulmahmood-sss alphasecure mahmood_cubix 48660186
armahmood786@hotmail.com alphapeeler@icloud.com
http://alphapeeler.sf.net/me http://alphapeeler.sf.net/acms/
Classes
A class is a description of a set of
objects that share the same attributes,
ClassName operations, relationships, and semantics.

Graphically, a class is rendered as a

attributes rectangle, usually including its name,
attributes, and operations in separate,
designated compartments.
operations
Class Names
The name of the class is the only required tag in the
ClassName graphical representation of a class. It always
appears in the top-most compartment.

attributes

operations
Class Attributes

Person

An attribute is a named property of a

name : String class that describes the object being modeled.
address : Address In the class diagram, attributes appear in
birthdate : Date the second compartment just below the
ssn : Id name-compartment.
Class Attributes (Cont’d)
Attributes are usually listed in the form:

Person attributeName : Type

A derived attribute is one that can be

computed from other attributes, but
name : String doesn’t actually exist. For example,
address : Address a Person’s age can be computed from
birthdate : Date his birth date. A derived attribute is
/ age : Date designated by a preceding ‘/’ as in:
ssn : Id
/ age : Date
Class Attributes (Cont’d)

Person

Attributes can be:

+ public
+ name : String
# protected
# address : Address
- private
# birthdate : Date
/ derived
/ age : Date
- ssn : Id
Class Operations

Person

name : String
address : Address
birthdate : Date
ssn : Id

Operations describe the class behavior

eat and appear in the third compartment.
sleep
work
play
 Class Operations (Cont’d)

PhoneBook

newEntry (n : Name, a : Address, p : PhoneNumber, d : Description)

getPhone ( n : Name, a : Address) : PhoneNumber

You can specify an operation by stating its signature: listing the name, type, and
default value of all parameters, and, in the case of functions, a return type.
Class Responsibilities
A class may also include its responsibilities in a class diagram.

A responsibility is a contract or obligation of a class to perform a particular

service.

SmokeAlarm

Responsibilities

-- sound alert and notify guard station

when smoke is detected.

-- indicate battery state

Relationships
In UML, object interconnections (logical or physical), are
modeled as relationships.

There are three kinds of relationships in UML:

• dependencies

• generalizations

• associations
Dependency Relationships
A dependency indicates a semantic relationship between two or
more elements. The dependency from CourseSchedule to Course exists
because Course is used in both the add and remove operations of
CourseSchedule.

CourseSchedule

Course

add(c : Course)
remove(c : Course)
Generalization Relationships

Person
A generalization connects a subclass
to its superclass. It denotes an
inheritance of attributes and behavior
from the superclass to the subclass and
indicates a specialization in the subclass
of the more general superclass.

Student
Generalization Relationships
UML permits a class to inherit from multiple superclasses, although some
programming languages (e.g., Java) do not permit multiple inheritance.

Student Employee

TeachingAssistant
Association Relationships
If two classes in a model need to communicate with each other, there must be
link between them.

An association denotes that link.

Student Instructor
Association Relationships
We can indicate the multiplicity of an association by adding multiplicity
adornments to the line denoting the association.

The example indicates that a Student has one or more Instructors:

Student Instructor
1..*
Association Relationships

The example indicates that every Instructor has one or more Students:

Student Instructor
1..*
Association Relationships
We can also indicate the behavior of an object in an association (i.e., the role
of an object)

teaches learns from

Student Instructor
1..* 1..*
Association Relationships
We can also name the association.

membership
Student Team
1..* 1..*
Association Relationships
We can specify dual associations.

member of

1..* Consists of 1..*

Student Team

1 president of 1..*
Association Relationships
We can constrain the association relationship by defining the navigability of
the association. Here, a Router object requests services from a DNS object by
sending messages to (invoking the operations of) the server. The direction of
the association indicates that the server has no knowledge of the Router.

Router DomainNameServer
Association Relationships
Associations can also be objects themselves, called link classes or an
association classes.

Registration

modelNumber
serialNumber
warrentyCode

Product Warranty
Association Relationships
A class can have a self association.

Class

Two instances of the same class:

Pilot
Aviation engineer
Association Relationships
We can model objects that contain other objects by way of special
associations called aggregations and compositions.

An aggregation specifies a whole-part relationship between an aggregate (a

whole) and a constituent part, where the part can exist independently from
the aggregate. Aggregations are denoted by a hollow-diamond adornment
on the association.
Association Relationships
A composition indicates a strong ownership and coincident lifetime of parts
by the whole (i.e., they live and die as a whole). Compositions are denoted
by a filled-diamond adornment on the association.

Scrollbar
1 1
Window Titlebar
1 1
Menu
1 1 ..
*
Interfaces
An interface is a named set of operations that
specifies the behavior of objects without
showing their inner structure. It can be
rendered in the model by a one- or two-
<<interface>>
compartment rectangle, with the stereotype
ControlPanel
<<interface>> above the interface name.
Interface Services

Interfaces do not get instantiated. They

<<interface>> have no attributes or state. Rather, they
ControlPanel specify the services offered by a related
class.
getChoices : Choice[]
makeChoice (c : Choice)
getSelection : Selection
Interface Realization Relationship
A realization relationship connects a
<<interface>> class with an interface that supplies
Printer its behavioral specification. It is
rendered by a dashed line with a
specifier hollow triangle towards the specifier.

<<interface>> <<interface>>
Paser Paser
implementation

Print Setup

HTML Parser JSON Parser

Relationships in Nutshell
 Dependency : class A
uses class B
 Aggregation : class A
has a class B
 Composition : class
A owns a class B
 Inheritance : class B
is a Class A (or class A
is extended by class B)
 Realization : class B
realizes Class A (or
class A is realized by
class B)
Dependency
 Dependency is represented when a reference to one
class is passed in as a method parameter to another
class. For example, an instance of class B is passed in to
a method of class A:

1public class A {
2
3 public void doSomething(B b) {
Aggregation
 Now, if class A stored the reference to class B for later
use we would have a different relationship called
Aggregation. A more common and more obvious
example of Aggregation would be via setter injection:

1public class A {
2
3 private B _b;
4
5 public void setB(B b) { _b = b; }
Composition
 Aggregation is the weaker form of object containment
(one object contains other objects). The stronger form
is called Composition. In Composition the
containing object is responsible for the creation and
life cycle of the contained object (either directly or
indirectly). Following are a few examples of
Composition. First, via member initialization:

1public class A {
1public class A {
2
2
3 private B _b;
3 private B _b = new B();
4
5 public A() {
6 _b = new B();
7 } // default constructor
Inheritance

1public class A {
2
3 ...
4
5} // class A
6
7public class B extends A {
8
9 ....
10
11} // class B
Realization
1public interface A {
2
3 ...
4
5} // interface A
6
7public class B implements A {
8
9 ...
10
11} // class B
Parameterized Class
A parameterized class or template
T
defines a family of potential elements.
LinkedList
To use it, the parameter must be bound.

T
1 .. *
A template is rendered by a small dashed
rectangle superimposed on the upper-right
corner of the class rectangle. The dashed
rectangle contains a list of formal
parameters for the class.
Example : Parameterized Class

class Set <T> {

void insert (T newElement);
void remove (T anElement);
Parameterized Class (Cont’d)
 Some object-oriented languages such as C++ and Ada
support the concept of parametrized classes.
 They are most commonly used for the element type of
collection classes, such as the elements of lists.
 For example, in Java, suppose that a Board software
object holds a List of many Squares. And, the concrete
class that implements the List interface is
an ArrayList:
public class Board
{
private List<Square> squares = new ArrayList<Square>();
// …
}
Parameterized Class (Cont’d)
T
LinkedList Binding is done with the <<bind>>
stereotype and a parameter to supply to
the template. These are adornments to
the dashed arrow denoting the realization
T relationship.
1..* Here we create a linked-list of names for
the Students List.

<<bind>>(Name)

StudentList
Enumeration

<<enumeration>> An enumeration is a user-defined data type

Boolean that consists of a name and an ordered list
of enumeration literals.
false
true
Exceptions
Exceptions can be modeled just
<<exception>>
like any other class.
Exception
Notice the <<exception>>
getMessage() stereotype in the name
compartment.
printStackTrace()

<<exception>> <<exception>>
InterfaceException SQLException