What are the advantages and disadvantages of implementing a Factory pattern in PHP using an abstract class versus a parameterized Factory?

When implementing a Factory pattern in PHP, using an abstract class allows for better organization and structure by defining common methods and properties that all concrete factories must implement. On the other hand, using a parameterized Factory allows for more flexibility and customization by passing parameters to the factory method to determine which object to create. 

// Abstract Factory pattern implementation using an abstract class

abstract class AbstractFactory {
    public abstract function createProduct();
}

class ConcreteFactoryA extends AbstractFactory {
    public function createProduct() {
        return new ProductA();
    }
}

class ConcreteFactoryB extends AbstractFactory {
    public function createProduct() {
        return new ProductB();
    }
}

// Parameterized Factory pattern implementation

class ParameterizedFactory {
    public function createProduct($type) {
        switch ($type) {
            case 'A':
                return new ProductA();
            case 'B':
                return new ProductB();
            default:
                throw new Exception('Invalid product type');
        }
    }
}

class ProductA {
    public function __construct() {
        echo "Product A created\n";
    }
}

class ProductB {
    public function __construct() {
        echo "Product B created\n";
    }
}

// Using the abstract factory
$factoryA = new ConcreteFactoryA();
$productA = $factoryA->createProduct();

$factoryB = new ConcreteFactoryB();
$productB = $factoryB->createProduct();

// Using the parameterized factory
$parameterizedFactory = new ParameterizedFactory();
$productA = $parameterizedFactory->createProduct('A');
$productB = $parameterizedFactory->createProduct('B');

Keywords

Factory pattern PHP abstract class parameterized Factory advantages

Related Questions