Use of Factory Pattern and its implementation in development

Use of Factory Pattern and its implementation:

It is the most widely used pattern among all design patterns. Its falls under "Creational" design pattern category and encapsulates the object creation and instantiation logic from the client or framework who want to use it.

In simple words whenever you need an object of particular product you need not to create it via using new operator you just need to call factory to create it for yourself and you use is it via common interface or base abstract class reference.

For Example suppose you are working on paint application where you need to provide an option for drawing various shapes like line, circle etc. Each shape will have its draw method where all the drawing logic will be performed. We can create a factory for the same which will encapsulates the object creation and instantiation logic and will return the object for requested shape.

For more understanding lets have a scenario states below:


There is a base abstract shape class.

public abstract class Shape
{
 public abstract void draw ();
}

and various subclasses like line, circle etc..

class Line extends Shape
{
 public void draw () 
 {
  // draw line 
 }
}

class Circle extends Shape
{
 public void draw ()
 {
  // draw line 
 }

}

Now if you want to create object of line and circle at client or in your paint application you will write code like :

Open-Closed Principle and its use in software development

Definition of Open-Closed Principle:

It states that software entities like classes, modules and functions should be open for extension but closed for modifications. It means if you want to add new functionality in your software application than it should not impact your previous functionality because it has already been tested and integrated.

We can take an example which violates the principle:

 public abstract class Animal{}
 
 public class Dog extends Animal{}
 
 public class Horse extends Animal{}
 
 public class AnimalSpeaker
 {
  public void speak(String type)
  {
   if(type equals Dog)
    speakDog();
   
   if(type equals Horse)
    speakHorse();
  }
 
  public void speakDog(){}
 
  public void speakHorse(){}
 
 }

Now suppose I want to add new base class called Cat then I need to create a new subclass Cat and will have to make change in AnimalSpeaker means violating the open-close principle.