Arquetipo
Patrones de comportamientoUso: AltaComplejidad: Baja

Template Method

Método plantilla

Define el esqueleto de un algoritmo en una clase base y deja que las subclases redefinan algunos pasos sin cambiar su estructura.

“Varios procesos siguen los mismos pasos y solo cambia uno o dos.”

workEl caso real

Tu sistema de recursos humanos calcula la nómina mensual de empleados en planilla, practicantes y trabajadores por horas. El proceso siempre es el mismo: calcular el ingreso bruto, aplicar los descuentos de ley, sumar bonificaciones, obtener el neto y emitir la boleta. Lo que cambia según el contrato es cómo se calcula el bruto y qué bonificaciones corresponden.

warningEl problema sin el patrón

Hay tres funciones casi idénticas de 80 líneas, una por tipo de contrato. Cuando cambia el porcentaje de un descuento de ley hay que corregirlo en las tres, y alguna siempre se queda atrás.

check_circleCómo lo resuelve el patrón

Una clase base define el método plantilla calcularNomina() con los pasos en un orden fijo. Los pasos comunes se implementan una sola vez; los que varían son métodos abstractos (el bruto) o ganchos con un valor por defecto (las bonificaciones) que cada subclase completa.

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
function nominaPlanilla(e: Empleado) { /* bruto + descuentos de ley + bonos + boleta */ }
function nominaPracticante(e: Empleado) { /* casi lo mismo, copiado */ }
function nominaPorHoras(e: Empleado) { /* casi lo mismo, copiado otra vez */ }
check_circleCon el patrónDESPUÉS
abstract class CalculoNomina {
  // Método plantilla: el orden de los pasos no cambia
  calcularNomina(e: Empleado): Boleta {
    const bruto = this.ingresoBruto(e);
    const neto = bruto - this.descuentosDeLey(bruto) + this.bonificaciones(e);
    return { empleadoId: e.id, bruto, neto };
  }

  protected abstract ingresoBruto(e: Empleado): number;          // paso obligatorio
  protected bonificaciones(_e: Empleado): number { return 0; }   // gancho opcional
  private descuentosDeLey(bruto: number) { return bruto * 0.13; } // común a todos
}

class NominaPorHoras extends CalculoNomina {
  protected ingresoBruto(e: Empleado) { return e.horas * e.tarifaHora; }
}

class NominaPlanilla extends CalculoNomina {
  protected ingresoBruto(e: Empleado) { return e.sueldoBase; }
  protected bonificaciones(e: Empleado) { return e.hijos > 0 ? 100 : 0; }
}

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

thumb_upCuándo usarlo

  • ✓Varios procesos siguen los mismos pasos y solo cambian algunos.
  • ✓Quieres fijar el orden de un proceso y permitir extender solo puntos concretos.

do_not_disturb_onCuándo no usarlo

  • ✕Los pasos varían tanto que la plantilla se llena de ganchos.
  • ✕Necesitas combinar variantes en tiempo de ejecución: la herencia es rígida y Strategy encaja mejor.
  • ✕Una subclase necesita "apagar" un paso que la base da por hecho: al anularlo puede romper lo que la base promete y violar el principio de sustitución de Liskov.
  • ✕La plantilla tiene muchos pasos: cuantos más hay, más difícil es entenderla y mantenerla.

memoryPrincipios en juego

  • •Principio de Hollywood ("no nos llames, nosotros te llamamos"): la clase base llama a las subclases.
  • •No te repitas: los pasos comunes se escriben una sola vez.

hubPatrones relacionados

  • •Strategy: cambia el algoritmo completo por composición; Template Method cambia partes por herencia.
  • •Factory Method: suele ser uno de los pasos de un método plantilla.
compare_arrowsSe suele confundir conTemplate Method vs Strategy →

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_blocksTemplate Method en tu lenguaje

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

LO IDIOMÁTICO EN TYPESCRIPT: abstract marca el paso obligatorio, los métodos protected con implementación por defecto son ganchos que las subclases pueden sobrescribir, y el paso común es privado (#), así que ninguna subclase puede alterarlo.

template-method.ts · 55 líneas
export interface Empleado {
  nombre: string;
  sueldoBase?: number;
  subvencion?: number;
  horas?: number;
  tarifaHora?: number;
  hijos?: number;
}

export interface Boleta {
  empleado: string;
  bruto: number;
  descuentos: number;
  bonificaciones: number;
  neto: number;
}

const redondear = (n: number) => Math.round(n * 100) / 100;

export abstract class CalculoNomina {
  // Método plantilla: el orden de los pasos es siempre el mismo
  calcularNomina(e: Empleado): Boleta {
    const bruto = this.ingresoBruto(e);
    const descuentos = this.#descuentosDeLey(bruto);
    const bonificaciones = this.bonificaciones(e);
    return { empleado: e.nombre, bruto, descuentos, bonificaciones, neto: redondear(bruto - descuentos + bonificaciones) };
  }

  protected abstract ingresoBruto(e: Empleado): number;        // paso obligatorio
  protected bonificaciones(_e: Empleado): number { return 0; }  // gancho
  protected aportaPension(): boolean { return true; }           // gancho

  #descuentosDeLey(bruto: number): number {                      // paso común
    return this.aportaPension() ? redondear(bruto * 0.13) : 0;
  }
}

export class NominaPlanilla extends CalculoNomina {
  protected ingresoBruto(e: Empleado) { return e.sueldoBase ?? 0; }
  protected bonificaciones(e: Empleado) { return (e.hijos ?? 0) > 0 ? 100 : 0; }
}

export class NominaPracticante extends CalculoNomina {
  protected ingresoBruto(e: Empleado) { return e.subvencion ?? 0; }
  protected aportaPension() { return false; }
}

export class NominaPorHoras extends CalculoNomina {
  protected ingresoBruto(e: Empleado) { return (e.horas ?? 0) * (e.tarifaHora ?? 0); }
}

// ── Uso ──
console.log(new NominaPlanilla().calcularNomina({ nombre: 'Ana', sueldoBase: 4000, hijos: 2 }));
console.log(new NominaPracticante().calcularNomina({ nombre: 'Leo', subvencion: 1200 }));
console.log(new NominaPorHoras().calcularNomina({ nombre: 'Rosa', horas: 80, tarifaHora: 25 }));
Ver los 23 patrones en TypeScript →