Transcript Object-Oriented Design Patterns

OO Design Patterns
Overview: Creational, Structural and
Behavioral Patterns for OO Design
Svetlin Nakov
Technical Trainer
www.nakov.com
Software University
http://softuni.bg
Table of Contents
1. What are Design Patterns?
2. Types of Design Patterns
3. Creational Patterns
4. Structural Patterns
5. Behavioral Patterns
6. Other Patterns
2
What are Design Patterns?
Name, Problem, Solution and Consequences
What is a Design Pattern?
 Software design pattern

Reusable solutions to common problems in software design

Problem / solution pairs within a given context

A template or recipe for solving certain software design problems
 GoF patterns

Classical object-oriented design patterns book
by Gama, Helm, Johnson, Vlissides 1995

The "Gang of Four Book"

Creational, structural and behavioural patterns
4
Elements of Design Patterns
 Design patterns are described by a few essential elements:

Pattern Name


Problem


Intent, context, when to apply
Solution


Increases vocabulary of designers
UML-like structure, abstract code
Consequences

Results and tradeoffs
5
Types of Design Patterns
Three Main Types of OO Design Patterns
 Creational patterns

Deal with initializing and configuring classes and objects
 Structural patterns

Describe ways to assemble objects to implement a new functionality

Composition of classes or objects
 Behavioral patterns

Deal with dynamic interactions among societies of classes and objects

How they distribute responsibilities
7
Creational Patterns
Creational Patterns
 Deal with object creation mechanisms
 Trying to create objects in a manner suitable to the situation
 Instead of "new
SomeClass()" use "pattern.Create()"
 Composed of two dominant ideas
 Encapsulating
knowledge about which concrete classes the system
uses
 Hiding how instances of these concrete classes are created and
combined
9
Singleton Pattern
 The Singleton class is a class that is supposed to have only one
(single) instance
 Usually created on demand (lazy loading)
 Sometimes Singleton is wrongly thought of as a global variable
 It is not!
 Possible problems:
 Thread-safe
10
Singleton – Example
public sealed class Singleton
{
private Singleton() { }
private static readonly Singleton instance = new Singleton();
public static Singleton Instance
{
get
{
return instance;
}
}
}
11
Factory
 In object-oriented programming, a Factory is an object for
creating other objects (alternative constructor)
 Not a GoF pattern; often mistaken with the Factory Method
 Traditional object creation: new + constructor call
DateTime t = new DateTime(2014, 10, 16);
 Creating objects through factory (usually a static method):
DateTime t = DateTime.Now;
Color c = Color.FromArgb(120, 255, 0, 0);
12
Factory – Example
public class Complex
{
private double real;
private double imaginary;
public static Complex FromPolarFactory(double modulus, double angle)
{
return new Complex(
modulus * Math.Cos(angle), modulus * Math.Sin(angle));
}
private Complex(double real, double imaginary)
{
this.real = real;
this.imaginary = imaginary;
}
}
Complex complexNum = Complex.FromPolarFactory(1, Math.PI / 3);
13
Factory: Variants
 Factories may have many variants
 Static / non-static method for creating products
 Return the product class / product subclass
 Factory inside / outside the product class
 Example:
 Coffee class – holds a mix of coffee and milk
 CoffeeFactory class – creates coffee, cappuccino / macchiato

Depending on the coffee type requested
14
Factory Method Pattern
 Factory Method
 Creates objects without specifying their exact class
 Crates subclasses, but returns the base abstract class / interface
 Benefits
 Allows adding new
subclasses later
 Easier extensibility
 Better maintainability
15
Factory Method – Example
public abstract class Product { … }
public class Chair : Product { … }
public class Table : Product { … }
public abstract class ProductCreator
{
public abstract Product CreateProduct();
}
public class TableCreator : ProductCreator
{
public override Product CreateProduct() { return new Table(…); }
}
public class ChairCreator : ProductCreator
{
public override Product CreateProduct() { return new Chair(…); }
}
16
Structural Patterns
Structural Patterns
 Structural patterns describe ways to assemble objects to
implement a new functionality
 Define how different classes and objects are combined to form
larger structures
 Structural class patterns use inheritance to compose interfaces or
implementations
 Structural object patterns compose objects for new functionality
 Examples of structural design patterns:
 Composite, Decorator, Façade, Adapter, Bridge, Proxy
18
Façade Pattern
 Façade provides a simplified interface to a larger body of code
 Higher level interface hides the complexity of subsystems
 Similar pattern: Adapter – converts between interfaces
19
Façade – Example
interface IAESFacade
{
string AESEncrypt(string
byte[] AESEncrypt(byte[]
byte[] AESDecrypt(byte[]
string AESDecrypt(string
}
class AESFacade
{
public string
public byte[]
public byte[]
public string
}
message, string password);
bytesToBeEncrypted, string password);
bytesToBeDecrypted, string password);
encryptedMessage, string password);
: IAESFacade
AESEncrypt(string
AESEncrypt(byte[]
AESDecrypt(byte[]
AESDecrypt(string
message, string password)
bytes, string password) {
bytes, string password) {
msg, string password) { …
{ … }
… }
… }
}
20
Composite Pattern
 Composite Pattern allows to combining different types of
objects in tree structures
 Treats the same individual
objects or groups of objects
 Example:
 Build a document system
 Used when
 You have different objects and
you want to treat them the same way
 You want to present a hierarchy of objects
21
Composite – Example
public interface IComponent { … }
public interface ICompositeComponent : IComponent
{
void Add(Component page);
void Remove(Component page);
}
public class Commander : ICompositeComponent
{
private ICollection<Component> childComponents =
new List<Component>();
public override void Add(Component component)
{ this.childComponents.Add(component); }
public override void Remove(Component component)
{ this.childComponents.Remove(component); }
}
22
Composite – Real World Examples
 Controls in Windows Forms
 Class System.Windows.Forms.Control holds child controls
 Properties Controls, HasChildren, …
 Controls in ASP.NET Web Forms
 Class System.Web.UI.Control holds child controls
 Property Controls
 Controls in AWT / Java Swing
 Classes java.awt.Component, java.awt.Container
23
Decorator Pattern
 Decorator adds responsibilities to objects dynamically
 Wrapping original component
 Alternative to inheritance (class explosion)
 Supports the Open-Closed principle
24
Decorator – Example
public abstract class Pizza
{
public abstract string GetDescription();
public abstract decimal GetPrice();
}
public class TomatoSaucePizza : Pizza
{
private Pizza basePizza;
public TomatoSaucePizza(Pizza pizza)
{ this.basePizza = pizza; }
public override string GetDescription()
{ return this.basePizza.GetDescription() + " + Tomato Sauce"; }
public override decimal GetPrice()
{ return basePizza.GetPrice() + 0.60m; }
}
25
Decorator – Real World Examples
 BufferedStream in .NET decorates Stream
 CryptoStream decorates Stream
CryptoStream crStream = new CryptoStream(stream,
encryptor, CryptoStreamMode.Write);
 BufferedReader in Java
BufferedReader bufferedReader =
new BufferedReader(
new InputStreamReader(
new FileInputStream(
new File("file_name.txt"))));
26
Adapter Pattern
 Adapter converts the given class' interface into another class
requested by the client
 Wrap an existing class with a new interface
 Impedance match an old component to a new system
 Allows classes to work together when this is impossible due to
incompatible interfaces
27
Adapter – Example
Legacy class
class ChemicalDatabank
{
public float GetMolecularStructure(string compound) {…}
…
}
interface ICompound
{
void Display();
}
Needed interface
public RichCompound : ICompound
{
public RichCompound(string compound) {
var chemicalBank = new ChemicalDatabank();
}
Adapter class
public void Display() {…}
}
28
Behavioral Patterns
Behavioral Patterns
 Behavioral patterns are concerned with communication
(interaction) between the objects
 Either with the assignment of responsibilities between objects
 Or encapsulating behavior in an object and delegating requests to it
 Increase flexibility in carrying out cross-classes communication
 Classical behavioral patterns:
 Chain of Responsibility,
Command, Interpreter, Iterator, Mediator,
Memento, Null Object, Observer, State, Strategy, Template
Method, Visitor
30
Iterator Pattern
 Iterator allows access to the elements of a complex object
without revealing its actual presentation
 Various ways of data structure traversing
 Unified interface for iterating over various data structures
31
Iterator – Example
public interface IEnumerator {
bool MoveNext();
object Current { get; }
void Reset();
}
public interface IEnumerable {
IEnumerator GetEnumerator();
}
private class ConcreteEnumerator : IEnumerator {
// Implement IEnumerator interface
}
var enumerator = someObject.GetEnumerator();
enumerator.Reset();
while (enumerator.MoveNext()) {
// Process the enumerator.Current
}
32
Iterator – Real World Examples
 IEnumerable<T> / foreach in C#
IEnumerator<T> GetEnumerator()
{
foreach(var element in this.array)
{
yield return element;
}
}
 Iterable<T> in Java
public boolean hasNext() {
if (count < str.length()) { return true; }
else return false;
}
public Character next() {
return str.charAt(count++);
}
33
Template Method Pattern
 Template Method defines the base of an algorithm in a method,
leaving some implementation to its subclasses
 Allows the subclasses to redefine the implementation of some of
the parts of the algorithm
 Doesn’t let the subclasses to change the algorithm structure
34
Template Method – Example
public abstract class HotDrink {
public void PrepareRecipe()
{
BoilWater(); Brew(); PourInCup(); AddSpices();
}
protected abstract void Brew();
Implemented by subclasses
protected abstract void AddSpices();
private void BoilWater() { ... }
private void PourInCup() { ... }
}
public class Coffee : HotDrink {
protected override void Brew() { ... }
protected override void AddSpices() { ... }
}
public class Tea : HotDrink {
protected override void Brew() { ... }
protected override void AddSpices() { ... }
}
35
Template Method – Real World Examples
 Thread.run() in Java
Thread thread = new Thread(){
public void run() {
System.out.println("Thread is running.");
}
};
thread.start();
 Thread.Start() in .NET
Thread thread = new Thread(
() => Console.WriteLine("Thread is running."));
thread.Start();
36
Observer Pattern
 Observer presents interface, allowing object to communicate
without any concrete knowledge about each other
 Also known as Publish-Subscribe pattern
 Object to inform other object about its state, without the
knowledge which are these objects
37
Observer – Real World Examples
 Events and event handlers in .NET
 Events sources (components) publish events (e.g. Button)
 Events in .NET provide subscribing mechanisms (e.g. Click)
 java.util.Observable / java.util.Observer
 Classical observer pattern
 ActionListener in Java
 java.awt.event.ActionListener has actionPerformed()
 java.awt.Button has addActionListener()
38
Strategy Pattern
 Strategy encapsulates an algorithm inside a class
 Making each algorithm replaceable by others

All the algorithms can work with the same data transparently

The client can transparently work with each algorithm
39
Strategy Pattern – Example
abstract class SortStrategy {
public abstract void Sort(IList<object> list);
}
class QuickSort : SortStrategy {
public override void Sort(IList<object> list) { … }
}
class MergeSort : SortStrategy {
public override void Sort(IList<object> list) { … }
}
class SortedList {
private IList<object> list = new List<object>();
public void Sort(SortStrategy strategy) {
// sortStrategy can be passed in constructor
sortStrategy.Sort(list);
}
}
40
Strategy – Real World Examples
 IComparer<T>, Cloneable<T> in .NET
 Sorting uses IComparer<T> as strategy for comparing items
 The Cloneable<T> is a strategy for cloning objects
 Comparer<T> in Java
 Sorting uses Comparer<T> as strategy for comparing items
 TreeMap<K, V> uses Comparer<T> as strategy for ordering the
tree nodes
41
Architectural Patterns
Architectural Patterns
 Client-Server Model – client ↔ server
 3-tier Architecture – front-end ↔ logic tier ↔ back-end
 Multi-tier Architecture
 Model-View-Controller (MVC) – for creating UI
 Model-View-Presenter (MVP) – for creating UI
 Model-View-ViewModel (MVVM) – for creating UI
 Front Controller – for dispatching requests in Web applications
 Active Record – wrap database tables in classes + CRUD operations
43
Summary
 Design patterns

Reusable solutions for common OO design problems
 Creational patterns

Singleton, Factory, Factory Method
 Structural patterns

Façade, Composite, Decorator, Adapter
 Behavioral patterns

Iterator, Observer, Template Method, Strategy
44
OO Design Patterns
?
https://softuni.bg/courses/oop/
License
 This course (slides, examples, demos, videos, homework, etc.)
is licensed under the "Creative Commons AttributionNonCommercial-ShareAlike 4.0 International" license
 Attribution: this work may contain portions from

"OOP" course by Telerik Academy under CC-BY-NC-SA license
46
SoftUni Diamond Partners
Free Trainings @ Software University
 Software University Foundation – softuni.org
 Software University – High-Quality Education,
Profession and Job for Software Developers

softuni.bg
 Software University @ Facebook

facebook.com/SoftwareUniversity
 Software University @ YouTube

youtube.com/SoftwareUniversity
 Software University Forums – forum.softuni.bg