Apply Design Patterns In Java (Part 1)

1. Overview

Design patterns are proven valuable solutions that serve as a model for solving design problem and may be used in a variety of situations to provide effective and efficient results. It also helps making your code readable and maintainable. Following are generally the design pattern categories:

• Creational Patterns: Deal with object creation mechanisms in such a way that one can create objects suitable to the situation (e.g., Singleton, Factory, Builder).
• Structural Patterns: Deal with object composition, forming larger structures from objects (e.g., Adapter, Composite, Proxy).
• Behavioral Patterns: Deal with object collaboration and how the responsibilities are assigned between objects (e.g., Strategy, Observer, Command).

Applying design patterns allows creating more maintainable, scalable, and reliable software.

2. Strategy Pattern

2.1 Definition

Strategy is a behavioral design pattern that lets you define a family of algorithms, put each of them into a separate class, and make their objects interchangeable.

2.2 Problem

We have a class NotificationService like this:

In the initial design, NotificationService has a type field that determines how to send notifications. This approach has several drawbacks:

• Hard to Extend: Adding a new notification type requires modifying the NotificationService class.
• Violation of Open/Closed Principle: The class should be open for extension but closed for modification.
• Increased Complexity: Conditional logic within the sendNotification method can make the class more complex and harder to maintain.

2.3 Solution

The Strategy Pattern refactors NotificationService to use a Notifier interface, which allows different notification strategies (e.g., SMSNotifier, EmailNotifier). This design:

• Enhances Flexibility: New notification methods can be added without modifying NotificationService.
• Adheres to the Open/Closed Principle: New strategies can be introduced without changing existing code.
• Simplifies Maintenance: Each notification strategy is encapsulated in its own class, reducing complexity in NotificationService.

2.4 Code Example

• Problem

• Solution

3. Factory Method Pattern

3.1 Definition

Factory Method is a creational design pattern that provides an interface for creating objects in a superclass, but allows subclasses to alter the type of objects that will be?created.

3.2 Problem

In the initial design, the NotificationService directly depends on the Notifier interface, and specific notifier types like SMSNotifier and EmailNotifier are directly instantiated. This approach:

• Hard to Extend: Adding new notifier types requires changes in NotificationService.
• Tight Coupling: The service is tightly coupled with specific notifier implementations.

3.3 Solution

The Factory Method Pattern introduces an abstract NotifierCreator class with a createNotifier method. Subclasses (SMSNotifierCreator and EmailNotifierCreator) override this method to instantiate specific notifiers. This design:

• Enhances Flexibility: New notifier types can be added by creating new subclasses of NotifierCreator.
• Reduces Coupling: NotificationService depends on the NotifierCreator interface, not on specific notifier implementations.

3.4 Code Example

• Problem

• Solution