The One-Sentence Distinction

• Factory Method is used to create one specific product (e.g., "I need a Transport").
• Abstract Factory is used to create a family of related products (e.g., "I need a Chair, Sofa, and CoffeeTable that all match the 'Victorian' style").

1. Factory Method (The "Polymorphic Constructor")

The Concept: You define an interface for creating an object, but let subclasses decide which class to instantiate.

• Focus: Inheritance.
• Mechanism: You put an abstract create() method in the parent class. The child class overrides it.

The Example (Logistics): You are building a logistics app.

• Parent: LogisticsApp has a method planDelivery(). It needs a transport.
• Problem: You don't know if it's a generic truck or a ship.
• Solution:
  • RoadLogistics subclass overrides createTransport() → returns Truck.
  • SeaLogistics subclass overrides createTransport() → returns Ship.

Java Code:

abstract class Logistics {
    // FACTORY METHOD: The parent doesn't know what comes out.
    abstract Transport createTransport(); 

    public void planDelivery() {
        Transport t = createTransport(); // Call the factory method
        t.deliver();
    }
}

class RoadLogistics extends Logistics {
    @Override
    Transport createTransport() { return new Truck(); } // Decision made here
}

2. Abstract Factory (The "Theme" Provider)

The Concept: You provide an interface for creating families of related or dependent objects without specifying their concrete classes.

• Focus: Composition/Delegation.
• Mechanism: You create a separate "Factory Object" (a helper) that has multiple methods (createA, createB, createC). You pass this object around.

The Example (Furniture Shop): You are selling furniture. A customer selects "Victorian Style".