When to use

Question 1

You want to use different variants of an algorithm within an object and be able to switch from one algorithm to another during runtime

Answer 1

Strategy

Question 2

You have a lot of similar classes that only differ in the way they execute some behavior.

Answer 2

Strategy

Question 3

You want isolate the business logic of a class from the implementation details of algorithms that may not be as important in the context of that logic.

Answer 3

Strategy

Question 4

Your class has a massive conditional statement that switches between different variants of the same algorithm.

Answer 4

Strategy

Question 5

Changes to the state of one object may require changing other objects, and the actual set of objects is unknown beforehand or changes dynamically.

Answer 5

Observer

Question 6

Some objects in your app must observe others, but only for a limited time or in specific cases.

Answer 6

Observer

Question 7

You need to be able to assign extra behaviors to objects at runtime without breaking the code that uses these objects.

Answer 7

Decorator

Question 8

It’s awkward or not possible to extend an object’s behavior using inheritance.

Answer 8

Decorator

Question 9

You don’t know beforehand the exact types and dependencies of the objects your code should work with.

Answer 9

Factory Method

Question 10

You want to provide users of your library or framework with a way to extend its internal components

Answer 10

Factory Method

Question 11

You want to save system resources by reusing existing objects instead of rebuilding them each time

Answer 11

Factory Method

Question 12

Your code needs to work with various families of related products, but you don’t want it to depend on the concrete classes of those products—they might be unknown beforehand or you simply want to allow for future extensibility

Answer 12

Abstract Factory

Question 13

You have a class with a set of Factory Methods that blur its primary responsibility

Answer 13

Abstract Factory

Question 14

You want to parametrize objects with operations

Answer 14

Command

Question 15

You want to queue operations, schedule their execution, or execute them remotely

Answer 15

Command

Question 16

You want to implement reversible operations

Answer 16

Command

Question 17

You want to use some existing class, but its interface isn’t compatible with the rest of your code

Answer 17

Adapter

Question 18

You want to reuse several existing subclasses that lack some common functionality that can’t be added to the superclass

Answer 18

Adapter

Question 19

You need to have a limited but straightforward interface to a complex subsystem

Answer 19

Fasade

Question 20

You want to structure a subsystem into layers

Answer 20

Fasade

Question 21

You have a heavyweight service object that wastes system resources by being always up, even though you only need it from time to time - lazy initialization

Answer 21

Proxy

Question 22

You want only specific clients to be able to use the service object; for instance, when your objects are crucial parts of an operating system and clients are various launched applications (including malicious ones)

Answer 22

Proxy

Question 23

Local execution of a remote service. This is when the service object is located on a remote server

Answer 23

Proxy

Question 24

You want to keep a history of requests to the service object.

Answer 24

Proxy

Question 25

You need to cache results of client requests and manage the life cycle of this cache, especially if results are quite large

Answer 25

Proxy

Question 26

You need to be able to dismiss a heavyweight object once there are no clients that use it

Answer 26

Proxy

Question 27

You want to divide and organize a monolithic class that has several variants of some functionality (for example, if the class can work with various database servers)

Answer 27

Bridge

Question 28

You need to extend a class in several orthogonal (independent) dimensions.

Answer 28

Bridge

Question 29

You need to be able to switch implementations at runtime

Answer 29

Bridge, Strategy

Question 30

You want to let clients extend only particular steps of an algorithm, but not the whole algorithm or its structure

Answer 30

Template Method

Question 31

You have several classes that contain almost identical algorithms with some minor differences. As a result, you might need to modify all classes when the algorithm changes

Answer 31

Template Method

Question 32

You have to implement a tree-like object structure

Answer 32

Composite

Question 33

You want the client code to treat both simple and complex elements uniformly

Answer 33

Composite

Question 34

Your collection has a complex data structure under the hood, but you want to hide its complexity from clients (either for convenience or security reasons).

Answer 34

Iterator

Question 35

Your code to be able to traverse different data structures or when types of these structures are unknown beforehand.

Answer 35

Iterator

Question 36

You have an object that behaves differently depending on its current state, the number of states is enormous, and the state-specific code changes frequently

Answer 36

State

Question 37

You have a class polluted with massive conditionals that alter how the class behaves according to the current values of the class’s fields

Answer 37

State

Question 38

You have a lot of duplicate code across similar states and transitions of a condition-based state machine

Answer 38

State

Question 39

Use the this pattern to get rid of a “telescopic constructor” (constructor with several optional parameters)

Answer 39

Builder

Question 40

Use this pattern when you want your code to be able to create different representations of some product (for example, stone and wooden houses)

Answer 40

Builder

Question 41

Use this pattern to construct Composite trees or other complex objects

Answer 41

Builder

Question 42

Use this pattern when your code shouldn’t depend
on the concrete classes of objects that you need to copy

Answer 42

Prototype

Question 43

Use the pattern when you want to reduce the number of subclasses
that only differ in the way they initialize their respective
objects. Somebody could have created these subclasses to
be able to create objects with a specific configuration

Answer 43

Prototype

Question 44

Use this pattern when a class in your program should
have just a single instance available to all clients; for example,
a single database object shared by different parts of the
program.

Answer 44

Singleton

Question 45

Use this pattern when you need stricter control over
global variables

Answer 45

Singleton

Question 46

Use the this pattern only when your program must support a huge number of objects which barely fit into available RAM.

Answer 46

Flyweight

Question 47

Use this pattern when your program
is expected to process different kinds of requests in various
ways, but the exact types of requests and their sequences are
unknown beforehand

Answer 47

Chain of Responsibility

Question 48

Use the pattern when it’s essential to execute several handlers
in a particular order

Answer 48

Chain of Responsibility

Question 49

Use the this pattern when the set of handlers and their order
are supposed to change at runtime

Answer 49

Chain of Responsibility

Question 50

Use this pattern when it’s hard to change some of the
classes because they are tightly coupled to a bunch of other
classes

Answer 50

Mediator

Question 51

The pattern lets you extract all the relationships between
classes into a separate class, isolating any changes to a specif-
ic component from the rest of the components

Answer 51

Mediator

Question 52

Use the pattern when you can’t reuse a component in a differ-
ent program because it’s too dependent on other components

Answer 52

Mediator

Question 53

Use the pattern when you find yourself creating tons of com-
ponent subclasses just to reuse some basic behavior in various
contexts

Answer 53

Mediator

Question 54

Use the pattern when you want to produce snapshots of the object’s state to be able to restore a previous state
of the object

Answer 54

Memento

Question 55

Use the pattern when you need to deal with transactions (i.e., if you need to roll back an operation
on error)

Answer 55

Memento

Question 56

Use the patern when you need to perform an operation on all elements of a complex object structure (for example, an object tree).

Answer 56

Visitor

Question 57

Use the pattern to clean up the business logic of auxiliary behaviors.

Answer 57

Visitor

Question 58

Use the pattern when a behavior makes sense only in some classes of a class hierarchy, but not in others.

Answer 58

Visitor