4. Patrones de comportamiento
Tratan la asignación de responsabilidades y los algoritmos entre objetos: comunicación, estados, notificaciones, recorridos, deshacer, variaciones de lógica sin herencia rígida, etc.
Chain of Responsibility (Refactoring.Guru ↗)
Pasa un mensaje por una cadena de manejadores hasta que uno lo procesa o se agota la cadena.
1 abstract class Manejador {
2 Manejador siguiente;
3 void setSig(Manejador s) { siguiente = s; }
4 abstract void manejar(int x);
5 }
1 from abc import ABC, abstractmethod
2
3 class Manejador(ABC):
4 def __init__(self) -> None:
5 self._sig = None
6 def set_sig(self, m: "Manejador") -> None:
7 self._sig = m
8 @abstractmethod
9 def manejar(self, x: int) -> None: ...
1 abstract class Manejador {
2 siguiente?: Manejador;
3 setSig(s: Manejador) { this.siguiente = s; }
4 abstract manejar(x: number): void;
5 }
Command (Refactoring.Guru ↗)
Encapsulas una solicitud como objeto para parametrizar, encolar, deshacer o registrar acciones.
1 interface Comando { void ejecutar(); }
2 class Boton {
3 Comando cmd;
4 void click() { cmd.ejecutar(); }
5 }
1 from abc import ABC, abstractmethod
2
3 class Comando(ABC):
4 @abstractmethod
5 def ejecutar(self) -> None: ...
6
7 class Boton:
8 def __init__(self, cmd: Comando) -> None:
9 self._cmd = cmd
10 def click(self) -> None:
11 self._cmd.ejecutar()
1 interface Comando { ejecutar(): void; }
2 class Boton {
3 constructor(private cmd: Comando) {}
4 click() { this.cmd.ejecutar(); }
5 }
Iterator (Refactoring.Guru ↗)
Recorres una colección sin exponer su representación interna.
1 interface Iterador<T> { boolean haySiguiente(); T siguiente(); }
2 class Coleccion {
3 Iterador<String> iterador() { /* ... */ return null; }
4 }
1 class Coleccion:
2 def __init__(self, items: list[str]) -> None:
3 self._items = items
4 def __iter__(self):
5 return iter(self._items)
1 class Coleccion<T> {
2 constructor(private items: T[]) {}
3 *[Symbol.iterator]() { for (const x of this.items) yield x; }
4 }
Mediator (Refactoring.Guru ↗)
Los componentes no se llaman entre sí directamente; coordinan a través de un mediador central.
1 interface Mediador {
2 void notificar(Object emisor, String evento);
3 }
1 from abc import ABC, abstractmethod
2
3 class Mediador(ABC):
4 @abstractmethod
5 def notificar(self, emisor: object, evento: str) -> None: ...
1 interface Mediador {
2 notificar(emisor: unknown, evento: string): void;
3 }
Memento (Refactoring.Guru ↗)
Guardas y restaura el estado interno de un objeto sin violar su encapsulamiento.
1 class Memento { final String estado; Memento(String e){ estado=e; } }
2 class Origen {
3 String estado;
4 Memento guardar() { return new Memento(estado); }
5 void restaurar(Memento m) { estado = m.estado; }
6 }
1 from dataclasses import dataclass
2
3 @dataclass
4 class Memento:
5 estado: str
6
7 class Origen:
8 def __init__(self) -> None:
9 self.estado = ""
10 def guardar(self) -> Memento:
11 return Memento(self.estado)
12 def restaurar(self, m: Memento) -> None:
13 self.estado = m.estado
1 class Memento {
2 constructor(readonly estado: string) {}
3 }
4 class Origen {
5 estado = '';
6 guardar() { return new Memento(this.estado); }
7 restaurar(m: Memento) { this.estado = m.estado; }
8 }
Observer (Refactoring.Guru ↗)
Varios suscriptores reaccionan automáticamente a cambios en un sujeto.
1 interface Observador { void actualizar(); }
2 class Sujeto {
3 List<Observador> obs = new ArrayList<>();
4 void notificar() { obs.forEach(Observador::actualizar); }
5 }
1 from typing import Protocol
2
3 class Observador(Protocol):
4 def actualizar(self) -> None: ...
5
6 class Sujeto:
7 def __init__(self) -> None:
8 self._obs: list[Observador] = []
9 def notificar(self) -> None:
10 for o in self._obs:
11 o.actualizar()
1 type Observador = { actualizar(): void };
2 class Sujeto {
3 private obs: Observador[] = [];
4 notificar() { this.obs.forEach((o) => o.actualizar()); }
5 }
State (Refactoring.Guru ↗)
El comportamiento cambia cuando el estado interno cambia, a menudo delegando en objetos de estado.
1 interface EstadoPuerta { void clic(Puerta p); }
2 class Puerta { EstadoPuerta estado; void clic() { estado.clic(this); } }
1 from abc import ABC, abstractmethod
2
3 class EstadoPuerta(ABC):
4 @abstractmethod
5 def clic(self, puerta: "Puerta") -> None: ...
6
7 class Puerta:
8 def __init__(self) -> None:
9 self.estado: EstadoPuerta | None = None
10 def clic(self) -> None:
11 assert self.estado
12 self.estado.clic(self)
1 interface EstadoPuerta { clic(p: Puerta): void; }
2 class Puerta {
3 estado!: EstadoPuerta;
4 clic() { this.estado.clic(this); }
5 }
Strategy (Refactoring.Guru ↗)
Familia de algoritmos intercambiables bajo una misma interfaz, elegidos en tiempo de ejecución.
1 interface Envio { int costo(int kg); }
2 class Carrito {
3 Envio estrategia;
4 int total(int kg) { return estrategia.costo(kg); }
5 }
1 from abc import ABC, abstractmethod
2
3 class Envio(ABC):
4 @abstractmethod
5 def costo(self, kg: int) -> int: ...
6
7 class Carrito:
8 def __init__(self, estrategia: Envio) -> None:
9 self._e = estrategia
10 def total(self, kg: int) -> int:
11 return self._e.costo(kg)
1 interface Envio { costo(kg: number): number; }
2 class Carrito {
3 constructor(private e: Envio) {}
4 total(kg: number) { return this.e.costo(kg); }
5 }
Template Method (Refactoring.Guru ↗)
Defines el esqueleto de un algoritmo en una clase base y delegas pasos variables a subclases.
1 abstract class Informe {
2 final void generar() {
3 encabezado();
4 cuerpo();
5 pie();
6 }
7 abstract void cuerpo();
8 void encabezado() {}
9 void pie() {}
10 }
1 from abc import ABC, abstractmethod
2
3 class Informe(ABC):
4 def generar(self) -> None:
5 self.encabezado()
6 self.cuerpo()
7 self.pie()
8 @abstractmethod
9 def cuerpo(self) -> None: ...
10 def encabezado(self) -> None: ...
11 def pie(self) -> None: ...
1 abstract class Informe {
2 generar() {
3 this.encabezado();
4 this.cuerpo();
5 this.pie();
6 }
7 abstract cuerpo(): void;
8 encabezado() {}
9 pie() {}
10 }
Visitor (Refactoring.Guru ↗)
Separas operaciones de la estructura de objetos; nuevas operaciones como nuevos “visitantes”.
1 interface Visitor { void visit(NodoA a); void visit(NodoB b); }
2 interface Nodo { void accept(Visitor v); }
1 from abc import ABC, abstractmethod
2
3 class Visitor(ABC):
4 @abstractmethod
5 def visit_a(self, a: "NodoA") -> None: ...
6 @abstractmethod
7 def visit_b(self, b: "NodoB") -> None: ...
1 interface Visitor {
2 visitA(a: NodoA): void;
3 visitB(b: NodoB): void;
4 }
5 interface Nodo {
6 accept(v: Visitor): void;
7 }
