Design Pattern In Java

Table of Contents

What Are Design Patterns In Java

Design pattern In Java are defined as solutions to common problems in software design. These are well-proved solutions for solving specific tasks as the requirements of the final project. These act as the basic structure to solve a particular type of problem in your code. Usage of these design patterns you can make your code more flexible, reusable, and maintainable.

Advantages of Design Pattern In Java

These Design Pattern In Java ease out the work of software developers and have several benefits:

Patterns act as a blueprint for solutions to common problems in software design. They provide a structured approach to several problems.
They increase the reusability of the code as these can be used in multiple projects. Thus you can reuse it in similar situations, saving time and effort.
Helps building scalable software architectures that can accommodate vast changes keeping in mind the changing requirements of the user.
As the scalability of the project increases, it fosters the flexibility of the project as well. It makes the system more adaptable to changing requirements or environments.
As the design patterns are tried and tested solutions by several developers and software testers the risk of new errors and bugs in the code is reduced.

Thus, these patterns should be used appropriately during the analysis and requirement phase of SDLC to avail maximum benefit and achieve optimal solutions.

Types of Design Patterns

Core Java (or JSE) Design Patterns.
JEE Design Patterns.

Core Java Design Patterns

Core Design pattern In Java are those design patterns specifically applicable and commonly used in Java. These are broadly divided into

1. Creational Design Pattern

These design pattern In Java generally deal with the way of creating objects. (i.e. creating an object of a class).In Java, an object is created by using a new keyword

StudentId s=new StudentId();

Here, we created the instance by using the new keyword however with the changing requirements of users the nature of the object must be changed to accommodate those changes. In such cases, we must get the help of creational design patterns.

Now, these are further categorized into 6 types:

Factory Method Pattern: provides an interface/abstract class for creating an object and allows the sub-classes to choose the type of objects to create.
Abstract Factory Pattern: It undertakes to define an interface or abstract class for creating families of related objects but without specifying their concrete sub-classes.
Singleton Pattern: defines only one instance of a class and provides a global point of access to that instance.

It further has two forms:

Early Instantiation: the creation of instance at load time.
Lazy Instantiation: the creation of an instance when required.

Prototype Pattern: In this instead of creating a new object, cloning of an existing object takes place which can be customized as per the requirements.
Builder Pattern: this type incorporates step by step approach and thus constructs a complex object from simple objects.
Object Pool Pattern: this contains a collection of several objects that can be reused to create expensive/complex objects.

2. Structural Design Pattern

These design patterns In Java involve composing classes and objects to form larger structures, by inheriting the properties of other classes, while keeping those structures scalable and flexible.

Adapter Pattern: this type carries out the conversion of an interface of a particular class into another interface as per the user’s requirements.
Bridge Pattern: this is also known as Handle or Body, it decouples the functional abstraction to foster their independent implementation.
Composite Pattern: this is useful for creating a hierarchical structure of objects, and further helps to operate in a generic manner as per the client’s requirements.
Decorator Pattern: uses composition instead of inheritance to make the object more extensible, and attaches flexible additional responsibilities to an object. This is also known as Wrapper.
Facade Pattern: Provides a unified and simplified interface to a complex subsystem. This further promotes ease of the code and helps to hide complexities from the client.
Flyweight Pattern: this pattern focuses on reusing already existing similar kind of objects by storing them and create new object when no matching object is found.
Proxy Pattern: this simply means an object representing another object. This even provides control for accessing the original object. This is one of the easiest design pattern to implement.

3. Behavioral Design Pattern

Chain Of Responsibility Pattern: this Design pattern Java is a kind of referential model i.e. each receiver contains a reference of another receiver that behave like a change of code. This is mainly used in ATMs where continuity is required.
Command Pattern: this design pattern involves the creation of an Invoker Object. The request of the user is encapsulated as an object command and is passed to the invoker object. This further looks for an appropriate object which can handle the command until its final execution.
Interpreter Pattern: this pattern has a comparatively limited approach, where formal grammar expressions are used. Grammer is defined as a particular language along with the interpreter to interpret it sentence by sentence.
Iterator Pattern: In this type, a set way is defined to access elements of a sequence without exposing their implementation. This is also known as a cursor.
Mediator Pattern: this involves defining an object that encapsulates how a set of objects interacts. This pattern reduces communicational complexities when the length of the code along with the number of objects declared increases.
Memento Pattern: This pattern is also known as a token and involves the restoration of the object’s previous state. Therefore, it is used to implement the undo operation by saving the current state of the object as it changes state.
Observer Pattern: this maintains a one-to-one relation between the object and its dependencies in a way that if one object changes its state, all other dependent objects and variables are notified about the same and update their state automatically.
State Pattern: In this pattern the behavioral changes of the class are maintained as the class behavior changes based on its state. This is done by creating an object and a context object.
Strategy Pattern: Also known as Policy , this pattern involves defining a family of functionality, their encapsulation, and making them interchangeable to increase the flexibility of the code.
Template Pattern: It is very common technique for reusing the code, a blueprint or say a basic structure of the code function is defined leaving the definition of the steps of the subclasses for later stages.

• JEE or J2EE Design Patterns

These design pattern In Java are used for the development of Enterprise Web-based Applications and to address various concerns in enterprise applications. These differ in terms of their context and application from core Java design patterns. Core Java design patterns are typically applied to applications, libraries, or frameworks and deal with the creation of small-scale objects whereas JEE deals with enterprise-level large-scale applications.

1. Presentation Layer Design Pattern

These design pattern In Java provide different approaches to organizing the presentation layer of an application. These focus on constructing a structure that provides ways to increase the flexibility and scalability of the application.

Intercepting Filter Pattern: This pattern is used when we want to centralize the processing of the requests and provide ways to check the encoding scheme of the requests. It also helps to manipulate a request and its response before and after its processing.
Front Controller Pattern: This provides a unified single interface to handle all the requests. It also helps to control the page flow and navigation, perform authentication and authorization, and manage the data model.
View Helper Pattern: It helps in separating the presentation logic from the actual view templates, this is done by encapsulating the presentation logic in separate components.
Composite View Pattern: This helps to generate ways to manage complex views by dividing complex attributes into smaller reusable components. It also creates a hierarchical structure of views.

2. Business Layer Design Pattern

This type deals with the business layer of an application, various terminologies can be implemented to formulate interfaces that manage business logic effectively. Therefore, this facilitates maintainability, and flexibility in the business layer.

Business Delegate Pattern: This deals with the separation of the presentation tier from the business services. It further creates a centralized channel for communication between both the tiers, acts as an intermediary between the presentation tier (client) and the business services (components or services).
Service Locator Pattern: It is a centralized registry which maps service names to their corresponding implementations. This pattern thus mainly focus on locating instances and keeping a record of all these mapping in a centralized server.
Session Facade Pattern: This also creates a unified interface to a set of business services however it acts as a high-level interface where several components are stored in a single facade interface.
Transfer Object Pattern: This is used in distributed systems to facilitate proper transmission of data between several layers. This, therefore, reduces the number of remote calls and optimizes data transfer.

3. Integration Layer Design Pattern

This pattern facilitates communication and data exchange between different layers and systems. It further manages the complexities of the integration and thus increases the scalability and flexibility of the overall application.

Data Access Object Pattern: this design pattern provides an interface to access data sources such as databases and web servers. It provides a centralized interface for performing CRUD (Create, Read, Update, Delete) operations.
Web Service Broker Pattern: just like the former type, this design pattern interaction between clients and multiple web services. This acts like a middleware layer between web applications.

Design Pattern In Java FAQs

What is the difference between core and JEE design patterns?

These differ in terms of their context and application from core Java design patterns. Core Java design patterns are typically applied to applications, libraries, or frameworks and deal with the creation of small-scale objects whereas JEE deals with enterprise-level large-scale applications.

Describe the steps to design a pattern.

The first step is to analyze the requirements of the client and the available resources as per the application to be developed. Every design should have a set of rules and regulations for solving the problem. Then these designs should be mentioned during the analysis and requirement phase of SDLC. After conducting some tests, the design should be finalized.

Elaborate on the advantages of design patterns in brief.

These patterns increase the reusability of the code, which further can be used in multiple projects. These also provide template solutions and a structured approach to client's demands and thus facilitate the proper transfer of data within the layers of the application.