Template Method: un esqueleto con huecos

  • Lección 23 de 32
  • 10 min
  • Intermedio
  • 12 pasos

Dos informes con los mismos pasos copiados. Vas a subir el esqueleto a una clase base, dejar huecos para las subclases y ver cuándo una función hace lo mismo con menos.

Copias del esqueleto
1
tu códigoReportabstractAbstractListabstractInputStreamabstractReportSalesReportTrioBytesSalesReportStockReportStockReportUsersReportUsersReportrenderReportfunciónrenderReportrowscallbackrowsmismo esqueleto · 2 copiasDos clases, los mismos pasos// SalesReport.render()return ["REPORT","Mon 10", "Tue 12","-- end --"].join("\n");// StockReport.render()return ["REPORT","apples 4","-- end --"].join("\n");pie nuevopie viejoEl pie nuevo, en una sola copia// SalesReport.render()−"-- end --"].join("\n");+"-- end of report --"].join("\n");// StockReport.render()▸"-- end --"].join("\n");render() fija el ordenReport, el esqueletoabstract class Report {▸render(): string {return [this.header(),...this.rows(),this.footer()].join("\n");}protected abstract rows(): string[];}rows(): tu parterender()Lo que escribe SalesReportclass SalesReport extends Report {▸protected rows() {return ["Mon 10", "Tue 12"];}}new SalesReport().render();// REPORT, Mon 10, Tue 12, -- end --header y footer: por defectoredefine header()Hooks y pasos abstractos// en Reportprotected header() { return "REPORT"; }protected footer() { return "-- end --"; }▸protected abstract rows(): string[];// en StockReportprotected rows() { return ["apples 4"]; }▸protected header() { return "STOCK"; }solo escribe rows()El informe nuevo entero+class UsersReport extends Report {+protected rows() {+return ["ana", "luis"];+}+}get(i) y size()indexOf() ya viene hechoUna lista con dos métodosclass Trio extends AbstractList<String> {▸public String get(int i) {return "n" + i;}▸public int size() { return 3; }}new Trio().indexOf("n2"); // 2read() × 3read(buf, 0, 3)Un stream con un métodoclass Bytes extends InputStream {private int n = 0;▸public int read() {return n < 3 ? n++ : -1;}}// read(buf, 0, 3) llama 3 veces a read()no es una plantilla HTMLDos ideas equivocadas«es una plantilla HTML»es un algoritmo con huecos«necesita herencia»una función también sirveel hueco es un parámetrofija el ordenEl hueco como parámetrofunction renderReport(▸rows: () => string[],) {return ["REPORT", ...rows(),"-- end --"].join("\n");}+renderReport(() => ["Wed 7"]);¿quién llama a rows()?Cuándo nouna función bastapasa una funciónel orden de los pasos cambiael patrón no encajalees la subclaseno ves quién la llamacada informe: solo rows()Template Method en una tablaproblemapasos copiados en cada clasesoluciónrender() fija el ordenhuecosabstractos u opcionales (hooks)en JavaAbstractList, InputStreamno lo usessi una función basta
  • petición
  • respuesta

Paso 1 de 12

Problema

Dos informes, el mismo esqueleto

Una app genera informes de texto. SalesReport y StockReport arman su salida igual: un encabezado REPORT, las filas y un pie -- end --. Solo cambian las filas.

Cada clase escribe esos tres pasos por su cuenta. El orden y el formato están copiados, y nada obliga a que sigan iguales.

Paso 2 de 12

Problema

Cambias el pie y te olvidas de uno

Te piden que el pie diga -- end of report --. Abres SalesReport y lo cambias. Pero StockReport tiene su propia copia, y esa se queda con el pie viejo.

Nadie te avisa: las dos clases compilan y funcionan. Los informes ya no se parecen, y lo descubre quien los lee.

Qué cambió

  • pie de SalesReport

Paso 3 de 12

Concepto

El esqueleto sube a una clase base

Llevamos los pasos a una clase abstracta Report. Su método render() fija el orden: encabezado, filas, pie. Ese método es el template method: el esqueleto del algoritmo.

La parte que cambia, rows(), queda como un hueco: un método abstracto que cada subclase completa. SalesReport y StockReport heredan de Report; la línea con triángulo hueco significa «hereda de».

Qué cambió

  • abstract class Report
  • 2 copias del esqueleto

Paso 4 de 12

Técnica

No llamas a tu parte: te llaman

SalesReport solo escribe rows(). Tu código llama a render(), que vive en Report, y es render() quien llama a rows() cuando le toca.

Eso es inversión de control: la clase base decide cuándo corre tu parte. Es la forma que vas a ver en frameworks: heredas de una clase suya, escribes un método y el framework lo llama.

Paso 5 de 12

Técnica

Pasos con valor por defecto y pasos obligatorios

No todos los huecos son iguales. header() y footer() traen un valor por defecto: la subclase puede redefinirlos. A esos pasos opcionales se les llama hooks. rows() es abstracto: la subclase tiene que escribirlo, o no compila.

StockReport redefine header() para empezar con STOCK; SalesReport usa el de la base. El orden de los pasos sigue en render(), y ninguna subclase lo toca.

Qué cambió

  • header() en StockReport

Paso 6 de 12

Solución

Un informe nuevo es un método

Llega UsersReport. Ya no copias el esqueleto: heredas de Report y escribes rows(). Encabezado, pie y orden vienen de la base.

Y el pie del paso 2 ahora se cambia en un sitio: footer() en Report. Los tres informes lo reciben.

Qué cambió

  • UsersReport
  • footer() en Report

Paso 7 de 12

Técnica

En Java: `AbstractList`

La biblioteca estándar de Java usa este patrón. Para una lista de solo lectura extiendes AbstractList y escribes solo get(int) y size().

El resto ya viene hecho sobre esos dos métodos: por ejemplo iterator() e indexOf(). Tú llenas dos huecos; la base pone el algoritmo.

Paso 8 de 12

Técnica

En Java: `InputStream`

Otro caso: para crear tu propio InputStream tienes que escribir read(), que devuelve el siguiente byte, o -1 cuando no quedan más.

El read(buf, off, len) de la base llama a read() una y otra vez para llenar el arreglo. Tú dices cómo leer un byte; la base decide cuántas veces pedirlo.

Paso 9 de 12

Concepto

Ni plantillas HTML ni herencia obligatoria

Dos confusiones comunes. El template de este patrón no tiene nada que ver con las plantillas HTML de un motor de vistas: es un algoritmo con pasos fijos y huecos.

Y la idea no exige herencia: si el hueco es una función que recibes como parámetro, consigues lo mismo con menos acoplamiento. Lo ves en el próximo paso.

Paso 10 de 12

Técnica

El mismo esqueleto sin herencia

renderReport recibe el paso que cambia como una función, rows. Fija el orden igual que render(), pero no hay clase base ni subclases: llamas y pasas tu parte.

Es la idea de Strategy, la primera lección de este módulo. En tu propio código suele ser lo más simple; la herencia tiene sentido cuando un framework ya te da la clase base.

Qué cambió

  • extends Report
  • rows: () => string[]

Paso 11 de 12

Compromiso

Cuándo no usar Template Method

Ganas un esqueleto que nadie rompe y pasos que no se repiten. Pagas con acoplamiento: cada subclase depende de cómo Report llama a sus métodos, y un cambio en la base llega a todas.

Evítalo si una función basta, o si las subclases necesitan cambiar el orden de los pasos: el patrón existe justo para fijarlo. Y quien lee SalesReport ve rows() pero no quién lo llama; tiene que ir a buscarlo a la base.

Paso 12 de 12

Resumen

La base fija el orden, tú llenas los huecos

Cuando varias clases repiten los mismos pasos con detalles distintos, sube el esqueleto a un template method en una clase base y deja los detalles como métodos que las subclases completan.

Lo vas a ver en frameworks y en Java (AbstractList, InputStream). En tu propio código, si basta con pasar una función, pasa una función.

Aprenderás

  • Reconocer el problema: los mismos pasos copiados en varias clases que solo cambian en un detalle.
  • Subir el esqueleto a un método de una clase base que llama a los pasos que cambian.
  • Distinguir los pasos con valor por defecto de los pasos que la subclase tiene que escribir.
  • Reconocer el patrón en `AbstractList` e `InputStream` de Java.
  • Saber cuándo una función como parámetro es más simple y cuándo el patrón no encaja.