Design patterns illustrated-2015-03

Design Patterns
illustrated
Herman Peeren, March 17, 2015
(Design Patterns illustrations: Nelleke Verhoeff, 2010)
in this presentation I also used some UML-diagrams
from these handy UML-reference cards:
http://www.mcdonaldland.info/2007/11/28/40/

Design Patterns
●● recipes against common (OO-) programming problems
●● code reuse: no need to reinvent the wheel
●● common language
●● GOF: 23 “classical” patterns
classic,
The Book
四人帮

The one constant in software development:

CHANGE!

CHANGE!
I knew it ...

Ideal: code as modular black boxes

Single responsibility principle
Open for extension, closed for modification
Liskov subsitution principle
Interface segregation
Dependency inversion

It might get you into trouble...

some code smells:
►► duplicate code
►► long method
►► large class
►► combinatorial explosion
►► conditional complexity
►► switch statements
►► indecent exposure

Code often starts simple
But “grows”:
►► more methods in a class
►► longer methods
►► more if then but if then while x>0 or and etc.
►► more classes, that depends on other classes
and becomes more complex

Example: a shopping cart
►► implement putting products in the cart
►► start with some pay() method
►► if paypal then..., if iDEAL then...
►► let’s extract a payment interface
►► with several implementations (paypal, iDEAL, etc)
►► mutually exclusive choices
each choice is a “strategy” (hurray, our first pattern!)

Strategy pattern
For instance: different payment possibilities at checkout

Replace Conditional Logic with Strategy
if ($income <= 10000) {
return $income*0.365;
} else if ($income <= 30000) {
return ($income-10000)*0.2+35600;
} else //etc (...)
return ($income-60000)*0.02+105600;
} // note: mutual exclusive grouping
if ($income <= 100000) {
$strategy = new InsuranceStrategyLow($income);
} else if ($income <= 300000) {
$strategy = new InsuranceStrategyMedium($income);
} else //etc (...)
$strategy = new InsuranceStrategyVeryHigh($income);
}
return $strategy->calculateInsurance();
http://wiki.jetbrains.net/intellij/Replace_conditional_logic_with_strategy_pattern

Strategy
When something can be done in several ways, make those
ways interchangeable.
POSSI-
BILITIES
c©yepr

State example: states of a document
►► a draft doesn’t need a depublish() method
►► a published document doesn’t need a publish() method
or states of a shopping-cart
►► while shopping you don’t need a pay() method
►► but you need methods to put product in or out the cart
►► when paid you don’t need a pay() method
►► nor put_product_in_cart()

State
Let an object show other methods
after a change of internal state (as if it changes it’s class).
in a.....hick......different state,
....hick....I behave differently....hick.....
c© yepr

Bridge example: payment and payment providers

Bridge
Decouple an abstraction from its implementation.c
COLA
COLA
COLA
COLA
1 LITER
1 LITER
COLA
MILK
MILK
1 LITER
1 LITER
MILK
©yepr

Factory method example: different kinds of customers...

...with different kinds of invoices

Factory Method
Provide an interface for the creation of objects.
Allow subclasses to “decide” which class to instantiate.
c©yepr

Abstract factory example:
a Gold customer, cart, invoice, etc.

Abstract Factory
Povide an interface for creating families of related
or dependent objects. A factory for factories.
c©yepr

Building (complex) objects
Example: DI-container
Other example:
documentbuilder (for tree-like structures):
/$domtree = new DOMDocument(‘1.0’, ‘UTF-8’);
/* create the root element of the xml tree */
$xmlRoot = $domtree->createElement(“xml”);
/* append it to the document created */
$xmlRoot = $domtree->appendChild($xmlRoot);
$currentTrack = $domtree->createElement(“track”);
$currentTrack = $xmlRoot->appendChild($currentTrack);
// etc...

Builder
Seperate the construction process (how) of a complex object
from the concrete representations (what).
c©yepr

Encapsulate what doesn’t vary...

Template Method
The skeleton of an algorithm is fixed,
but parts can be filled in differently.
c©yepr

Add behaviour
►► but respect the Open-Closed principle

In PHP you can use __call to copy parent methods:
public function __call($method, $args) {
return call_user_func_array(
array($this->decoratedInstance, $method),
$args
);
}
N.B.: Magic functions are magic...
but come at a cost!

Decorator
Add extra functionallity (at runtime),
while keeping the interface the same.
Matroushka’s...
c©yepr

Visitor
Make a kind of plugin-possibility for methods:
in that way methods can be added in runtime.
printservice!
c©yepr

Composite
Create a tree structure for part-whole hierarchies.
A node is also a (part of a) tree. Recursive:
c©yepr

Unify interfaces with Adapter:
For instance: different payment gateways
(PayPal, iDEAL, Hipay, Moneybookers, etc.)
Instead of different interfaces
refactor to
one preferred interface
and write adapters for the others

Adapter (= Wrapper)
Adapt an interface to an expected interface.c©yepr

Proxy
Provide a surrogate or placeholder for another object
to control access to it.
c©yepr

Facade
Provide a general (simpler) interface for a set of interfaces.
looks
simple
c©yepr

Observer
Notify “subscribers” of changes.
WHO?
ME
ME
MENO
c©yepr

Mediator
Layer in between: communication via one object.c©yepr

Memento
Save and restore the internal state of an object.
ME
c©yepr

Chain of Responsibility
Define a method of passing a request among a chain of objects.c©yepr

A command is an object to execute 1 method
Decoupling (Symfony2) Forms from Entities:
http://verraes.net/2013/04/decoupling-symfony2-forms-from-entities/
Chain of Command: Chain of Responsability with Commands
Replace Conditional Dispatcher with Command
if ($actionName == NEW_WORKSHOP) {
//do a lot
} else if ($actionName == ALL_WORKSHOPS) {
// do a lot of other things
} // and many more elseif-statements
NewWorkshopHandler, AllWorkshopsHandler, etc.

Command
Encapsulate a command request in an object.c
YOU,DO YOUR
TASK!
LIGHT
OFF
LIGHT
ON
TASKTASK
©yepr

Flyweight
Use one instance of a class
to provide many “virtual” instances.
c©yepr

PHP: SPL iterators
►► http://www.php.net/manual/en/class.iterator.php
►► http://www.php.net/manual/en/spl.iterators.php
Stefan Froelich:
►► http://www.sitepoint.com/using-spl-iterators-1/
►► http://www.sitepoint.com/using-spl-iterators-2/
Anthony Ferrara video:
►► http://blog.ircmaxell.com/2013/01/todays-programming-with-anthony-vi-
deo.html

Iterator
Enable sequential access to collection elements, without showing
the underlying data-structures (array, list, records, etc)
nextnext
next
c©yepr

Replace implicit language with Interpreter:
search-methods including combinations:
►► belowPriceAvoidingAColor( )
►► byColorAndBelowPrice( )
►► byColorSizeAndBelowPrice( )
interpretable expression:
$productSpec =
new AndSpec(
new BelowPriceSpec(9.00),
new NotSpec(newColorSpec(WHITE))
);
“You don’t need an Interpreter for complex languages
or for really simple ones.” (Joshua Kerievsky)

Interpreter
Domain -> (little) language -> grammar -> objects (DSL)
he means:
do this, do that,
and after finishing it,
go there!
HÉ!HÉ!
c©yepr

Javascript:
var Person = function() { // bladibla };
var Customer = function(name) {
this.name = name;
};
Customer.prototype = new Person();
Prototype in PHP:
►► adding properties is easy
►► adding behaviour is less obvious, but...
►► CLOSURES can help here, with some (dirty) tricks

Singleton
Ensure a class only has one instance, and provide a global
point of access to it.
Oh, I’m so
loooooooonly
c©yepr

Singleton
Ensure a class only has one instance, and provide a global
point of access to it.
Did anybody say GLOBAL???
Oh, I’m so
loooooooonly
c
BANNED!
©yepr

“Every
advantage
has its
disadvantages”
(free to Johan Cruyff,
Dutch Football Pattern Designer
and Ajax-fan...)

Classic pattern categories
creational, structural and behavioral patterns:
►► creational: object instantiation
►► structural: larger structures of classes or objects
►► behavioral: interaction and distribution of responsibility

Other categorisations
Loek Bergman (dev. from Rotterdam):
►► transformational
►► transportational
►► translational
Anthony Ferrara:
►► Shim : not necessary (for PHP)
►► decompositional: breaking objects apart
►► compositional: making things simpler by assembling
http://loekbergman.nl/InsideArchitecture
http://blog.ircmaxell.com/2013/09/beyond-design-patterns.html

Creational design patterns
►► Factory Method: Allow subclasses to “decide” which class
to instantiate.
►► Abstract Factory: Encapsulate a set of analo-
gous factories that produce families of objects.
►► Builder: Encapsulate the construction of com-
plex objects from their representation; so, the
same building process can create various repre-
sentations by specifying only type and content.
►► Singleton: Ensure that only a single instance of
a class exists and provide a single method for
gaining access to it.
►► Prototype: Create an initialized instance for
cloning or copying.

Structural design patterns
●● Adapter: Adapt an interface to an expected interface.
●● Bridge: Decouple an interface from its implementation.
●● Composite: Create a tree structure for part-whole hierarchies.
●● Decorator: Extend functionality dynamically.
●● Facade: Simplify usage by defining a high-level interface.
●● Flyweight: Support fine-grained objects efficiently by sharing.
●● Proxy: Represent an object with another object for access control.

Behavioral design patterns
●● Chain of Responsibility: Define a method of passing a
request among a chain of objects.
●● Command: Encapsulate a command request in an object.
●● Interpreter: Allow inclusion of language elements in an appli-
cation.
●● Iterator: Enable sequential access to collection elements.
●● Mediator: Define simplified communication between classes.
●● Memento: Save and restore the internal state of an object.
●● Observer: Define a scheme for notifying objects of changes to
another object.
●● State: Alter the behavior of an object when its state changes.
●● Strategy: Encapsulate an algorithm inside a class.
●● Template Method: Allow subclasses to redefine the steps of
an algorithm.
●● Visitor: Define a new operation on a class without changing it.

Some books
GOF: 23 “classical” patterns:
classic,
The Book
fun!
good start

Dec. 2013
Simple
Febr.
2013
Selection
PHP-
examples
PHP and Design Patterns

Fowler:
architectural patterns
for
enterprise applications
Fowler: also
known from
refactoring
Kerievsky:
refactoring
to patterns
PEAA & Refactoring

Resign Patterns:
Ailments of Unsuitable Project-Disoriented Software

Questions?
Contact info:
Herman Peeren
herman@yepr.nl
© Yepr
Design Pattern Illustrations: Nelleke Verhoeff, Red Cheeks Factory, 2010
Creative Commons Public License for noncommercial use
http://creativecommons.org/licenses/by-nc/3.0/legalcode

Design patterns illustrated-2015-03

More Related Content

What's hot (20)

Viewers also liked (9)

Similar to Design patterns illustrated-2015-03 (20)

More from Herman Peeren (19)

Recently uploaded (20)

Design patterns illustrated-2015-03