ECM 2414 Design Patterns

Question 1

What is a design pattern

Answer 1

Design patterns are meant to provide a general reusable solution to one type of problems during software development –
they provide an architecture.

Question 2

Object Oriented Design Principles

Answer 2

 Identify the aspects of your application that vary and separate them from
what stays the same
 Program to an interface, not an implementation
 Favor ‘object composition’ over class inheritance

Question 3

3 key types of design patterns

Answer 3

Creational
Structural
Behavioural

Question 4

Factory Pattern

Answer 4

A Creational Design Pattern

“Defines an interface for creating an object, but lets subclasses decide which class to instantiate. It lets a class defer instantiation
to subclasses.”

We provide a creator, but make the class abstract. The concrete classes that extend the creator class provide a concrete implementation of the factory method (often parametrised)

Question 5

Abstract Factory Pattern

Answer 5

“Provides an interface for creating families of related or dependent objects without specifying their concrete classes.”

Question 6

Factory vs Abstract Factory

Answer 6

Both used for object creation

Factory Pattern uses inheritance and gives you a complete object in one shot

Abstract Factory Pattern uses composition and returns a family of related classes

Question 7

Inheritance

Answer 7

extend a class and override a factory method

Question 8

Composition

Answer 8

defines an abstract type for creating a family of products and lets subclasses decide how those products are produced

Question 9

Builder Pattern

Answer 9

A creational design pattern

“Separates the construction of a complex object from its representation so that the same construction processes can create
different representations”

• Let you vary a product’s internal representation
• Isolate code for construction and representation
• Finer control over the construction process

Question 10

How does builder pattern work

Answer 10

• the builder specifies the interface for creating parts of the complex (Product) object
• the ConcreteBuilder objects create and assemble the parts that make up the Product through the Builder interface
• the director object takes responsibility for the construction process of the complex object, however it delegates the actual creation and assembly to the builder interface.
• the product represents the complex object that is created by the ConcreteBuilder object(s). The Produt consists of multiple parts that are created separately by the ConcreteBuilder objects

Question 11

Builder Pattern Benefits

Answer 11

• Encapsulates the way a complex object is constructed
• Allows objects to be constructed in a multistep and varying process (as opposed to one-step factories)
• Hides the internal representation of the product from the client

Question 12

Singleton Pattern

Answer 12

A creational Design Pattern

“Ensures that a class has only one instance, and provides a global point of access to it.”

The Problem: Want to have just a single instance of an object

Examples
- Window managers
- File systems
- Print spoolers

Question 13

How to create a Singleton pattern

Answer 13

Static member: Create a private static variable of the Singleton class. This is the only instance of Singleton class

Private constructor: Create a private constructor for making sure an outer class can NOT instantiate object from the Singleton class

Static public method: Create a global point of access to get a Singleton instance

This object may be resource hungry and not always used, so there is a cost to its implementation

Question 14

Eager Initialisation

Answer 14

the instance of singleton class is created at the time of class loading

Question 15

Lazy Initialisation

Answer 15

The singleton class employs a technique known as lazy instantiation to create the singleton, to ensure that the singleton instance is not created until the getInstance() method is called for the first time

Question 16

Thread Safe Singleton

Answer 16

The easier way to create a thread-safe singleton class is to make the global access method synchronized, so that only one thread can execute this method at a time.

To avoid this extra overhead everytime, double checked locking principle is used

The synchronized block is used inside the if condition with an additional check to ensure that only one instance of singleton class is created

Question 17

Decorator Pattern

Answer 17

A Structural Pattern

“Attaches additional behavioural responsibilities to an object dynamically. Decorators provide a flexible alternative to subclassing for extending functionality”

The concrete component of an abstract class gets wrapped in a number of decorators that affect its attributes

Question 18

Decorator facts

Answer 18

• You can use one or more decorators to wrap an object
• Decorators have the same supertype as the objects they decorate
  
  • So we can pass around a decorated object in place of the original object
• Objects can be decorated at any time, so we can perform dynamic runtime decoration
• Behaviour comes through the composition of decorators with the base components (and other decorators)
• Some limitations
  
  • Takes time and effort
  • Introduces new levels of abstraction to the object composition

Question 19

The Command Pattern

Answer 19

A Behavioural Design Pattern

“Encapsulates a request as an object, thereby letting you parameterise other objects with different requests, queue or log requests, and support undoable operations”

The client sets up the remote control/radio, such that a Receiver is bound to a particular ConcreteCommand

The Invoker then interacts with the button and the behaviour that results is therefore determined by the client

This pattern is widespread in GUI design

Question 20

Command Pattern Invoke

Answer 20

Holds a command and at some point asks the command to carry out a request by calling its execute() method

Question 21

Command Pattern Command

Answer 21

Command: declares interface for all commands (concrete implementors therefore interchangeable)

Question 22

Command Pattern ConcreteCommand

Answer 22

fines the binding between an action and a Receiver. Once bound (due to work by the Client) the Invoker can make a request of its Command object (execute())– resulting in the ConcreteCommand calling one or more actions on the Receiver

Question 23

Command pattern receiver

Answer 23

Performs the work required to carry out the request.
Effectively any class can act as a Receiver.

Question 24

Command Pattern Client

Answer 24

Responsible for instantiating the ConcreteCommand and setting its Receiver

Question 25

Factory pattern quick summary

Answer 25

constructs a complete object in one step

Question 26

Abstract factory pattern quick summary

Answer 26

creates a family of related classes

Question 27

builder pattern quick summary

Answer 27

constructs a complex object (with parts) step by step

Question 28

singleton pattern quick summary

Answer 28

creates just a single instance of a class

Question 29

Decorator pattern quick summary

Answer 29

dynamically attaches additional functionalities

Question 30

Command pattern quick summary

Answer 30

encapsulates a request as an object