Software Desing Patterns

Boutique product development company
It is amazing what you can accomplish when you have a client-centric team to deliver outstanding products.

Design Patterns
Arslan Anwar | Senior Software Engineer
Amir qayyum | Software Engineer

Programs must be written for people to read, and only incidentally
for machines to execute.

Design Patterns
➢ What are design patterns
➢ Why to use design patterns
➢ Type and Details of design patterns
➢ Design Pattern structure
➢ Code Examples
Arslan Anwar | Senior Software Engineer , Amir qayyum | Software Engineer

Design Patterns

What are design patterns

➢
➢Design patterns are optimized, reusable solutions to the programming
problems that we encounter every day.
➢A design pattern is a well described solution to a common software
problem.
➢It is a template that has to be implemented in the correct situation.


Design Patterns

Benefits of Design Patterns

➢

➢Design Patterns are already defined and provides industry
standard approach to solve a recurring problem, so it saves time if we
sensibly use the design pattern.
➢Using design patterns promotes reusability that leads to
more robust and highly maintainable code. It helps in reducing total
cost of ownership (TCO) of the software product.
➢ Since design patterns are already defined, it makes our code easy to
understand and debug. It leads to faster development and new members
of team understand it easily.


Design Patterns

Design Patterns Categories

Java Design Patterns are divided into three categories
Creational

Structural

Behavioral

Factory Method
Abstract Factory
Builder
Prototype
Singleton

Adapter
Bridge
Composite
Decorator
Flyweight
Facade
Proxy

Interpreter
Template
Method
Chain of
Responsibility
Command
Iterator
Mediator
Memento
Observer
State
Strategy
Visitor


Design Patterns

Singleton Design Pattern

➢Singleton is a part of Gang of Four design pattern and it is
categorized under creational design patterns. In this article we are going
to take a deeper look into the usage of the Singleton pattern. It is one of
the most simple design pattern in terms of the modelling but on the
other hand this is one of the most controversial pattern in terms of
complexity of usage.


Design Patterns


✓Ensure a class has only one instance, and provide a global point of
access to it.
✓Encapsulated "just-in-time initialization" or "initialization on first
use".

Arslan Anwar | Senior Software Engineer , Amir D | Software Engineer

Design Patterns


➢Structure


Design Patterns


✓Abstract Factory, Builder, and Prototype can use Singleton in their
implementation.
✓Facade objects are often Singletons because only one Facade object is
required.
✓State objects are often Singletons.
✓The advantage of Singleton over global variables is that you are
absolutely sure of the number of instances when you use Singleton, and,
you can change your mind and manage any number of instances.

✓The Singleton design pattern is one of the most inappropriately used
patterns. Singletons are intended to be used when a class must have
exactly one instance, no more, no less. Designers frequently use
Singletons in a misguided attempt to replace global variables.

Design Patterns


➢ Use in JDK
➢java.lang.Runtime#getRuntime()
➢java.awt.Desktop#getDesktop()

Example


Design Patterns


➢Create a resource a share it inside your application? What will you
do?
➢Updating shared resource(s) by various users!
➢Only readable resource


Design Patterns

Builder Design Pattern

The builder pattern is an object creation software design pattern. The
intention of the builder pattern is to find a solution to the telescoping
constructor anti-pattern.

The telescoping constructor anti-pattern occurs when the increase of
object constructor parameter combination leads to an exponential list of
constructors.
Instead of using numerous constructors, the builder pattern uses another
object, a builder, that receives each initialization parameter step by step
and then returns the resulting constructed object at once.


Design Patterns



Design Patterns


The intent of the Builder design pattern is to separate the construction of
a complex object from its representation. By doing so, the same
construction process can create different representations
For constructor management. For example google protocol buffer is a
way to transport objects. So we need a Template to make agreement on
both sides that we are sending an object with a specific structure.


Design Patterns

Builder Design Pattern exercise

Large class with multiple constructors and u need a constructor
constructor?
What if you have constructors, some setting some data and some setting
other data make some data null or modifying it?
Setting data in object in meaningful manner. Because we know setter
provide more meaning in setting/assigning a value to a property. OK?


Design Patterns

Factory method Design Pattern

Deals with the problem of creating objects (products) without
specifying the exact class of object that will be created. The essence of
this pattern is to "Define an interface for creating an object, but let the
classes that implement the interface decide which class to instantiate.
The Factory method lets a class defer instantiation to subclasses.
If object creation code is spread in whole application, and if you need to
change the process of object creation then you need to go in each and
every place to make necessary changes.


Design Patterns



Design Patterns


➢The creation of an object precludes its reuse without significant
duplication of code.
➢The creation of an object requires access to information or resources
that should not be contained within the composing class.

➢The lifetime management of the generated objects must be
centralized to ensure a consistent behavior within the application.


Design Patterns

Factory method Design Pattern exercise

What will you do if your applications is consuming services that are
hosted on different servers for Work, QA and End users.
What you do to handle object creation of some interface or parent class
that you are using on different levels in application.


Design Patterns

Abstract Factory Design Pattern

The Abstract Factory is known as a creational pattern - it's used to
construct objects such that they can be decoupled from the
implementing system. The definition of Abstract Factory provided in
the original Gang of Four book on Design Patterns states:
“Provides an interface for creating families of related or dependent
objects without specifying their concrete classes.”


Design Patterns

How different from Factory Design Pattern

➢With the Factory pattern, you produce implementations (Apple,
Banana, Cherry, etc.) of a particular interface -- say, IFruit.
➢With the Abstract Factory pattern, you produce implementations of a
particular Factory interface -- e.g., IFruitFactory. Each of those knows
how to create different kinds of fruit.


Design Patterns



Design Patterns


➢ The client code has no knowledge whatsoever of the concrete type.
The client code deals only with the abstract type. Objects of a concrete
type are indeed created by the factory, but the client code accesses such
objects only through their abstract interface.
➢ Adding new concrete types is done by modifying the client code to
use a different factory, a modification that is typically one line in one
file.
➢The different factory then creates objects of a different concrete type,
but still returns a pointer of the same abstract type as before — thus
insulating the client code from change.


Design Patterns


➢There will be a single Abstract Factory class (or interface) with two
concrete subclasses (cool and uncool).
➢The Abstract Factory class will contain three abstract methods with
no bodies.

➢For each product (A, B and C) there'll be an interface plus two
concrete subclasses.
➢The main program should create the factory instance that is used in
the program, and this should be passed to the Client class to tell it if
it should create cool or uncool products.


Design Patterns

Prototype Design Pattern

It is used when the type of objects to create is determined by a
prototypical instance, which is cloned to produce new objects. This
pattern is used to:
– Avoid subclasses of an object creator in the client application, like
the abstract factory pattern does.
– Avoid the inherent cost of creating a new object in the standard
way (e.g., using the 'new' keyword) when it is prohibitively
expensive for a given application.
To implement the pattern, declare an abstract base class that specifies a
pure virtual clone() method. Any class that needs a "polymorphic
constructor" capability derives itself from the abstract base class, and
implements the clone() operation.


Design Patterns



Design Patterns


The client, instead of writing code that invokes the "new" operator on a
hard-coded class name, calls the clone() method on the prototype, calls
a factory method with a parameter designating the particular concrete
derived class desired, or invokes the clone() method through some
mechanism provided by another design pattern.


Design Patterns

Prototype Design Pattern exercise
You are working on a editor with no ability of refactoring and you need to change
name of class what will you do. How can you use prototype pattern will help you
in that?


Design Patterns

Chain Of Responsibility

➢ Avoid coupling the sender of a request to the receiver by giving
more than one object a chance to handle the request. Chain the
receiving objects and pass the request along the chain until an object
handles it.
➢The main intention in Chain Of Responsibility is to decouple the
origin of the request and the handling of the request such that the origin
of the request need not worry who and how its request is being handled
as long as it gets the expected outcome


Design Patterns


➢Intent
○ The main intention in Chain Of Responsibility is to decouple the
origin of the request and the handling of the request such that the
origin of the request need not worry who and how its request is
being handled as long as it gets the expected outcome
○ Sender will not know which object in the chain will serve its
request.
○ Every node in chain will have the responsibility to decide, if they
can serve the request.
○ If node decides to forward the request, it should be capable of
choosing the next node and forward it.
○ There is a possibility where none of the node may serve the request


Design Patterns


➢ Structure


Design Patterns


➢ Use in JDK
javax.servlet.Filter#doFilter()
java.util.logging.Logger#log
Ads by Google
➢ Example


Design Patterns

Observer

➢ In observer design pattern multiple observer objects registers with a
subject for change notification. When the state of subject changes, it
notifies the observers. Objects that listen or watch for change are called
observers and the object that is being watched for is called subject.
➢Pattern involved is also called as publish-subscribe pattern. Model
view controller (MVC) architecture’s core uses the observer design
pattern.


Design Patterns

Observer

✓Subject provides interface for observers to register and unregister
themselves with the subject.
✓Subject knows who its subscribers are.
✓Multiple observers can subscribe for notifications.
✓Subject publishes the notifications.
✓Subject sends the notification saying the state has changed. It can
also pass any state information.


Design Patterns

Observer

➢ Structure


Design Patterns

Observer

➢ Use in JDK
HttpSessionBindingListener is an example where Observer design
pattern in used in Java API.
Example


Design Patterns

Command Design Pattern

➢Command design pattern is used to encapsulate a request as an object
and pass to an invoker, wherein the invoker does not knows how to
service the request but uses the encapsulated command to perform an
action.
➢To understand command design pattern we should understand the
associated key terms like client, command, command implementation,
invoker, receiver.


Design Patterns


✓Command is an interface with execute method. It is the core of
contract.
✓A client creates an instance of a command implementation and
associates it with a receiver.
✓An invoker instructs the command to perform an action.
✓A Command implementation’s instance creates a binding between the
receiver and an action.
✓Receiver is the object that knows the actual steps to perform the
action.


Design Patterns

Command Design Pattern (Important Points)

✓Command pattern helps to decouple the invoker and the receiver.
Receiver is the one which knows how to perform an action.
✓Command helps to implement call back in java.
✓Helps in terms of extensibility as we can add new command without
changing existing code.
✓Command defines the binding between receiver and action.
✓A command should be able to implement undo and redo operations.
That is restting the state of the receiver. It can be done from the support
of receiver.


Design Patterns


➢ Structure


Design Patterns


➢ Use in JDK
Implementations of java.lang.Runnable and javax.swing.Action follows
command design pattern.
Example


Design Patterns

Template Design Pattern

➢Template method pattern is a behavioral design pattern which
provide base method for algorithm,called template method which defers
some of its steps to subclasses So algorithm structure is same but some
of its steps can be redefined by subclasses according to context.
➢To understand command design pattern we should understand the
associated key terms like client, command, command implementation,
invoker, receiver.


Design Patterns

Template Design Pattern (Important Points)

✓Template method in super class follows “the Hollywood principle”:
“Don’t call us, we’ll call you”. This refers to the fact that instead of
calling the methods from base class in the subclasses, the methods from
subclass are called in the template method from superclass.
✓Template method in super class should not be overridden so make it
final
✓Template methods are technique for code reuse because with this,you
can figure out common behavior and defer specific behavior to
subclasses.


Design Patterns


✓ Define the skeleton of an algorithm in an operation, deferring some
steps to subclasses.
✓ Template Method lets subclasses redefine certain steps of an
algorithm without letting them to change the algorithm's structure.


Design Patterns


➢ Structure


Design Patterns


➢ Use in JDK
➢All non-abstract methods of java.io.InputStream,
java.io.OutputStream, java.io.Reader and java.io.Writer.
➢All non-abstract methods of java.util.AbstractList,
java.util.AbstractSet and java.util.AbstractMap.
➢javax.servlet.http.HttpServlet, all the doXXX() methods by default
sends a HTTP 405 "Method Not Allowed" error to the response. You're
free to implement none or any of them.
Example


Design Patterns

Visitor Design Pattern

➢Visitor Pattern is one of the behavioral design pattern. Visitor
pattern is used when we have to perform an operation on a group of
similar kind of Objects. With the help of visitor pattern, we can move
the operational logic from the objects to another class.
➢For example, think of a Shopping cart where we can add different
type of items (Elements), when we click on checkout button, it
calculates the total amount to be paid. Now we can have the calculation
logic in item classes or we can move out this logic to another class
using visitor pattern. Let’s implement this in our example of visitor
pattern.


Design Patterns


✓Represent an operation to be performed on the elements of an object
structure. Visitor lets you define a new operation without changing the
classes of the elements on which it operates.
✓The classic technique for recovering lost type information.
✓Do the right thing based on the type of two objects.
✓Double dispatch


Design Patterns


➢ Structure


Design Patterns


✓The benefit of this pattern is that if the logic of operation changes,
then we need to make change only in the visitor implementation rather
than doing it in all the item classes.

✓Another benefit is that adding a new item to the system is easy, it will
require change only in visitor interface and implementation and existing
item classes will not be affected.
✓The drawback of visitor pattern is that we should know the return
type of visit() methods at the time of designing otherwise we will have
to change the interface and all of its implementations. Another
drawback is that if there are too many implementations of visitor
interface, it makes it hard to extend.

Design Patterns


➢ Use in JDK
➢javax.lang.model.element.AnnotationValue and
AnnotationValueVisitor
➢javax.lang.model.element.Element and ElementVisitor
➢javax.lang.model.type.TypeMirror and TypeVisitor
Example


Design Patterns

Strategy Design Pattern

➢Strategy pattern is one of the behavioral design pattern. Strategy
pattern is used when we have multiple algorithm for a specific task and
client decides the actual implementation to be used at runtime.

➢Strategy pattern is also known as Policy Pattern. We defines
multiple algorithms and let client application pass the algorithm to be
used as a parameter. One of the best example of this pattern
is Collections.sort() method that takes Comparator parameter. Based on
the different implementations of Comparator interfaces, the Objects are
getting sorted in different ways.


Design Patterns


✓Define a family of algorithms, encapsulate each one, and make them
interchangeable. Strategy lets the algorithm vary independently from
the clients that use it.

✓Capture the abstraction in an interface, bury implementation details in
derived classes.


Design Patterns


➢ Structure


Design Patterns


✓We could have used composition to create instance variable for
strategies but we should avoid that as we want the specific strategy to
be applied for a particular task, same is followed in Collections.sort()
and Arrays.sort() method that take comparator as argument.
✓Strategy Pattern is very similar to State Pattern. One of the difference
is that Context contains state as instance variable and there can be
multiple tasks whose implementation can be dependent on the state
whereas in strategy pattern strategy is passed as argument to the method
and context object doesn’t have any variable to store it.
✓Strategy pattern is useful when we have multiple algorithms for
specific task and we want our application to be flexible to chose any of
the algorithm at runtime for specific task.

Design Patterns


➢ Use in JDK
➢java.util.Comparator#compare(), executed by among others
Collections#sort().
➢javax.servlet.http.HttpServlet, the service() and all doXXX() methods
take HttpServletRequest and HttpServletResponse and the implementor
has to process them (and not to get hold of them as instance variables!).
➢javax.servlet.Filter#doFilter()
Example


Design Patterns

State Design Pattern

➢State pattern is one of the behavioral design pattern. State design
pattern is used when an Object change it’s behavior based on it’s
internal state.

➢If we have to change the behavior of an object based on it’s state, we
can have a state variable in the Object and use if-else condition block to
perform different actions based on the state.


Design Patterns


✓Allow an object to alter its behavior when its internal state changes.
The object will appear to change its class.
✓An object-oriented state machine
✓wrapper + polymorphic wrappee + collaboration


Design Patterns


➢Structure


Design Patterns


✓The benefits of using State pattern to implement polymorphic
behavior is clearly visible, the chances of error are less and it’s very
easy to add more states for additional behavior making it more robust,
easily maintainable and flexible. Also State pattern helped in avoiding
if-else or switch-case conditional logic in this scenario
✓The implementation of the State pattern builds on the Strategy
pattern. The difference between State and Strategy is in the intent. With
Strategy, the choice of algorithm is fairly stable. With State, a change in
the state of the "context" object causes it to select from its "palette" of
Strategy objects.


Design Patterns


➢Use in JDK
➢javax.faces.lifecycle.LifeCycle#execute() (controlled by
FacesServlet, the behaviour is dependent on current phase (state) of JSF
lifecycle)

Example


Software Desing Patterns

Recommandé

Recommandé

Contenu connexe

Plus de Confiz

Plus de Confiz (15)

Dernier

Dernier (20)

Software Desing Patterns