Top 68 Design Patterns Interview Questions And Answers

Question 1

What is a _pattern_?

Accepted Answer

*Patterns* in programming are like recipes in cooking. They are not ready dishes, but instructions for slicing and dicing products, cooking them, serving them and so forth.

**Pattern content**
As a rule, a pattern description consists of the following:

* a problem that the pattern solves;
* motivation for solving the the problem using the method suggested by the pattern;
* structures of classes comprising the solution;
* an example in one of the programming languages;
* a description of the nuances of pattern implementation in various contexts;
relations with other patterns.

Question 2

What is _Design Patterns_ and why anyone should use them?

Accepted Answer

Design patterns are a well-described solution to the most commonly encountered problems which occur during software development.

Design pattern represents the best practices evolved over a period of time by experienced software developers. They promote reusability which leads to a more robust and maintainable code.

Question 3

What is _Singleton_ pattern?

Accepted Answer

**Singleton pattern** comes under *creational* patterns category and introduces a single class which is responsible to create an object while making sure that only single object gets created. This class provides a way to access its only object which can be accessed directly without need to instantiate the object of the class.

![](https://upload.wikimedia.org/wikipedia/commons/thumb/f/fb/Singleton_UML_class_diagram.svg/220px-Singleton_UML_class_diagram.svg.png)

Question 4

What are the _main categories_ of Design Patterns?

Accepted Answer

The Design patterns can be classified into three main categories:

* Creational Patterns
* Behavioral Patterns
* Functional Patterns

Question 5

What is _Factory_ pattern?

Accepted Answer

**Factory pattern** is one of most used design pattern and comes under *creational* patterns category. In Factory pattern, we create object without exposing the creation logic to the client and refer to newly created object using a *common interface*. ![](https://www.tutorialspoint.com/design_pattern/images/factory_pattern_uml_diagram.jpg)
**Pro's**: * Allows you to hide implementation of an application seam (the core interfaces that make up your application) * Allows you to easily test the seam of an application (that is to mock/stub) certain parts of your application so you can build and test the other parts * Allows you to change the design of your application more readily, this is known as loose coupling **Con's** * Makes code more difficult to read as all of your code is behind an abstraction that may in turn hide abstractions. * Can be classed as an anti-pattern when it is incorrectly used, for example some people use it to wire up a whole application when using an IOC container, instead use Dependency Injection.

Question 6

What is _Filter_ pattern?

Accepted Answer

**Filter pattern** or **Criteria pattern** is a design pattern that enables developers to filter a set of objects using different criteria and chaining them in a decoupled way through logical operations. This type of design pattern comes under *structural* pattern as this pattern combines multiple criteria to obtain single criteria. **Filter design pattern** is useful where you want to add filters dynamically or you are implementing multiple functionalities and most of them require different filter criteria to filter something. In that case instead of hard coding the filters inside the functionalities, you can create filter criteria and re-use it wherever required. ```js List laptops = LaptopFactory.manufactureInBulk(); AndCriteria searchCriteria = new AndCriteria( new HardDisk250GBFilter(), new MacintoshFilter(), new I5ProcessorFilter()); List filteredLaptops = searchCriteria.meets(laptops); ```

Question 7

Name _types_ of Design Patterns?

Accepted Answer

Design patterns can be classified in three categories: Creational, Structural and Behavioral patterns.

-   Creational Patterns - These design patterns provide a way to create objects while hiding the creation logic, rather than instantiating objects directly using new opreator. This gives program more flexibility in deciding which objects need to be created for a given use case.

-   Structural Patterns - These design patterns concern class and object composition. Concept of inheritance is used to compose interfaces and define ways to compose objects to obtain new functionalities.

-   Behavioral Patterns - These design patterns are specifically concerned with communication between objects.

Question 8

What is _Inversion of Control_?

Accepted Answer

*Inversion of control* is a broad term but for a software developer it's most commonly described as a pattern used for decoupling components and layers in the system.

For example, say your application has a text editor component and you want to provide spell checking. Your standard code would look something like this:
```js
public class TextEditor {

private SpellChecker checker;

public TextEditor() {
        this.checker = new SpellChecker();
    }
}
```
What we've done here creates a dependency between the TextEditor and the SpellChecker. In an IoC scenario we would instead do something like this:
```js
public class TextEditor {

private IocSpellChecker checker;

public TextEditor(IocSpellChecker checker) {
        this.checker = checker;
    }
}
```

You have *inverted control* by handing the responsibility of instantiating the spell checker from the TextEditor class to the caller.

```js
SpellChecker sc = new SpellChecker; // dependency
TextEditor textEditor = new TextEditor(sc);
```

Question 9

What is _Null Object_ pattern?

Accepted Answer

In **Null Object pattern**, a null object replaces check of NULL object instance. Instead of putting if check for a null value, Null Object reflects a do nothing relationship. Such Null object can also be used to provide default behaviour in case data is not available.

In Null Object pattern, we create an abstract class specifying various operations to be done, concrete classes extending this class and a null object class providing do nothing implementation of this class and will be used seamlessly where we need to check null value.

![](https://www.tutorialspoint.com/design_pattern/images/null_pattern_uml_diagram.jpg)

Question 10

What is _Template_ pattern?

Accepted Answer

In **Template pattern**, an abstract class exposes defined way(s)/template(s) to execute its methods. Its subclasses can override the method implementation as per need but the invocation is to be in the same way as defined by an abstract class. This pattern comes under _behavior_ pattern category.

![](https://upload.wikimedia.org/wikipedia/commons/2/2a/W3sDesign_Template_Method_Design_Pattern_UML.jpg)

Top 68 Design Patterns Interview Questions

What are the main categories of Design Patterns?

What is Design Patterns and why anyone should use them?

What is Singleton pattern?

What is a pattern?

Why would you want to use a Repository Pattern with an ORM?

What are some benefits of Repository Pattern?

Name types of Design Patterns?

What is Null Object pattern?

What is Dependency Injection?

What is Proxy pattern?

What is Inversion of Control?

What is Iterator pattern?

What is State pattern?

What is Template pattern?

What is Filter pattern?

What is Builder pattern?

What is Strategy pattern?

Can we create a clone of a singleton object?

What is Factory pattern?

Is Unit Of Work equals Transaction? Or it is more than that?

What is Decorator pattern?

What is Memento pattern?

What is Unit Of Work?

What is Mediator pattern?

What are some reasons to use Repository Pattern?

What is an Aggregate Root in the context of Repository Pattern?

Can you give any good explanation what is the difference between Proxy and Decorator?

When should I use Active Record vs Repository Pattern?

What are the drawbacks to the ActiveRecord pattern?

In OOP, what is the difference between the Repository Pattern and a Service Layer?

What are some advantages of using Dependency Injection

What is the Command and Query Responsibility Segregation (CQRS) Pattern?

Name some benefits of CQRS Pattern

Describe what is the Event Sourcing Pattern

Explain the use of Claim Check Pattern in Azure Event Grid

What are the difference between a Static class and a Singleton class?

What is Adapter Pattern?

What does program to interfaces, not implementations mean?

What is Prototype pattern?

What is Interpreter pattern?

What is Command pattern?

What is Facade pattern?

What is the Chain of Responsibility pattern?

What is Abstract Factory pattern?

When should I use Composite design pattern?

What is Observer pattern?

What is Bridge pattern?

Explain usage of Service Locator Pattern

What are some disadvantages of Dependency Injection?

What is the difference between Strategy design pattern and State design pattern?

What is relationship between Repository and Unit of Work?

What is Flyweight pattern?

Explain what is Composition over Inheritance?

Why shouldn't I use the Repository Pattern with Entity Framework?

How is Bridge pattern is different from Adapter pattern?

How should I be grouping my Repositories when using Repository Pattern?

Is Repository Pattern as same as Active Record Pattern?

What will you choose: Repository Pattern or "smart" business objects?

Could you explain some benefits of Repository Pattern?

Why would I ever use a Chain of Responsibility over a Decorator?

When would you use the Builder Pattern? Why not just use a Factory Pattern?

What's the difference between the Dependency Injection and Service Locator patterns?

What is the difference between the Template patterns and the Strategy pattern?

Explain difference between the Facade, Proxy, Adapter and Decorator design patterns?

Could you explain the difference between Façade vs. Mediator?

Can we use the CQRS without the Event Sourcing?

Could you explain what is the Deadly Diamond of Death?

How should I add an object into a collection maintained by Aggregate Root?