Introduction to Factory Design Pattern

The Factory Design Pattern is a creational design pattern that provides a centralized way to create objects without exposing the instantiation logic to the client. It is particularly useful when dealing with multiple types of objects that share a common interface or superclass, ensuring flexibility, scalability, and maintainability in object creation.

• Purpose: To encapsulate object creation logic, making the system easier to extend and maintain.
• Relevance: Commonly used in software development for creating objects in a uniform, centralized manner, especially in scenarios like database connections, UI components, or logging systems. It is a key pattern for coding interviews at top tech companies (e.g., FAANG/MAANG).

Challenges of Manual Object Creation

Manually creating objects (e.g., using new in Java) leads to several issues, particularly when the system grows or requirements change.

• Hard-Coded Instantiation:
  • Directly instantiating objects (e.g., new Car()) in multiple places leads to code duplication.
  • Example: If a system needs to create vehicles like Car, Truck, or Bike, each instantiation requires specific logic, which is error-prone and hard to maintain.
• Repetition Across Codebase:
  • If object creation logic is scattered across the codebase, any change (e.g., adding a new parameter like an engine) requires updates in multiple locations.
  • Example: A company decides all Car objects must include a custom engine. Without a centralized mechanism, every instantiation site must be updated manually.
• Inflexibility:
  • Hard-coded logic makes it difficult to adapt to new requirements, such as adding a new vehicle type or changing instantiation parameters.
• Maintenance Nightmare:
  • Changes to object creation logic (e.g., adding a new vehicle type) require modifying code everywhere, increasing the risk of errors.

Example Scenario: Imagine a system where users create vehicles manually:

// Without Factory Pattern
Vehicle car = new Car(); // User 1
Vehicle truck = new Truck(); // User 2
Vehicle bike = new Bike("sports"); // User 3 with different parameters

If the Car class now requires a custom engine, every instantiation like new Car() must be updated to new Car(new CustomEngine()), leading to widespread code changes.

Problems with Conditional Logic

A common attempt to address manual instantiation is using conditional logic (e.g., if-else statements) to decide which object to create based on input. However, this approach has limitations:

• Scattered Logic: Conditional logic still requires each user to implement creation logic, leading to duplication.
• Maintenance Issues: Adding a new vehicle type requires updating if-else blocks across the codebase.
• Lack of Centralization: Conditional logic does not provide a single point of control, making it hard to enforce uniform creation.

Example of Conditional Logic:

Vehicle createVehicle(String type) {
    if (type.equals("car")) {
        return new Car();
    } else if (type.equals("truck")) {
        return new Truck();
    } else if (type.equals("bike")) {
        return new Bike();
    }
    return null;
}