What is the Factory design pattern, and when should you use it?

The Factory design pattern is a creational pattern that provides an interface for creating objects but allows subclasses to alter the type of objects that will be created. It promotes loose coupling by centralizing object creation.

• Key points:
  • Object Creation: The pattern defines a method for creating objects, but the actual instantiation of the objects is deferred to subclasses.
  • Decoupling: It decouples the client from the concrete classes it needs to instantiate.
  • Flexible: It allows for the creation of different types of objects based on certain conditions.
• When to use:
  • When the exact type of the object to be created is determined at runtime.
  • When the creation process is complex, and you want to delegate object creation to a factory method.
  • When you want to provide a single interface for creating objects from a family of related classes.

• Example:

  public interface Animal {
      void speak();
  }
  
  public class Dog implements Animal {
      @Override
      public void speak() {
          System.out.println("Woof");
      }
  }
  
  public class Cat implements Animal {
      @Override
      public void speak() {
          System.out.println("Meow");
      }
  }
  
  public class AnimalFactory {
      public static Animal getAnimal(String type) {
          if (type.equals("Dog")) {
              return new Dog();
          } else if (type.equals("Cat")) {
              return new Cat();
          }
          return null;
      }
  }
  

• Usage:

  Animal dog = AnimalFactory.getAnimal("Dog");
  dog.speak(); // Output: Woof
  

In summary, the Factory pattern is useful when you need to create objects based on dynamic conditions or when the creation process should be abstracted away, making the system more modular and easier to maintain.