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
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 */ }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.
quizPon a prueba lo que leíste
Dos preguntas al azar sobre este patrón. Cada vez que las cambias salen otras.
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.
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 }));LO IDIOMÁTICO EN C# / .NET: En C# los métodos no son virtual por defecto: el método plantilla es un método normal y las subclases no pueden sobrescribirlo. Los pasos obligatorios son abstract y los ganchos virtual, con una implementación por defecto que cada subclase puede cambiar.
Console.WriteLine(new NominaPlanilla().CalcularNomina(new Empleado("Ana") { SueldoBase = 4000, Hijos = 2 }));
Console.WriteLine(new NominaPracticante().CalcularNomina(new Empleado("Leo") { Subvencion = 1200 }));
Console.WriteLine(new NominaPorHoras().CalcularNomina(new Empleado("Rosa") { Horas = 80, TarifaHora = 25 }));
public record Empleado(string Nombre)
{
public decimal SueldoBase { get; init; }
public decimal Subvencion { get; init; }
public decimal Horas { get; init; }
public decimal TarifaHora { get; init; }
public int Hijos { get; init; }
}
public record Boleta(string Empleado, decimal Bruto, decimal Descuentos, decimal Bonificaciones, decimal Neto);
public abstract class CalculoNomina
{
// Método plantilla: no es virtual, así que el orden de los pasos no se puede cambiar
public Boleta CalcularNomina(Empleado e)
{
var bruto = IngresoBruto(e);
var descuentos = AportaPension ? Math.Round(bruto * 0.13m, 2) : 0;
var bonificaciones = Bonificaciones(e);
return new Boleta(e.Nombre, bruto, descuentos, bonificaciones, bruto - descuentos + bonificaciones);
}
protected abstract decimal IngresoBruto(Empleado e); // paso obligatorio
protected virtual decimal Bonificaciones(Empleado e) => 0; // gancho
protected virtual bool AportaPension => true; // gancho
}
public class NominaPlanilla : CalculoNomina
{
protected override decimal IngresoBruto(Empleado e) => e.SueldoBase;
protected override decimal Bonificaciones(Empleado e) => e.Hijos > 0 ? 100 : 0;
}
public class NominaPracticante : CalculoNomina
{
protected override decimal IngresoBruto(Empleado e) => e.Subvencion;
protected override bool AportaPension => false;
}
public class NominaPorHoras : CalculoNomina
{
protected override decimal IngresoBruto(Empleado e) => e.Horas * e.TarifaHora;
}LO IDIOMÁTICO EN JAVA: El método plantilla se declara final, así ninguna subclase puede cambiar el orden de los pasos. Los pasos obligatorios son abstract y los ganchos son métodos protected con una implementación por defecto que las subclases pueden sobrescribir.
void main() {
IO.println(new NominaPlanilla().calcularNomina(new Empleado("Ana", 4000, 0, 0, 0, 2)));
IO.println(new NominaPracticante().calcularNomina(new Empleado("Leo", 0, 1200, 0, 0, 0)));
IO.println(new NominaPorHoras().calcularNomina(new Empleado("Rosa", 0, 0, 80, 25, 0)));
}
record Empleado(String nombre, double sueldoBase, double subvencion, double horas, double tarifaHora, int hijos) {}
record Boleta(String empleado, double bruto, double descuentos, double bonificaciones, double neto) {}
abstract class CalculoNomina {
// Método plantilla: `final`, el orden de los pasos no se puede cambiar
final Boleta calcularNomina(Empleado e) {
var bruto = ingresoBruto(e);
var descuentos = aportaPension() ? redondear(bruto * 0.13) : 0;
var bonificaciones = bonificaciones(e);
return new Boleta(e.nombre(), bruto, descuentos, bonificaciones, redondear(bruto - descuentos + bonificaciones));
}
protected abstract double ingresoBruto(Empleado e); // paso obligatorio
protected double bonificaciones(Empleado e) { return 0; } // gancho
protected boolean aportaPension() { return true; } // gancho
private static double redondear(double valor) {
return Math.round(valor * 100) / 100.0;
}
}
class NominaPlanilla extends CalculoNomina {
@Override protected double ingresoBruto(Empleado e) { return e.sueldoBase(); }
@Override protected double bonificaciones(Empleado e) { return e.hijos() > 0 ? 100 : 0; }
}
class NominaPracticante extends CalculoNomina {
@Override protected double ingresoBruto(Empleado e) { return e.subvencion(); }
@Override protected boolean aportaPension() { return false; }
}
class NominaPorHoras extends CalculoNomina {
@Override protected double ingresoBruto(Empleado e) { return e.horas() * e.tarifaHora(); }
}LO IDIOMÁTICO EN JAVASCRIPT: Sin abstract, el paso obligatorio lanza un error en la clase base. Los ganchos son métodos con una implementación por defecto, y el paso común es privado (#), así que ninguna subclase puede alterarlo.
/** @typedef {{ nombre: string, sueldoBase?: number, subvencion?: number, horas?: number, tarifaHora?: number, hijos?: number }} Empleado */
const redondear = (n) => Math.round(n * 100) / 100;
export class CalculoNomina {
// Método plantilla: el orden de los pasos es siempre el mismo
/** @param {Empleado} empleado */
calcularNomina(empleado) {
const bruto = this.ingresoBruto(empleado);
const descuentos = this.#descuentosDeLey(bruto);
const bonificaciones = this.bonificaciones(empleado);
return { empleado: empleado.nombre, bruto, descuentos, bonificaciones, neto: redondear(bruto - descuentos + bonificaciones) };
}
/** @param {Empleado} _empleado @returns {number} */
ingresoBruto(_empleado) {
throw new Error(`${this.constructor.name} debe implementar ingresoBruto()`); // paso obligatorio
}
/** @param {Empleado} _empleado */
bonificaciones(_empleado) { return 0; } // gancho
aportaPension() { return true; } // gancho
#descuentosDeLey(bruto) { // paso común
return this.aportaPension() ? redondear(bruto * 0.13) : 0;
}
}
export class NominaPlanilla extends CalculoNomina {
ingresoBruto(e) { return e.sueldoBase; }
bonificaciones(e) { return e.hijos > 0 ? 100 : 0; }
}
export class NominaPracticante extends CalculoNomina {
ingresoBruto(e) { return e.subvencion; }
aportaPension() { return false; }
}
export class NominaPorHoras extends CalculoNomina {
ingresoBruto(e) { return e.horas * e.tarifaHora; }
}
// ── 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 }));LO IDIOMÁTICO EN PYTHON: @abstractmethod marca el paso obligatorio, los métodos con implementación por defecto son ganchos, y @final (de typing) declara que el método plantilla no debe sobrescribirse: los verificadores de tipos (mypy, Pyright) avisan si una subclase lo intenta.
from abc import ABC, abstractmethod
from dataclasses import dataclass
from typing import final
@dataclass(frozen=True)
class Empleado:
nombre: str
sueldo_base: float = 0
subvencion: float = 0
horas: float = 0
tarifa_hora: float = 0
hijos: int = 0
@dataclass(frozen=True)
class Boleta:
empleado: str
bruto: float
descuentos: float
bonificaciones: float
neto: float
class CalculoNomina(ABC):
@final
def calcular_nomina(self, e: Empleado) -> Boleta:
"""Método plantilla: el orden de los pasos es siempre el mismo."""
bruto = self.ingreso_bruto(e)
descuentos = self._descuentos_de_ley(bruto)
bonificaciones = self.bonificaciones(e)
return Boleta(e.nombre, bruto, descuentos, bonificaciones, round(bruto - descuentos + bonificaciones, 2))
@abstractmethod
def ingreso_bruto(self, e: Empleado) -> float: ... # paso obligatorio
def bonificaciones(self, e: Empleado) -> float: # gancho
return 0
def aporta_pension(self) -> bool: # gancho
return True
def _descuentos_de_ley(self, bruto: float) -> float: # paso común
return round(bruto * 0.13, 2) if self.aporta_pension() else 0
class NominaPlanilla(CalculoNomina):
def ingreso_bruto(self, e: Empleado) -> float:
return e.sueldo_base
def bonificaciones(self, e: Empleado) -> float:
return 100 if e.hijos > 0 else 0
class NominaPracticante(CalculoNomina):
def ingreso_bruto(self, e: Empleado) -> float:
return e.subvencion
def aporta_pension(self) -> bool:
return False
class NominaPorHoras(CalculoNomina):
def ingreso_bruto(self, e: Empleado) -> float:
return e.horas * e.tarifa_hora
if __name__ == "__main__":
print(NominaPlanilla().calcular_nomina(Empleado("Ana", sueldo_base=4000, hijos=2)))
print(NominaPracticante().calcular_nomina(Empleado("Leo", subvencion=1200)))
print(NominaPorHoras().calcular_nomina(Empleado("Rosa", horas=80, tarifa_hora=25)))LO IDIOMÁTICO EN GO: Go no tiene herencia, así que el método plantilla es una función que recibe los pasos variables como una interfaz. Los ganchos con comportamiento por defecto se obtienen incrustando el struct pasosPorDefecto, y cada tipo de contrato solo define lo que cambia.
package main
import (
"fmt"
"math"
)
type Empleado struct {
Nombre string
SueldoBase, Subvencion, Horas, TarifaHora float64
Hijos int
}
type Boleta struct {
Empleado string
Bruto, Descuentos, Bonificaciones, Neto float64
}
type PasosNomina interface {
IngresoBruto(Empleado) float64 // paso obligatorio
Bonificaciones(Empleado) float64 // gancho
AportaPension() bool // gancho
}
// pasosPorDefecto aporta los ganchos a quien lo incruste
type pasosPorDefecto struct{}
func (pasosPorDefecto) Bonificaciones(Empleado) float64 { return 0 }
func (pasosPorDefecto) AportaPension() bool { return true }
func redondear(n float64) float64 { return math.Round(n*100) / 100 }
// CalcularNomina es el método plantilla: el orden de los pasos es siempre el mismo
func CalcularNomina(e Empleado, pasos PasosNomina) Boleta {
bruto := pasos.IngresoBruto(e)
descuentos := 0.0
if pasos.AportaPension() {
descuentos = redondear(bruto * 0.13)
}
bonificaciones := pasos.Bonificaciones(e)
return Boleta{e.Nombre, bruto, descuentos, bonificaciones, redondear(bruto - descuentos + bonificaciones)}
}
type NominaPlanilla struct{ pasosPorDefecto }
func (NominaPlanilla) IngresoBruto(e Empleado) float64 { return e.SueldoBase }
func (NominaPlanilla) Bonificaciones(e Empleado) float64 {
if e.Hijos > 0 {
return 100
}
return 0
}
type NominaPracticante struct{ pasosPorDefecto }
func (NominaPracticante) IngresoBruto(e Empleado) float64 { return e.Subvencion }
func (NominaPracticante) AportaPension() bool { return false }
type NominaPorHoras struct{ pasosPorDefecto }
func (NominaPorHoras) IngresoBruto(e Empleado) float64 { return e.Horas * e.TarifaHora }
func main() {
fmt.Printf("%+v\n", CalcularNomina(Empleado{Nombre: "Ana", SueldoBase: 4000, Hijos: 2}, NominaPlanilla{}))
fmt.Printf("%+v\n", CalcularNomina(Empleado{Nombre: "Leo", Subvencion: 1200}, NominaPracticante{}))
fmt.Printf("%+v\n", CalcularNomina(Empleado{Nombre: "Rosa", Horas: 80, TarifaHora: 25}, NominaPorHoras{}))
}LO IDIOMÁTICO EN RUST: En Rust, el método plantilla es un método provisto de un trait (con implementación por defecto) que llama a un método requerido (el paso obligatorio) y a otros provistos (los ganchos). A diferencia de Java o C#, no se puede impedir que una implementación lo sobrescriba: se documenta.
use std::fmt;
#[derive(Default)]
struct Empleado {
nombre: &'static str,
sueldo_base: f64,
subvencion: f64,
horas: f64,
tarifa_hora: f64,
hijos: u32,
}
struct Boleta {
empleado: &'static str,
bruto: f64,
descuentos: f64,
bonificaciones: f64,
neto: f64,
}
impl fmt::Display for Boleta {
fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result {
write!(
f,
"{}: bruto {}, descuentos {}, bonificaciones {}, neto {}",
self.empleado, self.bruto, self.descuentos, self.bonificaciones, self.neto
)
}
}
fn redondear(valor: f64) -> f64 {
(valor * 100.0).round() / 100.0
}
trait CalculoNomina {
fn ingreso_bruto(&self, e: &Empleado) -> f64; // paso obligatorio
fn bonificaciones(&self, _e: &Empleado) -> f64 {
0.0 // gancho
}
fn aporta_pension(&self) -> bool {
true // gancho
}
// Método plantilla: el orden de los pasos es siempre el mismo (no lo sobrescribas)
fn calcular_nomina(&self, e: &Empleado) -> Boleta {
let bruto = self.ingreso_bruto(e);
let descuentos = if self.aporta_pension() {
redondear(bruto * 0.13)
} else {
0.0
};
let bonificaciones = self.bonificaciones(e);
Boleta {
empleado: e.nombre,
bruto,
descuentos,
bonificaciones,
neto: redondear(bruto - descuentos + bonificaciones),
}
}
}
struct NominaPlanilla;
impl CalculoNomina for NominaPlanilla {
fn ingreso_bruto(&self, e: &Empleado) -> f64 {
e.sueldo_base
}
fn bonificaciones(&self, e: &Empleado) -> f64 {
if e.hijos > 0 { 100.0 } else { 0.0 }
}
}
struct NominaPracticante;
impl CalculoNomina for NominaPracticante {
fn ingreso_bruto(&self, e: &Empleado) -> f64 {
e.subvencion
}
fn aporta_pension(&self) -> bool {
false
}
}
struct NominaPorHoras;
impl CalculoNomina for NominaPorHoras {
fn ingreso_bruto(&self, e: &Empleado) -> f64 {
e.horas * e.tarifa_hora
}
}
fn main() {
let ana = Empleado {
nombre: "Ana",
sueldo_base: 4000.0,
hijos: 2,
..Default::default()
};
let leo = Empleado {
nombre: "Leo",
subvencion: 1200.0,
..Default::default()
};
let rosa = Empleado {
nombre: "Rosa",
horas: 80.0,
tarifa_hora: 25.0,
..Default::default()
};
println!("{}", NominaPlanilla.calcular_nomina(&ana)); // Ana: bruto 4000, descuentos 520, bonificaciones 100, neto 3580
println!("{}", NominaPracticante.calcular_nomina(&leo)); // Leo: bruto 1200, descuentos 0, ... neto 1200
println!("{}", NominaPorHoras.calcular_nomina(&rosa)); // Rosa: bruto 2000, descuentos 260, ... neto 1740
}LO IDIOMÁTICO EN PHP: El método plantilla se declara final public, así ninguna subclase puede cambiar el orden de los pasos. Los pasos obligatorios son abstract protected y los ganchos son métodos protected con una implementación por defecto.
<?php
declare(strict_types=1);
final readonly class Empleado
{
public function __construct(
public string $nombre,
public float $sueldoBase = 0,
public float $subvencion = 0,
public float $horas = 0,
public float $tarifaHora = 0,
public int $hijos = 0,
) {}
}
abstract class CalculoNomina
{
// Método plantilla: `final`, el orden de los pasos no se puede cambiar
final public function calcularNomina(Empleado $e): string
{
$bruto = $this->ingresoBruto($e);
$descuentos = $this->aportaPension() ? round($bruto * 0.13, 2) : 0.0;
$bonificaciones = $this->bonificaciones($e);
$neto = round($bruto - $descuentos + $bonificaciones, 2);
return "{$e->nombre}: bruto {$bruto}, descuentos {$descuentos}, bonificaciones {$bonificaciones}, neto {$neto}";
}
abstract protected function ingresoBruto(Empleado $e): float; // paso obligatorio
protected function bonificaciones(Empleado $e): float { return 0.0; } // gancho
protected function aportaPension(): bool { return true; } // gancho
}
final class NominaPlanilla extends CalculoNomina
{
protected function ingresoBruto(Empleado $e): float { return $e->sueldoBase; }
protected function bonificaciones(Empleado $e): float { return $e->hijos > 0 ? 100.0 : 0.0; }
}
final class NominaPracticante extends CalculoNomina
{
protected function ingresoBruto(Empleado $e): float { return $e->subvencion; }
protected function aportaPension(): bool { return false; }
}
final class NominaPorHoras extends CalculoNomina
{
protected function ingresoBruto(Empleado $e): float { return $e->horas * $e->tarifaHora; }
}
echo (new NominaPlanilla())->calcularNomina(new Empleado('Ana', sueldoBase: 4000, hijos: 2)), "\n";
echo (new NominaPracticante())->calcularNomina(new Empleado('Leo', subvencion: 1200)), "\n";
echo (new NominaPorHoras())->calcularNomina(new Empleado('Rosa', horas: 80, tarifaHora: 25)), "\n";
// Ana: bruto 4000, descuentos 520, bonificaciones 100, neto 3580 · ...