Providing a static method encapsulated in a class called factory, in order to hide the implementation logic and makes client code focus on usage rather then initialization new objects.
Providing a static method encapsulated in a class called factory, in order to hide the
implementation logic and makes client code focus on usage rather then initialization new objects.
## Explanation
Real world example
> Lets say we have a web application connected to SQLServer, but now we want to switch to Oracle. To do so without modifying existing source code, we need to implements Simple Factory pattern, in which a static method can be invoked to create connection to a given database.
> Lets say we have a web application connected to SQLServer, but now we want to switch to Oracle. To
> do so without modifying existing source code, we need to implements Simple Factory pattern, in
> which a static method can be invoked to create connection to a given database.
Wikipedia says
> Factory is an object for creating other objects – formally a factory is a function or method that returns objects of a varying prototype or class.
> Factory is an object for creating other objects – formally a factory is a function or method that
> returns objects of a varying prototype or class.
**Programmatic Example**
We have an interface 'Car' and tow implementations 'Ford' and 'Ferrari'.
We have an interface `Car` and two implementations `Ford` and `Ferrari`.
```java
/**
* Car interface.
*/
publicinterfaceCar{
publicStringgetDescription();
StringgetDescription();
}
/**
* Ford implementation.
*/
publicclassFordimplementsCar{
staticfinalStringDESCRIPTION="This is Ford.";
...
...
@@ -54,9 +50,6 @@ public class Ford implements Car {
}
}
/**
* Ferrari implementation.
*/
publicclassFerrariimplementsCar{
staticfinalStringDESCRIPTION="This is Ferrari.";
...
...
@@ -68,14 +61,11 @@ public class Ferrari implements Car {
}
```
Enumeration above represents types of cars that we support (Ford and Ferrari).
Enumeration above represents types of cars that we support (`Ford` and `Ferrari`).
```java
publicenumCarType{
/**
* Enumeration for different types of cars.
*/
FORD(Ford::new),
FERRARI(Ferrari::new);
...
...
@@ -90,17 +80,12 @@ public enum CarType {
}
}
```
Then we have the static method 'getCar' to create car objects encapsulated in the factory class 'CarSimpleFactory'.
Then we have the static method `getCar` to create car objects encapsulated in the factory class
`CarSimpleFactory`.
```java
/**
* Factory of cars.
*/
publicclassCarsFactory{
/**
* Factory method takes as parameter a car type and initiate the appropriate class.
*/
publicstaticCargetCar(CarTypetype){
returntype.getConstructor().get();
}
...
...
@@ -122,17 +107,21 @@ Program output:
ThisisFord.
ThisFerrari.
```
## Class Diagram
![alt text](./etc/factory.urm.png"Factory pattern class diagram")
## Applicability
Use the Simple Factory pattern when you only care about the creation of a object, not how to create and manage it.
## Pros
Use the Simple Factory pattern when you only care about the creation of a object, not how to create
and manage it.
Pros
* Allows keeping all objects creation in one place and avoid of spreading 'new' key value across codebase.
* Allows to writs loosely coupled code. Some of its main advantages include better testability, easy-to-understand code, swappable components, scalability and isolated features.
## Cons
Cons
* The code becomes more complicated than it should be.
## Related patterns
...
...
@@ -140,5 +129,3 @@ Use the Simple Factory pattern when you only care about the creation of a object