Arquetipo
Patrones creacionalesUso: Muy altaComplejidad: Baja

Factory Method

Método fábrica · Constructor virtual

Define un método para crear un objeto, pero deja que las subclases decidan qué clase concreta instanciar.

“Tengo un switch que decide qué clase crear y crece con cada tipo nuevo.”

workEl caso real

Tu fintech concilia los movimientos bancarios de sus clientes con sus ventas. Cada banco entrega el extracto en su propio formato: uno envía un CSV separado por punto y coma, otro un TXT de ancho fijo y otro expone una API JSON. El proceso de conciliación (leer los movimientos, cruzarlos con las ventas y marcar diferencias) es siempre el mismo; lo único que cambia es cómo se lee el extracto.

warningEl problema sin el patrón

El servicio de conciliación tiene un switch(banco) que crea el lector correcto, y ese mismo switch aparece en el proceso nocturno, en la carga manual de archivos y en las pruebas. Sumar un banco obliga a modificar todos esos lugares y es fácil olvidar uno.

check_circleCómo lo resuelve el patrón

La clase base Conciliador define el proceso y delega la creación del lector en un método fábrica abstracto, crearLector(). Cada subclase (ConciliadorBancoAndino, ConciliadorBancoPacifico) decide qué lector concreto crear. Sumar un banco es sumar una subclase, sin tocar el proceso.

schemaDiagrama de clases

Diagrama interactivo: puedes acercar, mover el lienzo y pasar el cursor sobre cada clase para ver su detalle.

codeEl código, antes y después

cancelSin el patrónANTES
class ServicioConciliacion {
  conciliar(banco: string, archivo: string) {
    let lector: LectorExtracto;
    switch (banco) {
      case 'andino':   lector = new LectorCsvAndino(); break;
      case 'pacifico': lector = new LectorTxtPacifico(); break;
      default: throw new Error('Banco no soportado: ' + banco);
    }
    const movimientos = lector.leer(archivo);
    // ...cruzar con ventas y reportar diferencias
  }
}
check_circleCon el patrónDESPUÉS
abstract class Conciliador {
  // Método fábrica: cada subclase decide qué lector crear
  protected abstract crearLector(): LectorExtracto;

  conciliar(archivo: string): Diferencia[] {
    const movimientos = this.crearLector().leer(archivo);
    return cruzarConVentas(movimientos);
  }
}

class ConciliadorBancoAndino extends Conciliador {
  protected crearLector() { return new LectorCsvAndino(); }
}

class ConciliadorBancoPacifico extends Conciliador {
  protected crearLector() { return new LectorTxtPacifico(); }
}

Ejemplos en TypeScript, simplificados para mostrar la idea: los tipos auxiliares (Pedido, Cliente…) se omiten.

lightbulb

Matiz importante

En el código actual es muy común reemplazar la herencia por inyección: se pasa al constructor una fábrica o una función que crea el lector. La idea es la misma: el proceso no decide qué clase concreta se instancia. Además, el método fábrica no está obligado a crear siempre un objeto nuevo: puede devolver uno que ya existe (de una caché o de un pool) y quien lo llama no nota la diferencia.

thumb_upCuándo usarlo

  • ✓Una clase tiene un proceso estable, pero el objeto concreto con el que trabaja varía según el caso.
  • ✓Quieres que quien extienda tu código (subclases, plugins) decida qué objeto se crea.
  • ✓Quieres reutilizar objetos costosos (lectores ya configurados, conexiones) en lugar de crearlos cada vez: el método fábrica puede devolver uno existente.

do_not_disturb_onCuándo no usarlo

  • ✕Solo hay un tipo concreto y no se prevé otro: un new directo es más claro.
  • ✕Si la variación no justifica una jerarquía de clases, basta con inyectar el objeto o una función que lo cree.
  • ✕Cada producto nuevo exige también un creador nuevo: con muchos productos, la jerarquía crece más de lo que aporta.

memoryPrincipios en juego

  • •Abierto/Cerrado: un banco nuevo es una subclase nueva, no un case más.
  • •Inversión de dependencias: el proceso depende de la interfaz LectorExtracto, no de los lectores concretos.

hubPatrones relacionados

  • •Abstract Factory: suele implementarse con varios métodos fábrica, uno por producto.
  • •Template Method: el método fábrica suele ser uno de los pasos que la subclase completa.
  • •Prototype: alternativa que crea objetos clonando en vez de usar subclases.
compare_arrowsSe suele confundir conFactory Method vs Abstract Factory →

quizPon a prueba lo que leíste

Dos preguntas al azar sobre este patrón. Cada vez que las cambias salen otras.

Más ejercicios →

code_blocksFactory Method en tu lenguaje

El mismo caso, implementado completo y de forma idiomática. Se puede copiar y ejecutar.

LO IDIOMÁTICO EN TYPESCRIPT: La clase abstracta declara el método fábrica como protected abstract: el compilador obliga a cada subclase a implementarlo. Gracias al tipado estructural, un lector solo necesita cumplir la forma de LectorExtracto.

factory-method.ts · 64 líneas
export interface Movimiento {
  fecha: string;
  referencia: string;
  monto: number;
}

export interface LectorExtracto {
  leer(contenido: string): Movimiento[];
}

class LectorCsvAndino implements LectorExtracto {
  leer(contenido: string): Movimiento[] {
    return contenido.trim().split('\n').map((linea) => {
      const [fecha, referencia, monto] = linea.split(';');
      return { fecha, referencia, monto: Number(monto) };
    });
  }
}

class LectorTxtPacifico implements LectorExtracto {
  // Ancho fijo: fecha (10) + referencia (8) + monto (resto)
  leer(contenido: string): Movimiento[] {
    return contenido.trim().split('\n').map((linea) => ({
      fecha: linea.slice(0, 10),
      referencia: linea.slice(10, 18).trim(),
      monto: Number(linea.slice(18)),
    }));
  }
}

export abstract class Conciliador {
  // Método fábrica: cada subclase decide qué lector crear
  protected abstract crearLector(): LectorExtracto;

  conciliar(contenido: string, ventas: Map<string, number>): string[] {
    const diferencias: string[] = [];
    for (const mov of this.crearLector().leer(contenido)) {
      const esperado = ventas.get(mov.referencia);
      if (esperado !== mov.monto) {
        diferencias.push(`${mov.referencia}: banco ${mov.monto}, ventas ${esperado ?? 'sin registro'}`);
      }
    }
    return diferencias;
  }
}

export class ConciliadorBancoAndino extends Conciliador {
  protected crearLector() { return new LectorCsvAndino(); }
}

export class ConciliadorBancoPacifico extends Conciliador {
  protected crearLector() { return new LectorTxtPacifico(); }
}

// ── Uso ──
const ventas = new Map([['F-001', 150], ['F-002', 80]]);

const csvAndino = '2026-11-01;F-001;150\n2026-11-01;F-002;75';
console.log(new ConciliadorBancoAndino().conciliar(csvAndino, ventas));
// [ 'F-002: banco 75, ventas 80' ]

const txtPacifico = '2026-11-01F-001   150\n2026-11-02F-003   40';
console.log(new ConciliadorBancoPacifico().conciliar(txtPacifico, ventas));
// [ 'F-003: banco 40, ventas sin registro' ]
Ver los 23 patrones en TypeScript →