From a1da1e4973d82ebf958175b34b27710a8ec0b715 Mon Sep 17 00:00:00 2001
From: =?UTF-8?q?Ilkka=20Sepp=C3=A4l=C3=A4?= <ilkka.seppala@gofore.com>
Date: Sun, 6 Sep 2020 19:46:13 +0300
Subject: [PATCH] Cleanup factory

---
 factory/README.md                             | 51 +++++++------------
 .../main/java/com/iluwatar/factory/Car.java   |  2 +-
 2 files changed, 20 insertions(+), 33 deletions(-)

diff --git a/factory/README.md b/factory/README.md
index 9ab61b579..5fd97ccae 100644
--- a/factory/README.md
+++ b/factory/README.md
@@ -15,35 +15,31 @@ tags:
 
 ## Intent
 
-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.
- */
 public interface Car {
-  
-  public String getDescription();
-  
+  String getDescription();
 }
 
-/**
- * Ford implementation.
- */
 public class Ford implements Car {
 
   static final String DESCRIPTION = "This is Ford.";
@@ -54,9 +50,6 @@ public class Ford implements Car {
   }
 }
 
-/**
- * Ferrari implementation.
- */
 public class Ferrari implements Car {
    
   static final String DESCRIPTION = "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
 public enum CarType {
   
-  /**
-   * 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.
- */
 public class CarsFactory {
   
-  /**
-   * Factory method takes as parameter a car type and initiate the appropriate class.
-   */
   public static Car getCar(CarType type) {
     return type.getConstructor().get();
   }
@@ -122,17 +107,21 @@ Program output:
 This is Ford.
 This Ferrari.
 ```
+
 ## 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
 [Factory Method](https://java-design-patterns.com/patterns/factory-method/)
 [Factory Kit](https://java-design-patterns.com/patterns/factory-kit/)
 [Abstract Factory](https://java-design-patterns.com/patterns/abstract-factory/)
-
-
diff --git a/factory/src/main/java/com/iluwatar/factory/Car.java b/factory/src/main/java/com/iluwatar/factory/Car.java
index 6f564233c..d1d622b9b 100644
--- a/factory/src/main/java/com/iluwatar/factory/Car.java
+++ b/factory/src/main/java/com/iluwatar/factory/Car.java
@@ -5,6 +5,6 @@ package com.iluwatar.factory;
  */
 public interface Car {
   
-  public String getDescription();
+  String getDescription();
   
 }