Factory Design Pattern in Java

By -

Type:  Creational Design Pattern

Summary


Factory or Factory method Design pattern is a creational design pattern. It helps in loose coupling between client and the actual object that the Client needs. Rather than Client calling the constructor using new operator it calls the Factory and the factory returns the respective object.

Details


Factory method design pattern encapsulate the complexities around creating an object and also uses Inheritance by letting factory method to decide which Subclass instance is needed to be returned.

Factory method pattern solves the issue of creating object without exposing internal details by
Provide an interface (Could be an Interface or Abstract Class) and a factory method
let the Client create the appropriate object by calling the factory method.

Example


Let's say we have a company ABC Cars Corp, which manufactures different type's of Cars (Sedan, SUV etc).  Now we want to provide a way to the Sales man to be able to get a Car (object instance) based on Customer preference, and can demo those cars to Customers.
One option is to provide constructor for those Cars. So that Client can call the constructors and create cars.

That exposes a lot of technical details to the Sales Man. Better would be have a factory/or room which has all available cars. Then the Sales Man can could quickly turn around with available Car to the Customer. That way the learning curve for the Sales Man is very minimum.

Now say down the lane, ABC Cars Corp also starting manufacturing Sports Car. Now the problem is, all the Sales Team needs to know what parameters needed to be sent to create a sample Sports cars. 

Factory method does that by utilizing inheritance and based on the requirement it creates a specific instance of one of the SubClass.

GasolineCarFactory is the Factory that implements a factory method.
Car is extended by two Subclasses SUVCar and CompactSedan Car

Class Diagram



Sample Code 



// subclass of Car
public class CompactSedanCar extends Car {

  @Override
  public String getModel() {
    return "Compact4person";
  }

  @Override
  public String getPrice() {
    return "20k";
  }

  @Override
  public String getType() {
    return "COMPACT";
  }
}

// subclass of Car
public class SUVCar extends Car {

  @Override
  public String getModel() {
    return "SUV2019";
  }

  @Override
  public String getPrice() {
    return "40k";
  }

  @Override
  public String getType() {
    return "SUV";
  }
}

// factory method Class which the Client interact with
public class GasolineCarFactory {

  public Car getCarType(int i) {
    switch (i) {
      case 1:
        return new CompactSedanCar();
      case 2:
        return new SUVCar();
      default:
        return new CompactSedanCar();
    }

  }

}

Github Code 

Advantages


Centralized interface to create object.
Easy of refactoring and code reuse.
Easy discovery for developers.
Better testable codes.
Internally the factory method can utilize Prototype design pattern or Flyweight design pattern as per the situation.

Disadvantages


Factory method design pattern adds a layer of attraction between Client and real Object.
when a new SubClass is introduced the factory method needs to update to take that into consideration.

When to Use


When we want to provide a centralized or common interface to create multiple objects (subclasses)
When we want to hide the complexities of creating instances of those object.
When we want to control how an object instance should be created.
If we have complex business logic while creating objects, this design pattern is very useful

Comments

Post a Comment

Popular posts from this blog

Difference between volatile and synchronized

By -
volatile is a field modifier, while synchronized modifies code blocks and methods. So we can specify three variations of a simple accessor using those two keywords: int i1; int geti1() {return i1;} volatile int i2; int geti2() {return i2;} int i3; synchronized int geti3() {return i3;} geti1() accesses the value currently stored in i1 in the current thread . Threads can have local copies of variables, and the data does not have to be the same as the data held in other threads. In particular, another thread may have updated i1 in it's thread, but the value in the current thread could be different from that updated value. In fact Java has the idea of a "main" memory, and this is the memory that holds the current "correct" value for variables. Threads can have their own copy of data for variables, and the thread copy can be different from the "main" memory. So in fact, it is possible for the "main"
Read more

Converting Java Map to String

By -
Java Collections framework, String manipulation etc is something that we often encounter in Development process. For processing collections (like checking null/empty, Intersection, Disjunction) We do have some of the very use full libraries. Some of the Collection related libraries are Apche Commons Collections and Google  Collections(Guava). Problem Use Case This article explains how to convert a Java Map to String(and vice versa) using different libraries and technique. One way is to use StringBuilder(Or String) and loop though the Map and build the String by applying some sort of separator ( for key:value and entry). Here we have to take care of the null value etc. Without Any Library If we want to convert the map to a String with key value separator and also individual entry seperator in the resulting String, we have to write code for that. For a simple Map, we have to iterate though the map, take care of the null values etc. Following is a sample to get String built
Read more

Masking Credit Card number in Java

By -
Sometimes we need to mask crucial information like Credit Card Numbers, CVV numbers etc before storing  or logging the information. This example mask Credit Card Number (Except last 4 Digit) from a Text which contains information along with Credit Card Number. The following example demonstrates how we can easily mask the credit card with Matcher and Pattern Classes. This Sample Code uses Matcher and Pattern. Pattern Used in this sample is not optimized for Credit Card Numbers, this pattern will get any numerical numbers in the String Content.  Based on the Credit Card Type a more efficient and Strict RegEx can be used to mask the Credit Card. /**Mask the Credit card number but last four digit value **/   Pattern PATTERN = Pattern.compile( "[0-9]+" ); String message = content; Matcher matcher = PATTERN.matcher(message); String maskingChar = "*"; StringBuilder finalMask = new StringBuilder(maskingChar);
Read more