design patterns

Question 1

what are design patterns

Answer 1

reusable solutions to common problems that occur in software design

Question 2

what are the 4 elements of a design pattern

Answer 2

name; description of the pattern in 2 or less words
problem; when you should use the pattern
solution; elements that make up the design and interactions responsibilities and relationships
consequences; trade offs of using the pattern

Question 3

what are the 3 categories of design patterns

Answer 3

creational; techniques to create objects
structural; how classes are imposed in larger structures
behavioural; communication between objects

Question 4

what is the observer design pattern

Answer 4

behavioural design pattern that allows you to define a subscription mechanism to notify other objects about any changes made in the object their observing

Question 5

subject/publisher

Answer 5

the object that is changing state and informs observers

Question 6

observers/subscribers

Answer 6

dynamically attached to the subject and can subscribe to event notifications

Question 7

subject as an abstract class

Answer 7

abstract class defines add remove and notify observers
the concrete subject extends the abstract class
the concrete observer implements the observer interface and registers with concrete subjects to receive updates

Question 8

subject as an interface

Answer 8

can add remove and notify observers
the concrete subject implements this and keeps a list of the observers and notifies them
the concrete observer implements the observer interface and registers with concrete subjects to receive updates

Question 9

what is an adaptor design pattern

Answer 9

structural design pattern that converts the interface of a class into an interface that the client expects

Question 10

what are the 4 classes needed for the adaptor

Answer 10

client; who wants to use the interface
target; the interface that the client uses
adaptor; adapts the adaptee to the target interface
adaptee; the existing interface that needs changing

Question 11

class adaptor

Answer 11

adaps the adaptee by inheriting it and implementing the target interface

Question 12

object adaptor

Answer 12

relies on composition
the adaptor implements the target interface and contains the adaptee instance to which it forwards the request

Question 13

proxy

Answer 13

provides a placeholder for a real object to control access to it

Question 14

what are 3 reasons for using proxies

Answer 14

authenticates a client
can create the subject on demand and only when needed
can stand in for something complex elsewhere

Question 15

how does a proxy work (implementation)

Answer 15

both the proxy and the subject classes implement the subject interface whilst the proxy keeps an instance of the real subject
when the client wants to access the object it has to go through the proxy which requests the real object

Question 16

remote proxy

Answer 16

provides a local representation for an object in a different address space

Question 17

protection proxy

Answer 17

validates access to the object
the proxy keeps an instance to the object which the client can only access through the proxy

Question 18

virtual proxy

Answer 18

enables the creation of expensive objects on demand
not all data from storage is loaded into memory when the object is called instead a list is kept of currently needed data therefore you only need to open the file when you need to add something to it

Question 19

builder

Answer 19

separates the creation of a complex object from its implementation so that the process can be used to create different representations

Question 20

how does a builder work

Answer 20

individual steps are separated into different methods and the director object specifies the steps in the correct order and different valued can be passed into the methods which will lead to different outcomes

Question 21

flyweight

Answer 21

optimising memory usage by sharing a common state amongst multiple objects

Question 22

how does a flyweight work

Answer 22

the flyweight interface has methods that the objects must have; unique data
the concrete implementation has objects that store shared data that can be used by many objects
the flyweight factory manages a pool of flyweight objects reusing them and only making new ones when necessary
the client passes in unique data whilst shared data stays the same