Design Pattern In Java
7) Observer design pattern(Publish/Subscribe) :- This pattern falls under behavioral design pattern. This pattern defines a one-to-many dependency between objects so that when one object state is change then all of its dependents are notified and updated automatically. In this pattern the objects that listen or watch for change are called observers and the object that is being watched for is called subject. It is mainly used to implement distributed event handling systems. Most of the programming libraries and system including GUI toolkits have implemented this design pattern.
As per GOF:- “Define a one-to-many dependency between objects so that when one object changes state, all its dependents are notified and updated automatically.”
Observer design pattern in Real World:- Most of the time, we have used online shopping, so whenever we searched for any product and suppose at that point of time it is not available then there is an option available i.e. "Notify me when product is available". If we will choose that option then whenever that product is available then we will get notification by mail or sms(Here when product is available means product state changes then we will get notification). In this case, Product is subject and we are observers.
Similarly in facebook, If we subscribe someone then whenever new updates raises by him then we will get notification.
Observer design pattern in Java :-
- javax.servlet.http.HttpSessionBindingListener
- javax.servlet.http.HttpSessionAttributeListener
- All implementations of java.util.EventListener (Used in Swings)
- java.util.Observer/java.util.Observable
When we can use this:-
- When subject doesn't know about number of observers it has.
- When one object changes its state,then all other dependent objects must automatically change their state to maintain consistency
- When an object should be able to notify other objects without knowing who objects are.
8) State design pattern:- This type of behavioral design pattern provides a mechanism to change behavior of an object based on the object’s state. State is used when we need a class to behave differently, such as performing slightly different computations, based on some arguments passed through to the class. In this pattern, we create objects which represent various states and a context object whose behavior varies as its state object changes.
As per GOF:- “Allows an object to alter its behaviour when its internal state changes. The object will appear to change its class.”
State design pattern in real world:- As we know, A vending machine is a machine which dispenses items such as snacks, beverages, alcohol, cigarettes, lottery tickets, cologne, consumer products and even gold and gems to customers automatically, after the customer inserts currency or credit into the machine. So this vending machines maintain its internal state which allow it to change it's behaviour depends on situation. For example, if there is no change available, it will demand exact currency. When something is out of stock, it will not deliver any product.
Another example is a drawing program like MSPaint where the program has a mouse cursor, which at any point in time can act as one of several tools. like eraser, pensil e.t.c. So, instead of switching between multiple cursor objects, the cursor maintains an internal state representing the tool currently in use. When a tool-dependent method is called (say, as a result of a mouse click), the method call is passed on to the cursor's state.
State design pattern in Java :-
- javax.faces.lifecycle.LifeCycle#execute() (controlled by FacesServlet, the behaviour is dependent on current phase (state) of JSF lifecycle)
9)Strategy design pattern:- This behavioral pattern is also known as policy pattern. An object controls which of a family of methods is called. Each method is in its' own class that extends a common base class. The Strategy pattern help us to build a software as a loosely coupled collection of interchangeable parts which makes our software much more extensible, maintainable, and reusable.
The strategy pattern tells do the below things
- It defines a family of algorithms,
- encapsulates each one(algorithm), and
- It makes the algorithms interchangeable within that family.
The best example of Strategy 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.
In Strategy design pattern:-
- Algorithms (strategies) are chosen at runtime.
- A Strategy is dynamically selected by a client i.e. a user or consuming program or by the Context.
- Our driver or controller class is typically named as Context.
- The Context class is aware of a variety of different algorithms, and each algorithm is considered as a Strategy. The Context class is responsible for handling the data during the interaction with the client.
As per GOF:- “Defines a set of encapsulated algorithms that can be swapped to carry out a specific behaviour.”
Uses:-
- When we need to use one of several algorithms dynamically.
- When we want to configure a class with one of many related classes behaviors.
Advantages:-
- Provides an alternative to subclassing.
- Reduces multiple conditional statements in a client.
- Can be used to hide data that an algorithm uses that clients shouldn't know about.
- Hides complex, algorithmic-specific data from the client.
Strategy design pattern in real world:- In many applications we are saving the files in different formats like: doc format(Ms-Word), ODT(OpenOffice), RTF, HTML, plain text.
Compress files using different compression algorithms by different application like winzip, winrar, 7Zip e.t.c.
Display calendars, with different holidays for different countries.
Strategy design pattern in Java:-
- javax.servlet.Filter#doFilter()
- 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!).
10) Template method design pattern:- This design pattern also fall under behavioural design pattern. In the template method design pattern, the 'template method' defines the common steps of an algorithm. The implementation of these steps can be deferred based on subclasses. Thus, the common algorithm is defined in the template method, but the exact steps of this algorithm can be defined in subclasses and the template method is implemented in an abstract class.
As per GOF:- “Defines the skeleton of an algorithm in a method, deferring some steps to subclasses. Template Method lets subclasses redefine certain steps of an algorithm without changing the algorithms structure.”
When to use: -
When we have a predefined steps for algorithm but implementation of those steps may vary.
When we want to avoid code duplication,implementing common code in base class and variation in subclass.
Template method design pattern in real world:-Making of every automobile and machines are based on some template pattern. Basic building plans because a different building may have many variations. For creating any framework, we need to use this design pattern in order to remove code duplication.
Template method design pattern in Java:-
- javax.servlet.http.HttpServlet, all the doXXX() methods by default sends a HTTP 405 "Method Not Allowed" error to the response. We are free to implement none or any of them.
- 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.
11) Visitor design pattern:- This pattern falls under behavioral design pattern. This pattern is used when we have to perform an operation on a group of similar kind of Objects. Using this design pattern, we can move the operational logic from the objects to another class. This pattern is providing a way of separating an algorithm from an object structure on which it operates. A practical result of this separation is the ability to add new operations to existing object structures without modifying those structures.
As of GOF:- “Allows for one or more operation to be applied to a set of objects at runtime, decoupling the operations from the object structure. ”
Visitor design pattern in Real world:- Visitor pattern is a design pattern commonly used in the parser of a compiler, such as Eclipse JDT AST Parser.
Visitor design pattern in Java:-
- javax.lang.model.type.TypeMirror and TypeVisitor
- javax.lang.model.element.AnnotationValue and AnnotationValueVisitor
- javax.lang.model.element.Element and ElementVisitor
Uses:-
- When the classes defining the object structure changes rarely, but we often want to define new operations over the structure. (If the object structure classes change often, then it's probably better to define the operations in those classes.)
- When many distinct and unrelated operations need to be performed on objects in an object structure, and we don't want to spoil their classes with these operations
- When an object structure contains many classes of objects with differing interfaces, and we want to perform operations on these objects that depend on their concrete classes
Advantages:-
- Adding new operations is easy
- Related behavior isn't spread over the classes defining the object structure; it's localized in a visitor. Unrelated sets of behavior are partitioned in their own visitor subclasses.
Difference between Visitor and Strategy pattern:-
Visitor and strategy looks similar as they encapsulates complex logic from data. We can say that Visitor design pattern is more general form of strategy. In Strategy design pattern we have one context on which multiple algorithms operate means in Strategy pattern we have a single context and multiple algorithms work on it. But on the other way Visitor design pattern have multiple contexts and for every context we have an algorithm.
In short, We can generalize that Strategy is a special kind of Visitor, In strategy we have one data context and multiple algorithms while in visitor for every data context, one algorithm associated with that.
No comments:
Post a Comment