Qué es el patrón de diseño Factory Method y cómo se aplica

Vista previa del material en texto

¿Qué es el patrón de diseño Factory Method y cómo se aplica en PHP? 
 
El patrón de diseño "Factory Method" (Método de Fábrica) es un patrón de diseño creacional que 
proporciona una interfaz para crear objetos en una clase base, pero permite a las subclases decidir 
qué clase concreta instanciar. El Factory Method es útil cuando una clase no puede anticipar el tipo 
exacto de objetos que debe crear y desea delegar esta responsabilidad a sus subclases. 
 
El patrón Factory Method se compone de dos partes principales: 
 
1. Producto (Product): Es la interfaz común que define el comportamiento de los objetos que serán 
creados por el Factory Method. 
 
2. Creador (Creator): Es la clase base abstracta que contiene el Factory Method. El Factory Method 
es un método abstracto que define cómo se crea el objeto de Producto. Las subclases del Creador 
implementarán el Factory Method para decidir el tipo concreto de Producto a crear. 
 
En PHP, el patrón Factory Method se puede implementar de la siguiente manera: 
 
```php 
// Producto (Product) 
interface Product 
{ 
 public function operation(): string; 
} 
 
// Producto concreto (Concrete Product) 
class ConcreteProductA implements Product 
{ 
 public function operation(): string 
 { 
 return "Operation of ConcreteProductA"; 
 } 
} 
 
// Producto concreto (Concrete Product) 
class ConcreteProductB implements Product 
{ 
 public function operation(): string 
 { 
 return "Operation of ConcreteProductB"; 
 } 
} 
 
// Creador (Creator) 
abstract class Creator 
{ 
 abstract public function factoryMethod(): Product; 
 
 public function someOperation(): string 
 { 
 $product = $this->factoryMethod(); 
 return "Creator: " . $product->operation(); 
 } 
} 
 
// Creador concreto (Concrete Creator) 
class ConcreteCreatorA extends Creator 
{ 
 public function factoryMethod(): Product 
 { 
 return new ConcreteProductA(); 
 } 
} 
 
// Creador concreto (Concrete Creator) 
class ConcreteCreatorB extends Creator 
{ 
 public function factoryMethod(): Product 
 { 
 return new ConcreteProductB(); 
 } 
} 
``` 
 
En este ejemplo, `Product` es la interfaz común para los productos que se pueden crear. 
`ConcreteProductA` y `ConcreteProductB` son dos implementaciones concretas de `Product`. 
`Creator` es la clase base abstracta que contiene el Factory Method `factoryMethod()`, y 
`ConcreteCreatorA` y `ConcreteCreatorB` son dos implementaciones concretas de `Creator` que 
definen qué tipo de producto concreto crear. 
 
Usando este patrón, puedes crear una instancia de `ConcreteCreatorA` o `ConcreteCreatorB` y 
llamar a `someOperation()` sin preocuparte por el tipo exacto de `Product` que será creado. El 
Factory Method en la subclase del `Creator` se encargará de decidir qué producto específico se 
creará. De esta manera, el código se vuelve más flexible y fácil de mantener, ya que los detalles de la 
creación de objetos se encuentran en las subclases en lugar de estar dispersos en el código cliente.