3. Patrones estructurales
Explican cómo componer clases y objetos para obtener estructuras más grandes: adaptar interfaces, añadir comportamiento por capas, unificar árboles, simplificar fachadas o compartir estado intrínseco.
Adapter (Refactoring.Guru ↗)
Envuelves una interfaz existente para que otra parte del sistema pueda usarla sin modificar el código original.
1 // Cliente espera EnchufeEU
2 class Adaptador implements EnchufeEU {
3 private EnchufeUS us;
4 void enchufar() { us.plug(); }
5 }
1 class EnchufeEU:
2 def conectar(self) -> None: ...
3
4 class Adaptador(EnchufeEU):
5 def __init__(self, us: object) -> None:
6 self._us = us
7 def conectar(self) -> None:
8 self._us.plug() # type: ignore
1 class Adaptador implements EUPlug {
2 constructor(private us: USPlug) {}
3 connect() { this.us.plugIn(); }
4 }
Bridge (Refactoring.Guru ↗)
Separas una jerarquía de abstracción de la de implementación para que evolucionen de forma independiente.
1 abstract class Vista {
2 protected ApiRender api;
3 Vista(ApiRender api) { this.api = api; }
4 abstract void dibujar();
5 }
1 from abc import ABC, abstractmethod
2
3 class ApiRender(ABC):
4 @abstractmethod
5 def pixel(self, x: int, y: int) -> None: ...
6
7 class Vista(ABC):
8 def __init__(self, api: ApiRender) -> None:
9 self._api = api
1 interface ApiRender { pixel(x: number, y: number): void; }
2 abstract class Vista {
3 constructor(protected api: ApiRender) {}
4 abstract dibujar(): void;
5 }
Composite (Refactoring.Guru ↗)
Tratas objetos simples y compuestos (árboles) de forma uniforme mediante una interfaz común.
1 interface Nodo { int tamano(); }
2 class Hoja implements Nodo { int tamano() { return 1; } }
3 class Carpeta implements Nodo {
4 List<Nodo> hijos;
5 int tamano() { return hijos.stream().mapToInt(Nodo::tamano).sum(); }
6 }
1 from abc import ABC, abstractmethod
2
3 class Nodo(ABC):
4 @abstractmethod
5 def tamano(self) -> int: ...
6
7 class Carpeta(Nodo):
8 def __init__(self, hijos: list[Nodo]) -> None:
9 self.hijos = hijos
10 def tamano(self) -> int:
11 return sum(h.tamano() for h in self.hijos)
1 interface Nodo { tamano(): number; }
2 class Carpeta implements Nodo {
3 constructor(private hijos: Nodo[]) {}
4 tamano() { return this.hijos.reduce((a, h) => a + h.tamano(), 0); }
5 }
Decorator (Refactoring.Guru ↗)
Añades responsabilidades dinámicamente envolviendo objetos en “capas” compatibles con la misma interfaz.
1 interface Cafe { double costo(); }
2 class Leche implements Cafe {
3 Cafe interior;
4 double costo() { return interior.costo() + 0.5; }
5 }
1 from abc import ABC, abstractmethod
2
3 class Cafe(ABC):
4 @abstractmethod
5 def costo(self) -> float: ...
6
7 class Leche(Cafe):
8 def __init__(self, interior: Cafe) -> None:
9 self._i = interior
10 def costo(self) -> float:
11 return self._i.costo() + 0.5
1 interface Cafe { costo(): number; }
2 class Leche implements Cafe {
3 constructor(private i: Cafe) {}
4 costo() { return this.i.costo() + 0.5; }
5 }
Facade (Refactoring.Guru ↗)
Ofreces un punto de entrada simple a un subsistema complejo reduciendo el acoplamiento del cliente.
1 class FacadeVideo {
2 void reproducir(String f) {
3 new Decoder().decode(f);
4 new Audio().play();
5 }
6 }
1 class FachadaVideo:
2 def reproducir(self, archivo: str) -> None:
3 self._decodificar(archivo)
4 self._audio()
5
6 def _decodificar(self, a: str) -> None: ...
7 def _audio(self) -> None: ...
1 class FacadeVideo {
2 reproducir(f: string) {
3 new Decoder().decode(f);
4 new AudioOut().play();
5 }
6 }
Flyweight (Refactoring.Guru ↗)
Compartes estado intrínseco entre muchas instancias para ahorrar memoria en objetos muy repetidos.
1 // Estado intrínseco compartido (color de tile)
2 class TileFlyweight { String color; }
3
4 class TileFactory {
5 Map<String, TileFlyweight> pool = new HashMap<>();
6 }
1 from dataclasses import dataclass
2
3 @dataclass(frozen=True)
4 class TileFlyweight:
5 color: str
6
7 _pool: dict[str, TileFlyweight] = {}
8
9 def tile(color: str) -> TileFlyweight:
10 return _pool.setdefault(color, TileFlyweight(color))
1 class TileFlyweight {
2 constructor(readonly color: string) {}
3 }
4 const pool = new Map<string, TileFlyweight>();
5 function tile(c: string) {
6 if (!pool.has(c)) pool.set(c, new TileFlyweight(c));
7 return pool.get(c)!;
8 }
Proxy (Refactoring.Guru ↗)
Sustituto que controla el acceso al objeto real (lazy load, permisos, logging, remoto, etc.).
1 interface Imagen { void mostrar(); }
2 class ProxyImagen implements Imagen {
3 RealImagen real;
4 void mostrar() {
5 if (real == null) real = new RealImagen();
6 real.mostrar();
7 }
8 }
1 from abc import ABC, abstractmethod
2
3 class Imagen(ABC):
4 @abstractmethod
5 def mostrar(self) -> None: ...
6
7 class ProxyImagen(Imagen):
8 def __init__(self) -> None:
9 self._real = None
10 def mostrar(self) -> None:
11 if self._real is None:
12 self._real = RealImagen()
13 self._real.mostrar()
1 interface Imagen { mostrar(): void; }
2 class ProxyImagen implements Imagen {
3 private real?: RealImagen;
4 mostrar() {
5 this.real ??= new RealImagen();
6 this.real.mostrar();
7 }
8 }
