Object-oriented design: GRASP patterns

J.Serrat
102759 Software Design
http://www.cvc.uab.es/shared/teach/a21291/web/

June 23, 2014

Index
1

Design & principles

GRASP

Expert

Creator

Low coupling

High cohesion

Controller

Polymorphism

Pure fabrication

Design & principles

GRASP

Expert

Creator

Low coupling

High cohesion

Controller

Polymorphism

Pure fabrication

Whats software design ?

Design is
Turning a specification for computer software into operational
software.
Links requirements to coding.
One further step from the problem space to the
computer-based solution
Object design
After identifying your requirements and creating a domain model,
add methods to the software classes, and define the messaging
between the objects to fulfil the requirements.

3 / 63

Design & principles

GRASP

Expert

Creator

Low coupling

High cohesion

Controller

Polymorphism

Pure fabrication

Whats software design ?

Design is needed at several different levels of detail in a system:
system
subsystems or packages: user interface, data
storage, application-level classes, graphics . . .
classes within packages, class relationships, interface of each class: public methods
attributes, private methods, inner classes . . .
source code implementing methods

4 / 63

Design & principles

GRASP

Expert

Creator

Low coupling

High cohesion

Controller

Polymorphism

Pure fabrication

How to design object-oriented ?

Start from OO analysis, problem domain classes

Add methods and define the messaging between them to fulfill
the requirements
New classes will appear, belonging to the software domain
Deciding what methods belong where, and how the
objects should interact, is terribly important and anything
but trivial.
Craig Larman

5 / 63

Design & principles

GRASP

Expert

Creator

Low coupling

High cohesion

Controller

Polymorphism

Pure fabrication

How to design object-oriented ?

Theres no a methodology to get the best object-oriented design,
but there are principles, patterns, heuristics.
Design patterns
bridge
strategy

singleton

visitor

Principles

decorator
...

substitution
single
responsibility
favor
composition
over
inheritance

GRASP
patterns

open-closed

don't repeat
yourself
Encapsulation
Information hiding
Abstraction
Inheritance
Composition

6 / 63

Design & principles

GRASP

Expert

Creator

Low coupling

High cohesion

Controller

Polymorphism

Pure fabrication

Why follow principles and patterns ?

They are best practices found after decades of experience by many
developers.

To build (more) change resistant designs.

Learn [to design objects] from the successes of others, not from
their failures

Read Symptoms of rotting design: rigidity, fragility, immobility,

viscosity in the article Design Principles and Design Patterns by
Robert C. Martin, 2000 at http://objectmentor.com/
resources/articles/Principles_and_Patterns.pdf.
7 / 63

Design & principles

GRASP

Expert

Creator

Low coupling

High cohesion

Controller

Polymorphism

Pure fabrication

Why follow principles and patterns ?

The design of many software applications begins as a
vital image in the minds of its designers. At this stage it
is clean, elegant, and compelling.
But then something begins to happen. The software
starts to rot. At first it isnt so bad. An ugly wart here, a
clumsy hack there. Yet, over time as the rotting
continues, the ugly festering sores and boils accumulate
until they dominate the design of the application. The
program becomes a festering mass of code that the
developers find increasingly hard to maintain.
Eventually, the sheer effort required to make even the
simplest of changes to the application becomes so high
that the engineers and front line managers cry for a
redesign project.
8 / 63

Design & principles

GRASP

Expert

Creator

Low coupling

High cohesion

Controller

Polymorphism

Pure fabrication

Why follow principles and patterns ?

What kind of changes cause designs to rot? Changes
that introduce new and unplanned for dependencies.
Each of the four symptoms is caused by improper
dependencies between the software modules. It is the
dependency architecture that is degrading, and with it
the ability of the software to be maintained.
(...) the dependencies between modules in an
application must be managed. This management consists
of the creation of dependency firewalls. Across such
firewalls, dependencies do not propagate.
Object Oriented Design principles build such firewalls
and manage module dependencies.
R.C. Martin, 2000
9 / 63

Design & principles

GRASP

Expert

Creator

Low coupling

High cohesion

Controller

Polymorphism

Pure fabrication

Whats ahead
Principles :
GRASP patterns :
Expert
Creator
High Cohesion
Low Coupling
Controller
Polymorphism
Pure
Fabrication

Dont repeat yourself

Liskov substitution
Single Responsibility
Information hiding
Open for extension, closed for
modification
Program to an interface, not to an
implementation
Favor composition over inheritance

Plus 23 design patterns.

10 / 63

Design & principles

GRASP

Expert

Creator

Low coupling

High cohesion

Controller

Polymorphism

Pure fabrication

GRASP patterns
Pattern
A named pair (problem, solution) plus advice on when/how to
apply it and discussion of its trade-offs. In our case, solves an
objectoriented generic design problem.
GRASP: General Responsibility Assignment Software Patterns
Principles of responsibility assignment, expressed as patterns.
Responsibility of an object/class is doing or knowing
creating an object or doing a calculation
initiating an action or controlling activities in other objects
knowing about private, encapsulated data
reference or contain other objects
know how to get or calculate something
11 / 63

Design & principles

GRASP

Expert

Creator

Low coupling

High cohesion

Controller

Polymorphism

Pure fabrication

GRASP patterns: conducting example

Point of Sale :
Application for a shop, restaurant,
etc. that registers sales.
Each sale is of one or more items
of one or more product types, and
happens at a certain date.
A product has a specification
including a description, unitary
price and identifier.
The application also registers
payments (say, in cash) associated
to sales.
A payment is for a certain amount,
equal or greater that the total of
the sale.
12 / 63

Design & principles

GRASP

Expert

Creator

Low coupling

High cohesion

Controller

Polymorphism

Pure fabrication

GRASP patterns
Make a class design

Not really a design, because there are no methods! Designs must

represent how to do something: register sales and payments.

Design & principles

GRASP

Expert

Creator

Low coupling

High cohesion

Controller

Polymorphism

13 / 63

Pure fabrication

GRASP patterns

Responsibilities are implemented through one or more methods,

that may collaborate (send messages to = call methods of) other
objects.
Recall : deciding what methods belong where, and how the
objects should interact, is terribly important and anything but
trivial.

14 / 63

Design & principles

GRASP

Expert

Creator

Low coupling

High cohesion

Controller

Polymorphism

Pure fabrication

GRASP patterns : Expert

Expert
Problem
What is a general principle of assigning responsibilities to classes ?
Solution
Assign responsibility to the information expert, the class that has
the information necessary to fulfil the responsibility.

15 / 63

Design & principles

GRASP

Expert

Creator

Low coupling

High cohesion

Controller

Polymorphism

Pure fabrication

GRASP patterns : Expert

Whos responsible for knowing the grand total of a Sale ?

16 / 63

Design & principles

GRASP

Expert

Creator

Low coupling

High cohesion

Controller

Polymorphism

Pure fabrication

GRASP patterns : Expert

17 / 63

Design & principles

GRASP

Expert

Creator

Low coupling

High cohesion

Controller

Polymorphism

Pure fabrication

GRASP patterns : Expert

1
2
3
4
5
6
7
8
9
10
11
12

public class Sale {

//...
public double getTotal(){
double total = 0;
for (SalesLineItem s : salesLineItem) {
ProductSpecification prodspec
= s.getProductSpecification();
total += s.getQuantity()*prodspec.getPrice();
}
return total;
}
}

Is this right ?

18 / 63

Design & principles

GRASP

Expert

Creator

Low coupling

High cohesion

Controller

Polymorphism

Pure fabrication

GRASP patterns : Expert

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18

public class Sale {

//...
public double getTotal(){
double total = 0;
for (SalesLineItem s : salesLineItem) {
total += s.getSubTotal();
}
return total;
}
}
public class SalesLineItem {
//...
public double getSubTotal(){
return this.getQuantity()
* productSpecification.getPrice();
}
}

19 / 63

Design & principles

GRASP

Expert

Creator

Low coupling

High cohesion

Controller

Polymorphism

Pure fabrication

GRASP patterns : Expert

20 / 63

Design & principles

GRASP

Expert

Creator

Low coupling

High cohesion

Controller

Polymorphism

Pure fabrication

GRASP patterns : Expert

Fulfilment of a responsibility may require information spread across
different classes, each expert on its own data.
Real world analogy: workers in a business, bureaucracy, military.
Dont do anything you can push off to someone else.
Benefits:
Low coupling: Sale doesnt depend on
ProductSpecification
More cohesive classes
Code easier to understand just by reading it

21 / 63

Design & principles

GRASP

Expert

Creator

Low coupling

High cohesion

Controller

Polymorphism

Pure fabrication

GRASP patterns : Expert

Not always convenient: problems of coupling and cohesion,
separation of concerns.

22 / 63

Design & principles

GRASP

Expert

Creator

Low coupling

High cohesion

Controller

Polymorphism

Pure fabrication

GRASP patterns : Creator

Creator
Problem
Who should be responsible for creating an instance of some class ?
Solution
Assign B the responsibility of create instances of A if
B aggregates or contains A objects
B closely uses A objects
B has the initializing data to be passed to the A constructor

23 / 63

Design & principles

GRASP

Expert

Creator

Low coupling

High cohesion

Controller

Polymorphism

Pure fabrication

GRASP patterns : Creator

Who should be responsible for creating a SalesLineItem from an
itemID and a quantity ?

24 / 63

Design & principles

GRASP

Expert

Creator

Low coupling

High cohesion

Controller

Polymorphism

Pure fabrication

GRASP patterns : Creator

Who should be responsible for creating a SalesLineItem from an
itemID and a quantity ?

25 / 63

Design & principles

GRASP

Expert

Creator

Low coupling

High cohesion

Controller

Polymorphism

Pure fabrication

GRASP patterns : Creator

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20

class Register{
ArrayList<Sale> sales = new ArrayList<Sale>();
//...
public void addItemToSale(Sale sale, int itemID,
int quantity) {
ProductSpecification prodSpec
= productcatalog.searchproductSpecification(itemID);
sale.addLineItem(prodSpec, quatity);
}
}
class Sale {
ArrayList<SalesLineItem> salesLineItem
= new ArrayList<SalesLineItem>();
//...
public void addLineItem(ProductSpecification prodSpec,
int quantity) {
salesLineItem.add(new SalesLineItem(prodSpec, quantity);
}
}
26 / 63

Design & principles

GRASP

Expert

Creator

Low coupling

High cohesion

Controller

Polymorphism

Pure fabrication

GRASP patterns : Creator

Benefits
Low coupling: anyway, the created class A has to know
(depend on) to the creator B
Exceptions
When creation is more complex, like instantiating objects of
different subclasses, or clone another object.

27 / 63

Design & principles

GRASP

Expert

Creator

Low coupling

High cohesion

Controller

Polymorphism

Pure fabrication

GRASP patterns : Creator

Traffic simulator application (old course assignment)
roads with one or more lanes
with entries, exits and different types of vehicles
each type of vehicle differs in a range of possible values for
length and maximum speed
when a vehicle is created, these two parameters get a random
value within their range

28 / 63

Design & principles

GRASP

Expert

Creator

Low coupling

High cohesion

Controller

Polymorphism

Pure fabrication

GRASP patterns : Creator

Entries E1, E2...throw vehicles to lanes, if traffic permits so.
Each entry must create each type of vehicle with its own
programmed frequency, like
E1 80% cars, 20% trucks
E2 50% cars, 30% trucks, 20% long trucks
...

29 / 63

Design & principles

GRASP

Expert

Creator

Low coupling

High cohesion

Controller

Polymorphism

Pure fabrication

GRASP patterns : Creator

30 / 63

Design & principles

GRASP

Expert

Creator

Low coupling

High cohesion

Controller

Polymorphism

Pure fabrication

GRASP patterns : Creator

Vehicles are created at Frequencies.getVehicle(), a

factory method
Creation means cloning a vehicle prototype from a list of
prototypes.
The prototype is chosen according to the lane frequencies
table.

31 / 63

Design & principles

GRASP

Expert

Creator

Low coupling

High cohesion

Controller

Polymorphism

Pure fabrication

GRASP patterns : Creator

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19

class Frequencies{
ArrayList<PrototipVehicle> prototips
= new ArrayList<PrototipVehicle>();
//...
public Vehicle getVehicle() {
double r = Math.random()*100.0;
double accumulatedFreq = 0.0;
iterator iter = prototips.Iterator();
while (iter.hasNext()) {
Prototip proto = (Prototip) iter.next();
double freq = proto.getFrequencia()
+ accumulatedFreq;
if ((r >= accumulatedFreq) && (r<freq)) {
return proto.getVehicle().clona(); // no clone()!
} else {
accumulatedFreq = freq;
}
}
}
32 / 63

Design & principles

GRASP

Expert

Creator

Low coupling

High cohesion

Controller

Polymorphism

Pure fabrication

GRASP patterns : Creator

Cloning is easy in Java: implement Cloneable interface and
call clone():
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15

public class Employee implements Cloneable{

private int empoyeeId;
private String employeeName;
private Department department;
public Employee(int id, String name, Department dept) {
this.empoyeeId = id;
this.employeeName = name;
this.department = dept;
}
@Override
protected Object clone() throws
CloneNotSupportedException {
return super.clone();
}
}
33 / 63

Design & principles

GRASP

Expert

Creator

Low coupling

High cohesion

Controller

Polymorphism

Pure fabrication

GRASP patterns : Creator

However, we want each clone of a prototype, to be different
from it in its length and max. speed attributes.
Therefore, we make a method clona() which calls the
constructor to get a vehicle of the right type with random
length and max. speed
1
2
3
4
5
6
7
8
9
10
11

public class Camio extends Vehicle {

protected static Rang rangLongitud = new Rang(8, 16);
protected static Rang rangVelMax = new Rang(120, 150);
public Camio(){
super(rangLongitud,rangVelMax);
}
@Override
public Vehicle clona() {
return new Camio();
}
}

(by the way, why static ?)

34 / 63

Design & principles

GRASP

Expert

Creator

Low coupling

High cohesion

Controller

Polymorphism

Pure fabrication

GRASP patterns : Low coupling

Coupling measures of how strongly an class is connected, depends,
relies on or has knowledge of objects of other classes.
Classes with strong coupling
suffer from changes in related classes
are harder to understand and maintain
are more difficult to reuse
But coupling is necessary if we want classes to exchange messages!
The problem is too much of it and/or too unstable classes.

35 / 63

Design & principles

GRASP

Expert

Creator

Low coupling

High cohesion

Controller

Polymorphism

Pure fabrication

GRASP patterns : Low coupling

Types of coupling

36 / 63

Design & principles

GRASP

Expert

Creator

Low coupling

High cohesion

Controller

Polymorphism

Pure fabrication

GRASP patterns : Low coupling

Problem
How to support low dependency, low change impact and increase
reuse ?

Solution
Assign responsibilities so that coupling remains low. Try to avoid
one class to have to know about many others.

37 / 63

Design & principles

GRASP

Expert

Creator

Low coupling

High cohesion

Controller

Polymorphism

Pure fabrication

GRASP patterns : Low coupling

Who should be responsible for creating a Payment for a Sale from
a handed amount ?

38 / 63

Design & principles

GRASP

Expert

Creator

Low coupling

High cohesion

Controller

Polymorphism

Pure fabrication

GRASP patterns : Low coupling

In the problem domain, Register knows about the handed

amount m. According to Creator,

39 / 63

Design & principles

GRASP

Expert

Creator

Low coupling

High cohesion

Controller

Polymorphism

Pure fabrication

GRASP patterns : Low coupling

Delegate to Sale : Register is not coupled anymore to Payment.

Sales is anyway in both cases (must be), because a Sale must
know its payment.

40 / 63

Design & principles

GRASP

Expert

Creator

Low coupling

High cohesion

Controller

Polymorphism

Pure fabrication

GRASP patterns : Low coupling

Who should own the method getBalance() that computes
payment amount - total of sale ?

41 / 63

Design & principles

GRASP

Expert

Creator

Low coupling

High cohesion

Controller

Polymorphism

Pure fabrication

GRASP patterns : Low coupling

Discussion
extreme low coupling: few big, complex, non-cohesive classes
that do everything, plus many objects acting as data holders
it is not coupling per se the problem but coupling to unstable
classes

42 / 63

Design & principles

GRASP

Expert

Creator

Low coupling

High cohesion

Controller

Polymorphism

Pure fabrication

GRASP patterns : High cohesion

Cohesion is a measure of how strongly related the responsibilities

of a class are. A class with low cohesion does many unrelated
things or too much work.
Problems: hard to
understand
maintain
reuse

43 / 63

Design & principles

GRASP

Expert

Creator

Low coupling

High cohesion

Controller

Polymorphism

Pure fabrication

GRASP patterns : High cohesion

Problem
How to keep classes focused, understandable and manageable ?
Solution Assign responsibilities so that cohesion remains high. Try
to avoid classes to do too much or too different things.

44 / 63

Design & principles

GRASP

Expert

Creator

Low coupling

High cohesion

Controller

Polymorphism

Pure fabrication

GRASP patterns : High cohesion

45 / 63

Design & principles

GRASP

Expert

Creator

Low coupling

High cohesion

Controller

Polymorphism

Pure fabrication

GRASP patterns : Controller

Classes do not need to represent just problem domain entities, but
also processes.
Problem Who should be responsible for handling an input event,
which object/s beyond the UI layer receives interaction ?

46 / 63

Design & principles

GRASP

Expert

Creator

Low coupling

High cohesion

Controller

Polymorphism

Pure fabrication

GRASP patterns : Controller

Solution A controller class representing the whole system or a

particular use case

47 / 63

Design & principles

GRASP

Expert

Creator

Low coupling

High cohesion

Controller

Polymorphism

Pure fabrication

GRASP patterns : Controller

Benefits
either the UI classes or the problem/software domain classes
can change without affecting the other side.
controller is a simple class that mediates between the UI and
problem domain classes, just forwards
event handling requests
output requests

48 / 63

Design & principles

GRASP

Expert

Creator

Low coupling

High cohesion

Controller

Polymorphism

Pure fabrication

GRASP patterns : Controller

HiLo game: read source code for Java + Swing at
GRASP Rod Byrne.pdf

49 / 63

Design & principles

GRASP

Expert

Creator

Low coupling

High cohesion

Controller

Polymorphism

Pure fabrication

GRASP patterns : Controller

50 / 63

Design & principles

GRASP

Expert

Creator

Low coupling

High cohesion

Controller

Polymorphism

Pure fabrication

GRASP patterns : Polymorphism

Polymorphic methods: giving the same name to (different) services

in different classes. Services are implemented by methods.
Problem
How to handle behavior based on type (i.e. class) but not with an
if-then-else or switch statement involving the class name or a tag
attribute ?

51 / 63

Design & principles

GRASP

Expert

Creator

Low coupling

High cohesion

Controller

Polymorphism

Pure fabrication

GRASP patterns : Polymorphism

52 / 63

Design & principles

GRASP

Expert

Creator

Low coupling

High cohesion

Controller

Polymorphism

Pure fabrication

GRASP patterns : Polymorphism

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17

static double ratioPerimeterToArea(Shape2D s) {

double ratio = 0.0;
if (s instanceof Triangle) {
// or String name = s.getClass().getName();
//
if (name=="Triangle") {
Triangle t = (Triangle) s;
ratio = t.perimeter()/t.area();
} else if (s instance of Circle) {
Circle c = (Circle) s;
ratio = c.perimeter()/c.area();
} else if (s instanceof Square) {
Square sq = (Square) s;
ratio = sq.perimeter()/sq.area();
}
return ratio;
}

53 / 63

Design & principles

GRASP

Expert

Creator

Low coupling

High cohesion

Controller

Polymorphism

Pure fabrication

GRASP patterns : Polymorphism

Problems:
new shapes and class name changes require the modification
of this kind of code
normally it appears at several places
avoidable coupling between Client and shape subclasses

54 / 63

Design & principles

GRASP

Expert

Creator

Low coupling

High cohesion

Controller

Polymorphism

Pure fabrication

GRASP patterns : Polymorphism

1
2
3

static double ratioPerimeterToArea(Shape2D s) {

return s.perimeter()/s.area();
}

55 / 63

Design & principles

GRASP

Expert

Creator

Low coupling

High cohesion

Controller

Polymorphism

Pure fabrication

GRASP patterns : Polymorphism

Write a class Expr to support the evaluation of arithmetic
expressions represented as trees:

56 / 63

Design & principles

GRASP

Expert

Creator

Low coupling

High cohesion

Controller

Polymorphism

Pure fabrication

GRASP patterns : Polymorphism

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18

public class NonPolyExpr {

public static final int CONST_EXPR = 1;
public static final int PLUS_EXPR = 2;
public static final int TIMES_EXPR = 3;
private int type;
private double value;
private NonPolyExpr left=null, right=null;
public NonPolyExpr( int type, double value ) {
this.type = type;
this.value = value;
}
public NonPolyExpr( int type, NonPolyExpr left,
NonPolyExpr right) {
this.type = type;
this.left = left;
this.right = right;
}

57 / 63

Design & principles

GRASP

Expert

Creator

Low coupling

High cohesion

Controller

Polymorphism

Pure fabrication

GRASP patterns : Polymorphism

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17

public double evaluate() {

switch( type ) {
case CONST_EXPR:
return value;
case PLUS_EXPR:
return left.evaluate() + right.evaluate();
case TIMES_EXPR:
return left.evaluate() * right.evaluate();
}
return java.lang.Double.NaN; // what is this?
}
}
NonPolyExpr a = new NonPolyExpr(NonPolyExpr.CONST_EXPR, 3.0);
NonPolyExpr b = new NonPolyExpr(NonPolyExpr.CONST_EXPR, 4.0);
NonPolyExpr c = new NonPolyExpr(NonPolyExpr.PLUS_EXPR,a,b);
System.out.print( c.evaluate() );

58 / 63

Design & principles

GRASP

Expert

Creator

Low coupling

High cohesion

Controller

Polymorphism

Pure fabrication

GRASP patterns : Polymorphism

Problems:
evaluate() is not cohesive as its polymorphic version
NonPolyExpr cannot be easily extended: unary (-) and
ternary operators (x ? y : z)
coupling: clients must know about expression types
CONST EXPR, PLUS EXPR, TIMES EXPR
it is legal to write non-sense code like
1
2
3

// a, b are NonPolyExpr objects

NonPolyExpr e = new NonPolyExpr(NonPolyExpr.CONST_EXPR,a,b);
System.out.print( e.evaluate() );

Exercise: write the polymorphic version.

59 / 63

Design & principles

GRASP

Expert

Creator

Low coupling

High cohesion

Controller

Polymorphism

Pure fabrication

GRASP patterns : Pure fabrication

Problem
What object should have a responsibility when no class of the
problem domain may take it without violating high cohesion, low
coupling ?
Not all responsibilities fit into domain classes, like persistence,
network communications, user interaction etc.

Remember what was the problem here

60 / 63

Design & principles

GRASP

Expert

Creator

Low coupling

High cohesion

Controller

Polymorphism

Pure fabrication

GRASP patterns : Pure fabrication

Solution
Assign a cohesive set of responsibilities to an artificial/convenience
class not representing a concept of the problem domain.

Exercise voltage divider

61 / 63

Design & principles

GRASP

Expert

Creator

Low coupling

High cohesion

Controller

Polymorphism

Pure fabrication

GRASP patterns : Pure fabrication

Later we will call this the strategy pattern.

62 / 63

Design & principles

GRASP

Expert

Creator

Low coupling

High cohesion

Controller

Polymorphism

Pure fabrication

GRASP patterns : Summary

What should you know
Whats design, object design and how to do it
What are responsibilities
Problem + solution of Expert, Creator GRASP patterns
Whats cohesion and coupling
Whats a controller class
Why instanceof is evil and how to avoid it
Whats a pure fabrication class and when to create them
Next: object-oriented design general principles

63 / 63