Java Design Patterns for Beginners with Diagrams & Code

The Prototype Design Pattern is a creational design pattern that allows an object to create a copy (or clone) of itself. This pattern is useful when creating a new object is costly, or when you want to keep the new object’s state the same as an existing one. Instead of instantiating a new object from a class directly, the prototype pattern creates a new object by copying an existing object.

The clone() method (or equivalent) is defined in the prototype and implemented in the concrete prototype classes. The client can then create new objects by copying prototypes without knowing their specific types.

Use Cases:

• When object creation is expensive (e.g., involves complex initialization, I/O operations, or heavy computational processes).

• When an object has many configurations that can be reused with small modifications.

• When you want to avoid subclasses or having a system be dependent on concrete classes.

The Builder Design Pattern is a creational design pattern that allows for the construction of complex objects step by step. Unlike other creational patterns that create objects in a single step, the Builder pattern focuses on the construction process. It separates the construction of an object from its representation, allowing the same construction process to create different representations.

Key components:

1. Builder: This is an interface or abstract class defining the steps to build the object. Each method in the interface typically corresponds to a part of the object being constructed.

2. Concrete Builder: Implements the builder interface, providing implementations for the building steps and keeping track of the representation it builds. It defines how the individual parts are created.

3. Director: This class is responsible for managing the correct sequence of object construction. It knows which concrete builder to use and in what order to execute the build steps, though this is optional in some implementations.

4. Product: The complex object that is being constructed.

The Adapter Pattern is a structural design pattern that allows objects with incompatible interfaces to work together. It acts as a bridge between two interfaces, converting the interface of a class into another interface that a client expects.

Key components:

• Client: The entity that wants to use some service but cannot because of incompatible interfaces.

• Adaptee: The class or object that has an interface that the client cannot directly use.

• Adapter: The intermediary that translates the client's request into a format that the Adaptee can understand.

Types of Adapter Patterns:

Object Adapter: Uses composition to adapt an object (as shown above).

Class Adapter: Uses inheritance, where the adapter inherits from both the target interface and the adaptee class. This is more restrictive since it only works in languages that support multiple inheritance.

Use Case:

You would use the Adapter Pattern when:

1. You have existing code that you cannot change (like a library) but need to integrate with new systems.

2. You need to convert data or interface formats to allow systems to work together.

3. You want to reuse a class that doesn't have the expected interface.

SpringMVC:

Handler: Servlet, Controller interface, Controller method with annotation @RequestMapping, HttpRequest

The Bridging Pattern is a structural design pattern in object-oriented software design that decouples an abstraction from its implementation, allowing both to vary independently. This pattern is useful when you want to avoid a permanent binding between an abstraction and its implementation. It helps in the case where you want to be able to change the abstraction as well as the implementation dynamically.

Key components:

Abstraction: This is the core interface or abstract class that defines the main functionality, but it doesn’t implement it directly. Instead, it maintains a reference to an implementation object.

Implementor: This is an interface that defines the method(s) to be implemented by the concrete implementation classes. The implementor is independent of the abstraction and can vary without affecting the abstraction.

Concrete Abstraction: This is a concrete class that extends the abstraction and uses the methods of the implementor to achieve its functionality.

Concrete Implementor: These are the actual classes that implement the Implementor interface and provide concrete implementations for the methods defined in it.

Benefits of the Bridge Pattern:

• Decoupling: The abstraction and implementation are decoupled, allowing both to evolve separately without affecting each other.

• Flexibility: You can switch between different implementations without modifying the abstraction.

• Scalability: New abstractions and implementations can be added easily without impacting existing code.

The Decorator Pattern is a structural design pattern used to extend the functionality of an object dynamically without altering its structure. It allows behavior to be added to individual objects, either statically or dynamically, without affecting the behavior of other objects from the same class.

Key components:

1. Component Interface: This defines the common interface for both decorators and the original object that will be wrapped.

2. Concrete Component: The class that we are decorating. This is the object whose behavior is being dynamically extended.

3. Decorator Class: This implements the same interface as the concrete component. It contains a reference to a component object and delegates all the work to the referenced object while adding some additional behavior.

4. Concrete Decorators: These are the actual decorators that extend the functionality of the component by adding their own behavior.

Composite Pattern is a structural design pattern used to treat individual objects and compositions of objects uniformly. It allows you to compose objects into tree-like structures to represent part-whole hierarchies, where individual objects and composite objects are handled in the same way.

Key components:

1. Component: An interface that defines the operations that can be performed on both individual objects and their compositions.

2. Leaf: Represents the individual objects that do not have any children. Implements the Component interface.

3. Composite: Contains child components and implements the Component interface. A composite object can contain multiple leaf or composite objects.

Benefits of using the Composite Pattern:

Simplifies Client Code:

Clients can treat both individual objects and composite structures uniformly. You don't need to worry whether you're dealing with a single object or a whole hierarchy, which reduces conditional logic and code complexity.

Easily Extendable:

It's easy to add new kinds of components without changing existing code. By adhering to a common interface, you can introduce new leaf or composite types with minimal impact on the client code.

Supports Recursive Structures:

The Composite Pattern is ideal for implementing recursive structures like trees, where components can contain children that are themselves either individual objects or further composites.

Promotes Flexibility:

You can dynamically create complex tree structures at runtime and manipulate them flexibly (e.g., adding or removing components without affecting the rest of the system).

Facilitates Polymorphism:

By relying on a common interface for leaf and composite nodes, the pattern promotes the use of polymorphism, allowing objects to be used interchangeably without knowing their specific type.

Reduces Duplication:

Since leaf and composite nodes share the same interface, duplicate code for handling individual and composite elements is minimized.