This is Part 1 of the Series: Software Design Patterns. In this tutorial series, I would explain to you the important software design patterns you need to know. There are actually dozens of Software Design Patterns out there. However, many of them are just features natively supported by certain programming languages.<\/p>\n
We would examine three categories of Software Design Patterns namely Creational Patterns, Structural Patterns and Behavioural Patterns.<\/p>\n
In this part, we would focus on Creational Patterns and we would cover the following:<\/p>\n
We would also try to give example with code snippet on how each is applied.<\/p>\n
<\/p>\n
To understand the Factory Pattern, we first need to understand the concept of Factory in programming. A factory is simply an object for creating other objects. It could be a function that returns an object. Such function if called a factory function and it normally invokes the “new”.<\/p>\n
For example, in a Spring application,\u00a0 we can have a factory function is given below that returns a RestTemplate object. This is shown below:<\/p>\n
@Bean<\/span>\r\npublic<\/span> RestTemplate getRestTemplate<\/span>()<\/span> {<\/span>\r\n return<\/span> new<\/span> RestTemplate<\/span>();<\/span>\r\n}<\/span>\r\n<\/pre>\n <\/p>\n
From the example above, if you need to want a new RestTemplate, you simply declare a private method of RestTemplate and annotate it with @Autowired<\/em> <\/strong>annotation. Like so:<\/p>\n@Autowired<\/span>\r\nprivate<\/span> RestTemplate restTemplate;<\/span>\r\n<\/pre>\n <\/p>\n
Benefits of Factory Pattern<\/strong><\/p>\n\n- subclasses of objects and redefine which classes to instantiate<\/li>\n
- instantiation is deferred to subclases<\/li>\n<\/ul>\n
<\/p>\n
2. Singleton Pattern<\/strong><\/h4>\nThis pattern restricts the instantiation of a class to just a single instance. It ensures that<\/p>\n
\n- only one instance of an object exists<\/li>\n
- provides access to that instance<\/li>\n
- controls creation of new objects<\/li>\n<\/ul>\n
Singleton pattern has the benefit of keeping the global namespace clean and also permits lazy initialization. This is preferred to global variables. To implement singleton class, you will have to:<\/p>\n
\n- declare all the constructors of the class as private. In this way, the class can’t be instantiated<\/li>\n
- provide a static method that returns a reference to that instance<\/li>\n<\/ul>\n
Example of a singleton class is given below:<\/p>\n
public<\/span> class<\/span> Student<\/span> {<\/span>\r\n private<\/span> static<\/span> Student instance =<\/span> new<\/span> Student();<\/span> \/\/ eagerly loads the singleton<\/span>\r\n private<\/span> int<\/span> count;<\/span>\r\n private<\/span> Student<\/span>(){<\/span>\r\n \/\/private to prevent instantiation from outside<\/span>\r\n }<\/span>\r\n \r\n public<\/span> static<\/span> Student getInstance<\/span>(){<\/span>\r\n return<\/span> instance;<\/span>\r\n }<\/span>\r\n public<\/span> int<\/span> getCount<\/span>()<\/span> {<\/span>\r\n return<\/span> count;<\/span>\r\n }<\/span>\r\n}<\/span>\r\n<\/pre>\n <\/p>\n
3. Builder Pattern<\/strong><\/h4>\nThis is a pattern that breaks down the construction of complex object into several steps. The objective is to separate complex object creation from its representation. The Builder patter follows the approach:<\/p>\n
\n- encapsulate the creation and assembling of various parts of a complex object into a separate Builder object<\/li>\n
- object creation is delegated to a Builder object instead of creating the object directly<\/li>\n<\/ul>\n
Since demonstrating this pattern is a bit more involved, you can find details in The Builder Pattern<\/p>\n
<\/p>\n
4. Prototype Pattern<\/strong><\/h4>\nIn the Prototype Pattern, new objects are created based on an existing prototype.<\/p>\n
To implement this pattern,\u00a0 you need to first create a base abstract class. This class would specify a pure virtual clone()<\/em> function. So classes can then derive from this abstract class implementing the clone()<\/em> method.<\/p>\n\/\/ Prototype Base class<\/span>\r\npublic<\/span> abstract<\/span> class<\/span> Shape<\/span> implements<\/span> Cloneable {<\/span>\r\n public<\/span> Shape clone<\/span>()<\/span> throws<\/span> CloneNotSupportedException{<\/span>\r\n return<\/span> (<\/span>Shape)<\/span> super<\/span>.<\/span>clone<\/span>();<\/span>\r\n }<\/span>\r\n}<\/span>\r\n\r\n\/\/ Derived class Rectangle using the Prototype<\/span>\r\npublic<\/span> class<\/span> Rectangle<\/span> extends<\/span> Shape {<\/span>\r\n @Override<\/span>\r\n public<\/span> Shape clone<\/span>()<\/span> throws<\/span> CloneNotSupportedException {<\/span>\r\n return<\/span> (<\/span>Rectangle)<\/span>super<\/span>.<\/span>clone<\/span>();<\/span>\r\n }<\/span>\r\n}<\/span>\r\n\r\n\/\/ Derived class Square using the Prototype<\/span>\r\npublic<\/span> class<\/span> Square<\/span> extends<\/span> Shape {<\/span>\r\n @Override<\/span>\r\n public<\/span> Shape clone<\/span>()<\/span> throws<\/span> CloneNotSupportedException {<\/span>\r\n return<\/span> (<\/span>Square)<\/span>super<\/span>.<\/span>clone<\/span>();<\/span>\r\n }<\/span>\r\n}<\/span>\r\n<\/pre>\n <\/p>\n
\n