Design Patterns

Why Patterns?

Each pattern describes a problem that occurs over and over again in our environment and then describes the core of the solution to that problem in such a way that you can use this solution a million times over without ever doing it the same way twice.

– Christopher Alexander

What is Pattern Designs and explain its significance?

Design Patterns are efficient solutions to the General Software Design problems.
Design patterns are documented tried and tested solutions for recurring problems in a given context. So basically you have a problem context and the proposed solution for the same.
Design patterns existed in some or other form right from the inception stage of software development.
Let’s say if you want to implement a sorting algorithm the first thing comes to mind is bubble sort. So the problem is sorting and solution is bubble sort. Same holds true for design patterns.

Which are the three main categories of design patterns?

There are three basic classifications of patterns Creational, Structural, and Behavioral patterns.

Creational Patterns

Abstract Factory : Creates an instance of several families of classes
Builder : Separates object construction from its representation
Factory Method : Creates an instance of several derived classes
Prototype : A fully initialized instance to be copied or cloned
Singleton : A class in which only a single instance can exist

:-The best way to remember Creational pattern is by remembering ABFPS (Abraham Became First President of States).

Structural Patterns
Adapter : Match interfaces of different classes .
Bridge : Separates an object’s abstraction from its implementation.
Composite : A tree structure of simple and composite objects.
Decorator : Add responsibilities to objects dynamically.
Flyweight : A fine-grained instance used for efficient sharing.
Proxy : An object representing another object.

Note :- To remember structural pattern best is (ABCDFP)

Behavioral Patterns
Mediator : Defines simplified communication between classes.
Memento : Capture and restore an object’s internal state.
Interpreter : A way to include language elements in a program.
Iterator : Sequentially access the elements of a collection.
Chain of Resp : A way of passing a request between a chain of objects.
Command : Encapsulate a command request as an object.
State : Alter an object’s behavior when its state changes.
Strategy : Encapsulates an algorithm inside a class.
Observer : A way of notifying change to a number of classes.
Template Method : Defer the exact steps of an algorithm to a subclass.
Visitor : Defines a new operation to a class without change.

Note: Just remember Music……. 2 MICS On TV (MMIICCSSOTV).

Note : In the further section we will be covering all the above design patterns in a more detail manner.

What are the different uses of Design Patterns?

  1. Speeds up the development process
  2. Ensures effective and efficient software designs
  3. More reusability for the common problems across the design model
  4. Enables code readability
  5. Good documentation and easier to maintain for other developers
  6. Robust applications can be developed
  7. Ensures customer retention for delivering efficient and robust solutions
  1. It gives a proven solution to a problem
  2. Ensures loosely coupled application development
  3. Enables instant high-level overview after l looking at the code immediately
  4. Easier to understand
  5. Easier to maintain and develop new features.

Which Design Pattern is used to implement any complex method or object?

There are some cases where there will need to implement complex methods or objects such as where a method needs to be implemented with more than 6 or 7 arguments. In that case, the method is going to be complex and this results in poor quality of code.
To avoid this problem, Builder Pattern can be used to implement an efficient way of handling and operating complex methods or objects. Builder Pattern will have a chain of methods and a build() method in order to be executed at the end of calling all the methods. This will construct a complex object easily by invoking in a chain method.

What is a Façade Design Pattern?

A Façade Design Pattern is a Structural Design Pattern which is implemented to represent a complete subsystem as a single class. This is efficient in case there is a huge number of classes in different areas.