Design Patterns in Java – Creational, Behavioural, & Structural
In this Java tutorial, we are going to talk about the Design Patterns in Java. Moreover, in this Java Design Pattern, we will see creational, behavioural, and structural design patterns in Java with the real-time examples.
So, let us start Design Patterns in Java.
2. What are Design Patterns in Java?
Design Patterns in Java are very talked-about among software system developers. A design pattern could be a well-delineated answer to a typical software system problem. Some of the advantages of using design patterns are:
- Java Design Patterns already outline and provide a business customary approach to resolve a recurring problem. Therefore it saves time if we tend to sanely use the design pattern. Several java design patterns that we can use in our Java projects.
- Using design patterns in Java promotes reusability that ends up in a lot of robust and highly maintainable code. It helps in reducing total cost of ownership (TCO) of the software package.
- Since design patterns are already defined, it makes our code straightforward to understand and debug. It ends up in quicker development and new members of the team are aware of it simply.
3. Types of Design Patterns in Java
Below we are discussing design patterns in Java. These Java design patterns have 3 categories – creational, structural, and behavioural design patterns in Java.
a. Creational Design Patterns in Java
Creational design patterns in Java give an answer to instantiate an object within the very best approach for specific things.
i. Singleton Pattern
Singleton design patterns in Java restricts the instantiation of a class and ensures that just one instance of the class exists within the Java virtual machine. It looks to be a really easy design pattern, however, once it involves implementation, it comes with a lot of implementation concerns. The implementation of the Singleton pattern has always been a disputable topic among developers. Examine Singleton design Pattern to be told regarding alternative ways to implement Singleton pattern and execs and cons of every of the method.
ii. Factory Pattern
Factory design patterns in Java use once we have an excellent class with multiple sub-classes and a super input, we want to come one amongst the sub-class. This pattern factory the responsibility of representation of from client program to the factory class.
iii. Abstract Factory Pattern
Abstract factory Java pattern can compare to factory pattern and its factory of factories. A single factory category that returns the various sub-classes supported the input provided and factory class uses if-else or switch statement to attain this.
In Abstract factory pattern, we tend to get eliminate if-else block and have a factory class for every sub-class and so an Abstract factory class which will return the sub-class supported the input factory category.
iv. Builder Pattern
Builder patterns in Java solves the problem with the sizable amount of ex gratia parameters and inconsistent state by providing how to create the item in small stages and supply a method which will really return the final Object. Examine the Builder Pattern as an example program and a new employed in JDK.
v. Prototype Pattern
Prototype design patterns in Java employes once the object creation could be an expensive affair and needs a lot of your time and resources and you’ve got the same object already existing. Therefore this pattern provides a mechanism to copy the initial object to a replacement object and so modify it per our wants. This pattern uses Java cloning to copy the object.
Prototype design pattern mandates that the object that you’re copying should provide the super feature. It mustn’t be done by the other class. But whether or not to use a shallow or deep copy of the item properties depends on the necessities and it’s a design call. Examine paradigm Pattern for a sample program.
b. Structural Design Patterns in Java
Structural Java patterns give alternative ways to form a class structure, as an example mistreatment inheritance and composition to form an outsized object from small objects.
i. Adapter Pattern
Adapter design patterns in Java, one amongst the structural design pattern and it’s used in order that 2 unrelated interfaces will work along. The object that joins these unrelated interfaces calls as an Adapter. As a true-life example, we can think about a mobile charger as an adapter as a result of mobile battery wants three volts to charge however the normal socket produces either 120V (US) or 240V (India). Therefore the mobile charger works as an adapter between mobile charging socket and also the electrical outlet.
ii. Composite Pattern
Composite Java pattern, one amongst the Structural design pattern and employes once we have to be compelled to represent a part-whole hierarchy. Once we ought to produce a structure in a very approach that the objects within the structure need to be treated identical approach, we can apply composite design pattern.
iii. Proxy Pattern
The proxy pattern in Java aims to provide a replacement r surrogate for one more object for control. Proxy pattern employes once we need to produce controlled access to a practicality.
iv. Flyweight Pattern
Flyweight Java design pattern employes once we ought to produce a lot of Objects of a class. Since each object consumes memory space that may be crucial for low memory devices, corresponding to mobile devices or embedded systems, flyweight design pattern applies to reduce the load on memory by sharing objects.
v. Facade Pattern
Facade pattern employes to help consumer applications to simply act with the system. Suppose we’ve got an application with a set of interfaces to use MySQL/Oracle database and to come up with different types of reports, corresponding to hypertext mark-up language report, PDF report etc. Therefore we’ll have a totally different set of interfaces to figure with differing types of database. Currently, a consumer application will use these interfaces to urge the specified info affiliation and generate reports. However once the complexity will increase or the interface behavior names are confusing, consumer application can realize it troublesome to manage it. Therefore we can apply Facade pattern here and supply a wrapper interface on high of the prevailing interface to assist consumer application. Examine Facade Pattern post for implementation details and a sample program.
vi. Bridge Pattern
Bridge design patterns in Java employes to decouple the interfaces from implementation and concealment the implementation details from the consumer programs. Like Adapter pattern, it’s one amongst the Structural design pattern.
vii. Decorator Pattern
Decorator design pattern employes to change the practicality of an object at runtime. At identical time alternative instances of the identical class won’t be full of this, therefore individual object gets the changed behavior. Decorator design pattern, one amongst the structural design pattern (such as Adapter Pattern, Bridge Pattern, Composite Pattern) and uses abstract classes or interface with the composition to implement.
c. Behavioural Design Patterns in Java
Behavioural Java patterns give an answer for the higher interaction between objects and the way to produce lose coupling and adaptability to increase simply.
i. Template method Pattern
Template method in Java defines the steps to execute a rule and it will give default implementation that may be common for all or a number of the subclasses
ii. Mediator Pattern
Mediator design patterns in Java employes to produce a centralized communication medium between totally different objects in a very system. we can use it in an enterprise application wherever multiple objects interacting with one another. If the objects act with one another directly, the system elements are tightly-coupled with one another that creates maintainability price higher and not versatile to increase simply. Mediator pattern focuses on to give a mediator between objects for communication and facilitate in implementing lose-coupling between objects.
iii. Chain of Responsibility Pattern
Chain of responsibility pattern employes to attain lose coupling in software system design wherever asking from the consumer pass to a chain of objects to method them. Then the object within the chain can decide themselves who are going to process the request and whether or not the request is needed to be sent to future object within the chain or not.
iv. Observer Pattern
Observer design patterns in Java beneficial to you within the state of an object and needs to urge notified whenever there’s any modification. In observer pattern, the item that watches on the state of another object are known as Observer and also the object that’s being watched inbuilt Subject.
Java provides intrinsically platform for implementing observer pattern through java.util.Observable category and java.util.Observer interface. As a result of the implementation, most of the days we tend to don’t need to finish up extending a category only for implementing Observer pattern as java doesn’t give multiple inheritances in categories
v. Strategy Pattern
Strategy pattern is additionally referred to as Policy Pattern and has multiple rules for a specific task and consumer decides the actual implementation to be used at runtime.
We tend to define multiple rules and let consumer application pass the algorithm to be used as a parameter. one amongst the simplest example of this pattern is Collections.sort() method that takes Comparator parameter. supported the various implementations of Comparator interfaces, the Objects have gotten sorted in numerous ways that.
vi. Command Pattern
Command Pattern employes to implement loose coupling in a very request-response model. Thus the request send to the invoker and invoker passes it to the encapsulated command object. Command object passes the request to the acceptable method of the receiver to perform the particular action.
vii. State Pattern
State design patterns in Java employes once an Object changes its behavior supported by its internal state.
If we’ve got to alter the behavior of an object supported its state, we can have a state variable within the Object and use if-else condition block to perform totally different actions supported the state. State pattern employes to produce a scientific and close-coupled thanks to achieving this through Context and State implementations.
viii. Visitor Pattern
The visitor pattern employees once we have to compel to perform an operation on a bunch reasonably Objects. With the assistance of traveller pattern, we can move the operational logic from the objects to a different an.
ix. Interpreter Pattern
Defines a grammatical illustration for a language and provides an interpreter to influence this grammar.
java compiler, the best example of this pattern, interprets the java ASCII text file into computer memory unit code that’s apprehensible by JVM. Google Translator additionally an example of interpreter pattern wherever the input may contain any language and that we will get the output in another language.
x. Iterator Pattern
Iterator pattern in one amongst the behavioral pattern accustom give a customary thanks to traverse through a bunch of Objects. It employes in Java assortment Framework wherever Iterator interface provides strategies for traversing through a group
Iterator pattern doesn’t solely regarding traversing through a group, we can give totally different reasonably iterators supported our needs. Iterator pattern hides the particular implementation of traversal through the gathering and consumer programs simply use iterator strategies. Examine Iterator Pattern post as an example program and implementation details.
xii. Memento Pattern
Memento design patterns in Java employees once we need to save lots of the state of an object in order that we can restore shortly. It employees to implement this in such how that the save state data of the item not accessible outside of the item, this protects the integrity of saving state data.
Memento pattern enforces with 2 objects – creator and Caretaker. The originator is that the object whose state has to save and restore and it uses an inner class to save lots of the state of Object. The inner category call as a reminder and its private, in order that it can’t access from other objects.
So, this was all about design patterns in Java. Hope you like our explanation.
Hence, in this Java tutorial, we learned about the design patterns in Java. Moreover, discussed 3 categories of Java design patterns i.e. Creational, Behavioural, and Structural Java Design Patterns. Also, we saw design pattern examples. Still, if any doubt regarding design in Java patterns, ask in the comment tab.