Behavioral Design Patterns

Question 1

Provide definition for Chain of Responsibility

Answer 1

Behavioral design pattern that lets
you pass requests along a chain of handlers. Upon receiving a
request, each handler decides either to process the request or
to pass it to the next handler in the chain

Question 2

What is not standard approach of Chain Of Responsibility design pattern

Answer 2

Upon receiving a request, a handler decides whether it can process it. If it can, it doesn’t pass
the request any further. So it’s either only one handler that
processes the request or none at all.

Question 3

Request has to be sent to first handler in the chain (Chain of Responsibility pattern) or not?

Answer 3

Request can be sent to any handler in the chain—it doesn’t
have to be the first one

Question 4

How to modify the order of handlers in CoR pattern in runtime

Answer 4

If you plan to modify chains at runtime,
you need to define a setter for altering the value of the reference field

Question 5

Chain of Responsibility is often used in conjunction with Composite. How Composite pattern can be adjusted for that

Answer 5

Component need to have a link to composite. This link play a role of next handler. (p.259)

Question 6

How CoR is connected to the Command pattern

Answer 6

Handlers in Chain of Responsibility can be implemented as
Commands. In this case, you can execute a lot of different
operations over the same context object, represented by a
request.
However, there’s another approach, where the request itself
is a Command object. In this case, you can execute the same
operation in a series of different contexts linked into a chain

Question 7

Provide a definition of command pattern

Answer 7

Command is a behavioral design pattern that turns a request into a stand-alone object that contains all information about the request. This transformation lets you parameterize
methods with different requests, delay or queue a request’s execution, and support undoable operations

Question 8

What is Separation Of Concerns principle

Answer 8

Design principle for separating a computer program into distinct sections (layers)

Question 9

Provide a definition of Iterator pattern

Answer 9

Behavioral design pattern that lets you traverse
elements of a collection without exposing its underlying
representation (list, stack, tree, etc.)

Question 10

Provide definition for Mediator design pattern

Answer 10

Behavioral design pattern that lets you reduce chaotic dependencies between objects. The pattern restricts direct communications between the objects and forces them to collaborate only via a mediator object

Question 11

What kind of object can Component pass to Mediator

Answer 11

Components may pass any context as arguments of this method, including their own objects, but only in such a way that no coupling occurs between a receiving component and the sender’s class.

Question 12

What else can do Mediator instead of keeping references to all components

Answer 12

They manage sometimes their lifecycle

Question 13

Provide definition for Memento design pattern

Answer 13

Behavioral design pattern that lets you save and
restore the previous state of an object without revealing the
details of its implementation

Question 14

What are the roles of orginator and caretaker in Memento pattern

Answer 14

Caretaker is an object which makes snapshot and produces memento.

Caretaker is an oblect which can use memento but only via the limited interface, it’s not able to
tamper with the state stored inside the memento.

Question 15

What is memento object

Answer 15

Value object that acts as a snapshot of the
originator’s state. It’s a common practice to make the memento
immutable and pass it the data only once, via the constructor

Question 16

In the absence of nested classes, you can restrict access to
the memento’s fields

Answer 16

By establishing a convention that caretakers can work with a memento only through an explicit-
ly declared intermediary interface, which would only declare
methods related to the memento’s metadata

Question 17

How originators can work with a memento in the model of implementation based on an intermediate interface?

Answer 17

Originators can work with a memento
object directly, accessing fields and methods declared in the
memento class. The downside of this approach is that you
need to declare all members of the memento public.

Question 18

In which way you can avoid that bussiness logic is mixed together with subscribction methods in Observer Pattern

Answer 18

You can create something like EventManager which will implement only subscription methods. And then create bussiness logic class which will composite EventManager

Question 19

Structure of Strategy and State patterns look similar. What is a key difference?

Answer 19

In the state pattern the particular states may na aware of each other and initiate transitions from one state to another, whereas strategies almost never know each other.

Question 20

How to avoid duplication of similar code across multiple states.

Answer 20

You may provide intermediate abstract classes that encapsulate some common behaviour

Question 21

How an optional step with empty body is called in template method pattern?

Answer 21

Hook (usually placed before and after crucial algorithm step.)

Question 22

What kind of steps you can distinguish in template method pattern

Answer 22

Abstract, optional, hook.

Question 23

Why Template Method pattern may violate Liskov Substitution Princliple?

Answer 23

The rule may be violated by suppressing a default step implementation via a subclass

Question 24

Provide a definition for Visitor pattern

Answer 24

Behavioral design pattern that lets you separate algorithms from the objects on which they operate

Question 25

What should you do when encounter a situation where the visitor will need access to some private members of the element class

Answer 25

In this case, you can either make these fields or methods public, violating the element’s encapsulation, or nest the visitor class in the element class.

Question 26

What means late or dynamic binding?

Answer 26

Checking class of the object passed as parameter and picking the method implementation from the appropriate class.

Question 27

Why we use the word late in binding?

Answer 27

Because we link object and its implementation after compilation, at runtime.

Question 28

Why we use the word dynamic in binding?

Answer 28

Because every new object might need to be linked to a different implementation.

Question 29

What means early or static binding?

Answer 29

Take place in compile time and compiler. When there are overloaded methods compiler checks its exact type. Inheritance hierarhy si nto taken into account.

Question 30

Why we use the word early in early binding?

Answer 30

Because it happens at compile time, before the program is launched.

Question 31

Why we use the word static in static binding?

Answer 31

Because it can’t be altered at runtime

Question 32

What is double dispatch?

Answer 32

Double dispatch is a trick that allows using dynamic binding alongside with overloaded methods (overloaded methods are not dynamically binded).

Question 33

Why we need an accept methods in Visitor pattern?

Answer 33

In order to use Double Dispatch trick (allow dynamic binding for overloaded methods)