Patrones de diseño de software

Los patrones de diseño se clasifican en tres categorías principales: patrones creacionales, patrones estructurales y patrones de comportamiento. Cada categoría aborda un aspecto específico de la construcción de software. Aquí hay una descripción general de algunos patrones comunes en cada categoría:

1. Patrones Creacionales

Estos patrones se centran en la forma en que se crean los objetos, ayudando a abstraer el proceso de instanciación.

Factory Method: Define una interfaz para crear un objeto, pero permite a las subclases alterar el tipo de objeto que se va a crear.
Abstract Factory: Proporciona una interfaz para crear familias de objetos relacionados o dependientes sin especificar sus clases concretas.
Singleton: Garantiza que una clase tenga solo una instancia y proporciona un punto de acceso global a esa instancia.
Builder: Separa la construcción de un objeto complejo de su representación, permitiendo crear diferentes representaciones.
Prototype: Permite crear nuevos objetos clonando una instancia existente.

2. Patrones Estructurales

Estos patrones se centran en cómo se componen las clases y los objetos para formar estructuras más grandes.

Adapter: Permite que las clases con interfaces incompatibles trabajen juntas convirtiendo la interfaz de una clase en otra interfaz esperada.
Bridge: Desacopla una abstracción de su implementación, permitiendo que ambas varíen independientemente.
Composite: Compone objetos en estructuras de árbol para representar jerarquías de parte-todo. Permite a los clientes tratar objetos individuales y composiciones de objetos de manera uniforme.
Decorator: Permite agregar responsabilidades adicionales a un objeto de manera dinámica.
Facade: Proporciona una interfaz simplificada a un conjunto más complejo de interfaces en un subsistema.
Flyweight: Utiliza el uso compartido para soportar eficientemente grandes cantidades de objetos de grano fino.
Proxy: Proporciona un sustituto o marcador de posición para otro objeto para controlar el acceso a él.

3. Patrones de Comportamiento

Estos patrones se centran en cómo los objetos interactúan y se comunican entre sí.

Chain of Responsibility: Permite pasar una solicitud a lo largo de una cadena de manejadores, donde cada manejador decide procesar la solicitud o pasarla al siguiente manejador en la cadena.
Command: Encapsula una solicitud como un objeto, permitiendo parametrizar a los clientes con diferentes solicitudes, encolar o registrar solicitudes y soportar operaciones que se pueden deshacer.
Interpreter: Proporciona una forma de evaluar o interpretar un lenguaje particular.
Iterator: Proporciona una forma de acceder secuencialmente a los elementos de una colección sin exponer su representación subyacente.
Mediator: Define un objeto que encapsula cómo interactúan un conjunto de objetos, promoviendo el acoplamiento débil al evitar que los objetos se refieran entre sí explícitamente.
Memento: Permite capturar y restaurar el estado interno de un objeto sin violar la encapsulación.
Observer: Define una dependencia de uno a muchos entre objetos, de manera que cuando un objeto cambia de estado, todos sus dependientes son notificados y actualizados automáticamente.
State: Permite que un objeto altere su comportamiento cuando su estado interno cambia, pareciendo que cambia su clase.
Strategy: Define una familia de algoritmos, encapsula cada uno de ellos y los hace intercambiables.
Template Method: Define el esqueleto de un algoritmo en una operación, delegando algunos pasos a subclases.
Visitor: Representa una operación que se realiza en los elementos de una estructura de objetos, permitiendo definir una nueva operación sin cambiar las clases de los elementos sobre los que opera.

Ejemplos de Patrones de Diseño

Factory Method

<?php
interface Product {
    public function operation();
}

class ConcreteProductA implements Product {
    public function operation() {
        return "Result of ConcreteProductA";
    }
}

class ConcreteProductB implements Product {
    public function operation() {
        return "Result of ConcreteProductB";
    }
}

abstract class Creator {
    abstract public function factoryMethod(): Product;

    public function someOperation() {
        $product = $this->factoryMethod();
        return $product->operation();
    }
}

class ConcreteCreatorA extends Creator {
    public function factoryMethod(): Product {
        return new ConcreteProductA();
    }
}

class ConcreteCreatorB extends Creator {
    public function factoryMethod(): Product {
        return new ConcreteProductB();
    }
}

// Uso
$creatorA = new ConcreteCreatorA();
echo $creatorA->someOperation(); // Output: Result of ConcreteProductA

$creatorB = new ConcreteCreatorB();
echo $creatorB->someOperation(); // Output: Result of ConcreteProductB
?>

Observer

<?php
interface Observer {
    public function update($subject);
}

interface Subject {
    public function attach(Observer $observer);
    public function detach(Observer $observer);
    public function notify();
}

class ConcreteSubject implements Subject {
    private $observers = [];
    private $state;

    public function attach(Observer $observer) {
        $this->observers[] = $observer;
    }

    public function detach(Observer $observer) {
        $this->observers = array_filter($this->observers, function($obs) use ($observer) {
            return $obs !== $observer;
        });
    }

    public function notify() {
        foreach ($this->observers as $observer) {
            $observer->update($this);
        }
    }

    public function getState() {
        return $this->state;
    }

    public function setState($state) {
        $this->state = $state;
        $this->notify();
    }
}

class ConcreteObserver implements Observer {
    public function update($subject) {
        echo "Observer: Reacted to the event. New state is " . $subject->getState() . "\n";
    }
}

// Uso
$subject = new ConcreteSubject();

$observer1 = new ConcreteObserver();
$observer2 = new ConcreteObserver();

$subject->attach($observer1);
$subject->attach($observer2);

$subject->setState(5); // Output: Observer: Reacted to the event. New state is 5
                       //         Observer: Reacted to the event. New state is 5
?>

Estos son solo algunos ejemplos de patrones de diseño. Cada patrón tiene su propio propósito y es útil en diferentes situaciones de diseño de software. Conocer y entender estos patrones puede ayudarte a escribir código más flexible, reutilizable y mantenible.