Design Patterns
What are design patterns?
Design patterns are general solutions providing a way to solve problems that commonly arise during software development. These solutions are proven through tests, trial and errors to be effective in improving overall code efficiency and readability. A design pattern is a template or a general concept that a developer can apply while developing a software, it is not a solution that can be transformed directly into code.
Why use design patterns?
Using design patterns to aid with development can help improve code quality, accelerate the process, and prevents the need to create a new pattern every time a design problem arises.
Types of design patterns
According to a book titled ‘Design Patterns - Elements of Reusable Object-Oriented Software’ published in 1994 by four authors (Known as Gang of Four) there are 23 different design patterns. These design patterns can mainly be classified into three categories:
- Creational Design Patterns
- Structural Design Patterns
- Behavioral Design Patterns
Each category is different in terms of complexity, level of detail and the scale of system being designed.
Creational Design Patterns
Creational Design Patterns tackles how to handle the creation of new objects. These patterns increase flexibility and reusability of code.
Examples of creational design patterns include:
- Factory Method Pattern
- Singleton Pattern
- Prototype Pattern
Structural Design Patterns
Structural Design Patterns focuses on how objects connect and relate with one another. These patterns help create structures using multiple objects and classes.
Examples of structural design patterns include:
- Facade Pattern
- Adapter Pattern
- Composite Pattern
- Proxy Pattern
- Decorator Pattern
Behavioral Design Patterns
Behavioral Design Patterns addresses how each object has a different purpose and work towards a common goal. These patterns focus mainly on the communication between objects and responsibility distribution between one object and the other.Examples of behavioral design patterns include:
- Template Method Pattern
- Chain of Responsibility Pattern
- Command Pattern
- Observer Pattern
- Strategy Pattern
Differences between similar design patterns
Strategy Pattern Vs Factory Method Pattern
Strategy Pattern
The Strategy design pattern is a type of behavioral design patterns that is used when representing multiple objects each having a different strategy of performing a behavior. In this pattern there is a context object that preforms that behavior based on desired strategy.
UML Diagram
When to use Strategy Pattern?
This pattern can be used when needed to switch between different variations of algorithms performing a certain behavior on runtime.
Example:
// ParkingStratetgy.java
public interface ParkingStratetgy {
public int parkCar(int carLicenseNumber);
}
// ParrallelPark.java
public class ParrallelPark implements ParkingStratetgy {
@Override
public String parkCar (int carLicenseNumber){
return “Car with license plate: “+carLicenseNumber+” parked parallelly”;
}
}
// PerpendicularPark.java
public class PerpendicularPark implements ParkingStratetgy {
@Override
public String parkCar (int carLicenseNumber){
return “Car with license plate: “+carLicenseNumber+” parked perpendicularly”;
}
}
// ParkingSpace.java
public class ParkingSpace {
private ParkingStratetgy parkingStratetgy;
public parkCar (ParkingStratetgy parkingStratetgy){
this. parkingStratetgy = parkingStratetgy;
}
public String parkCar(int carLicenseNumber){
return parkingStratetgy. parkCar(carLicenseNumber);
}
}
//StrategyPatternDemo.java
public class StrategyPatternDemo {
public static void main(String[] args) {
ParkingSpace parkingSpace = new ParkingSpace(new PerpendicularPark ());
System.out.println(parkingSpace. parkCar (123));
parkingSpace =new ParkingSpace (new ParrallelPark ());
System.out.println(parkingSpace. parkCar (756));
}
}
//Output
// Car with license plate: 123 parked perpendicularly
// Car with license plate: 756 parked parallelly
Factory Method Pattern
The Factory Method design pattern is a type of creational design patterns that is used to create an object by defining an interface that lets subclasses decide on the object type being created. This pattern abstracts creation logic from the clients.
UML Diagram
When to use Factory Method Pattern?
This pattern can be used when wanting a class to differ instantiation to its subclasses rather than the class itself.
Example:
//Notification.java
public interface Notification {
void notifyUser();
}
//SMSNotification.java
public class SMSNotification implements Notification {
@Override
public void notifyUser()
{
// TODO Auto-generated method stub
System.out.println("Sending an SMS notification");
}
}
//EmailNotification.java
public class EmailNotification implements Notification {
@Override
public void notifyUser()
{
// TODO Auto-generated method stub
System.out.println("Sending an e-mail notification");
}
}
//PushNotification.java
public class PushNotification implements Notification {
@Override
public void notifyUser()
{
// TODO Auto-generated method stub
System.out.println("Sending a push notification");
}
}
//NotificationFactory.java
public class NotificationFactory {
public Notification createNotification(String channel)
{
if (channel == null || channel.isEmpty())
return null;
switch (channel) {
case "SMS":
return new SMSNotification();
case "EMAIL":
return new EmailNotification();
case "PUSH":
return new PushNotification();
default:
throw new IllegalArgumentException("Unknown channel "+channel);
}
}
}
//NotificationService.java
public class NotificationService {
public static void main(String[] args)
{
NotificationFactory notificationFactory = new NotificationFactory();
Notification notification = notificationFactory.createNotification("SMS");
notification.notifyUser();
}
}
Similarities between Strategy Pattern and Factory Method Pattern
Both patterns have a main class that lets subclasses or implementation classes determine the way this main class works. In the case of Factory method pattern subclasses hold the creational logic of the main class. While in Strategy pattern, classes that implement the main class determine the behavior of certain functionalities of the main class.
Differences between Strategy Pattern and Factory Method Pattern
Composite Pattern Vs Decorator Pattern
Composite Pattern
The Composite design pattern is composing objects into tree structures, allowing clients to interact with separate objects and compositions of objects in a similar matter.
UML Diagram
When to use Composite Pattern?
This pattern can be used when needed to treat a group of objects the same way as a single object.
Example:
//Department.java
public interface Department {
void printDepartmentName();
}
//FinancialDepartment.java
public class FinancialDepartment implements Department {
private Integer id;
private String name;
public void printDepartmentName() {
System.out.println(getClass().getSimpleName());
}
}
//SalesDepartment.java
public class SalesDepartment implements Department {
private Integer id;
private String name;
public void printDepartmentName() {
System.out.println(getClass().getSimpleName());
}
}
//HeadDepartment.java
public class Head
Department implements Department {
private Integer id;
private String name;
private List childDepartments;
public HeadDepartment(Integer id, String name) {
this.id = id;
this.name = name;
this.childDepartments = new ArrayList<>();
}
public void printDepartmentName() {
childDepartments.forEach(Department::printDepartmentName);
}
public void addDepartment(Department department) {
childDepartments.add(department);
}
public void removeDepartment(Department department) {
childDepartments.remove(department);
}
}
Decorator Pattern
The Decorator design pattern is wrapping a class with another class that provides additional functionalities without altering the original class methods signatures.
UML Diagram
When to use Decorator Pattern?
This pattern is mainly used to alter project code to add functionalities without changing the existing core classes. It can also be used when wanting to reduce the number of classes needed to offer a combination of behaviors.
Example:
//VisitEngine.java
public interface VisitEngine {
String getEngineeringOfficeId();
String getEngineeringOfficeCityId();
int getRemainingCapacity();
List calculateVisits();
}
//GroupOneDecorator.java
public class GroupOneDecorator implements VisitEngine {
private VisitEngine engine;
private int groupCapacity;
private Queue groupOneLicenses;
private int remainingCapacity;
private List generatedVisits;
public GroupOneDecorator(VisitEngine engine, int groupCapacity, Queue groupOneLicenses) {
this.engine = engine;
this.groupCapacity = groupCapacity;
this.groupOneLicenses = groupOneLicenses;
generatedVisits = new ArrayList<>();
}
@Override
public List calculateVisits() {
List calculatedVisits = this.engine.calculateVisits();
generatedVisits.addAll(calculatedVisits);
remainingCapacity += groupCapacity;
return generatedVisits;
}
@Override
public String getEngineeringOfficeId() {
return engine.getEngineeringOfficeId();
}
@Override
public String getEngineeringOfficeCityId() {
return engine.getEngineeringOfficeCityId();
}
@Override
public int getRemainingCapacity() {
return remainingCapacity;
}
public int getGroupCapacity() {
return this.groupCapacity;
}
}
//GroupTwoDecorator.java
public class GroupTwoDecorator implements VisitEngine {
private VisitEngine engine;
private int groupCapacity;
private Queue groupTwoLicenses;
private int remainingCapacity;
private List generatedVisits;
public GroupTwoDecorator(VisitEngine engine, int groupCapacity, Queue groupTwoLicenses) {
this.engine = engine;
this.groupCapacity = groupCapacity;
this.groupTwoLicenses = groupTwoLicenses;
this.generatedVisits = new ArrayList<>();
}
@Override
public List calculateVisits() {
List calculatedVisits = this.engine.calculateVisits();
this.groupCapacity += engine.getRemainingCapacity();
generatedVisits.addAll(calculatedVisits);
remainingCapacity = groupCapacity;
return generatedVisits;
}
@Override
public String getEngineeringOfficeId() {
return engine.getEngineeringOfficeId();
}
@Override
public String getEngineeringOfficeCityId() {
return engine.getEngineeringOfficeCityId();
}
@Override
public int getRemainingCapacity() {
return remainingCapacity;
}
}
Similarities between Decorator Pattern and Composite Pattern
Both patterns aim to embed objects within another. The composite pattern embeds classes in a tree like structure while decorator pattern a class embeds another by wrapping to provide extra functionalities.
Differences between Decorator Pattern and Composite Pattern
.webp)
.webp)
