In my previous article, I spoke about fault tolerance design patterns in distributed systems. In this article, I will talk about the design patterns used for object creation.
Fault Tolerance Design Patterns in Distributed Systems | by Ethiraj Srinivasan | BootcampDistributed systems are made up of multiple interconnected components that work together to provide a service. Exploring patterns that keep them resilient when parts fail.
Creational patterns are a subset of design patterns that describes the object creation mechanisms. It helps to create objects flexibly and efficiently and provides loose coupling between classes. These design patterns provide abstraction in the object creation process, hiding the specific details during object instantiation.
Creational patterns are useful when the object creation is complex, has multiple steps, or requires creating different types of objects based on certain constraints. Creational Patterns aim to make the code maintainable, easier, and extensible.
Some of the creational patterns are
-
Factory method pattern
-
Builder pattern
-
Singleton pattern
-
Abstract factory pattern
-
Prototype pattern
Each creational pattern has its requirement and scenarios. We will look at the Factory method pattern and Builder pattern in detail.
Factory Method Pattern
Factory Method Pattern provides an interface for object creation and allows subclasses to alter the object instantiated. The object creation logic is encapsulated in a separate method called the factory method.
Photo by Alex Simpson on Unsplash
The factory method provides loose coupling as the client code depends only on the interface of the factory rather than any specific class. Thus new subclasses can be added without modifying any of the client code as long as it follows the factory method's interface.
1// Fruit interface
2interface Fruit {
3 void display();
4}
5
6// Orange class implementing Fruit
7class Orange implements Fruit {
8 @Override
9 public void display() {
10 System.out.println("This is an orange.");
11 }
12}
13
14// Apple class implementing Fruit
15class Apple implements Fruit {
16 @Override
17 public void display() {
18 System.out.println("This is a apple.");
19 }
20}
21
22// Factory class for creating fruits
23class FruitFactory {
24 public Fruit createFruit(String fruitType) {
25 if (fruitType.equalsIgnoreCase("orange")) {
26 return new Orange();
27 } else if (fruitType.equalsIgnoreCase("apple")) {
28 return new Apple();
29 }
30 // Handle additional fruit types here
31
32 return null; // Return null if the requested fruit type is not supported
33 }
34}
35
36// Game class
37class Game {
38 private FruitFactory fruitFactory;
39
40 public Game() {
41 fruitFactory = new FruitFactory();
42 }
43
44 public void collectFruit(String fruitType) {
45 Fruit fruit = fruitFactory.createFruit(fruitType);
46 if (fruit != null) {
47 System.out.println("Collected a fruit!");
48 fruit.display();
49 } else {
50 System.out.println("Sorry, the requested fruit is not available.");
51 }
52 }
53}
54
55// Usage
56public class Main {
57 public static void main(String[] args) {
58 Game game = new Game();
59
60 game.collectFruit("apple"); // Output: Collected a fruit! This is an apple.
61 game.collectFruit("orange"); // Output: Collected a fruit! This is a orange.
62 game.collectFruit("banana"); // Output: Sorry, the requested fruit is not available.
63 }
64}In the example above the Fruit interface describes the common behaviour of fruits. Apple and Orange are implementations of the Fruit interface.
FruitFactory class is the factory and createFruit() is the factory method that takes fruit type as the parameter. It instantiates specific fruit class based on the parameter.
The Game class uses the fruit factory to create and collect fruits. The collectFruit() method with the specific fruit type as a parameter is responsible for creating and collecting fruits.
In the main() method, we create an instance of the Game class and call the collectFruit() method. The FruitFactory creates the fruits and displays the fruit.
Thus a Factory Method Pattern helps to instantiate different fruits with the flexibility to add new fruits to the game without modifying the Game class ( client code).
Builder Pattern
The builder pattern helps to build a complex object step by step. The construction and representation of the object are separated using this pattern and allow the same process to create different object representations.
Photo by Baron on Unsplash
It helps in the readability and maintenance of the code by providing a clear way to get the required properties of the object during instantiation.
1// Car class
2class Car {
3 private String engine;
4 private boolean hasSunroof;
5 private String transmission;
6 private int numWheels;
7 private String color;
8
9 private Car(Builder builder) {
10 this.color = builder.color;
11 this.numWheels = builder.numWheels;
12 this.hasSunroof = builder.hasSunroof;
13 this.engine = builder.engine;
14 this.transmission = builder.transmission;
15 }
16
17 // Getters for the car properties
18 public String getTransmission() {
19 return transmission;
20 }
21
22 public boolean hasSunroof() {
23 return hasSunroof;
24 }
25
26 public String getColor() {
27 return color;
28 }
29
30 public int getNumWheels() {
31 return numWheels;
32 }
33
34 public String getEngine() {
35 return engine;
36 }
37
38 // Builder class
39 static class Builder {
40 private String color;
41 private boolean hasSunroof;
42 private String transmission;
43 private int numWheels;
44 private String engine;
45
46 public Builder setColor(String color) {
47 this.color = color;
48 return this;
49 }
50
51 public Builder setNumWheels(int numWheels) {
52 this.numWheels = numWheels;
53 return this;
54 }
55
56 public Builder setTransmission(String transmission) {
57 this.transmission = transmission;
58 return this;
59 }
60
61 public Builder setHasSunroof(boolean hasSunroof) {
62 this.hasSunroof = hasSunroof;
63 return this;
64 }
65
66 public Builder setEngine(String engine) {
67 this.engine = engine;
68 return this;
69 }
70
71 public Car build() {
72 return new Car(this);
73 }
74 }
75}
76
77// Usage
78public class Main {
79 public static void main(String[] args) {
80 Car car = new Car.Builder()
81 System.out.println("Color: " + car.getColor());
82 System.out.println("Engine: " + car.getEngine());
83 System.out.println("Transmission: " + car.getTransmission());
84 System.out.println("Number of Wheels: " + car.getNumWheels());
85 System.out.println("Has Sunroof: " + car.hasSunroof());
86 }
87}In the example above the Car.Builder class acts as the builder for the car construction. The car has different properties like color, engine, transmission, number of wheels, and sunroof.
The Car class has a private constructor with the builder object as its parameter. It then constructs the car based on the builder values.
The builder class provides the setter methods for the desired car properties and these methods return the builder object to support method chaining.
In the main() method, an instance of the car is created with the desired properties using the builder, and build() method is called to get the constructed car object.
This example shows how builder pattern can be used to construct a object with the desired properties using a flexible and readable manner. It allows the client code to configure the desired properties while ignoring other properties.
Hope the above explanations and implementation examples give you clarity on the creational designer pattern. Do note that each creational design pattern has its own set of requirements and constraints. Happy creating objects !!!