Patrón Template Method

from abc import ABC, abstractmethod


class Viaje(ABC):
    """La clase base fija el esqueleto del viaje; las subclases rellenan los pasos que cambian."""

    def hacer(self, destino):
        """El método plantilla: el orden de los pasos es siempre el mismo (Python no tiene final)."""
        print(f"Viaje a {destino}:")
        self.comprar_billete()
        if self.necesita_control():                       # un gancho
            print("  Pasar el control de equipajes")
        print("  Subir al tren")
        self.trayecto(destino)
        print(f"  Bajar en {destino}")

    @abstractmethod
    def comprar_billete(self): ...                        # pasos que escribe cada subclase

    @abstractmethod
    def trayecto(self, destino): ...

    def necesita_control(self):                           # gancho: tiene un valor por defecto
        return False


class Cercanias(Viaje):
    def comprar_billete(self):
        print("  Pasar el abono por el torno")

    def trayecto(self, destino):
        print(f"  12 paradas de pie hasta {destino}")


class AltaVelocidad(Viaje):
    def comprar_billete(self):
        print("  Comprar un billete con asiento: coche 5, plaza 8A")

    def necesita_control(self):
        return True

    def trayecto(self, destino):
        print(f"  2 h 30 min sin paradas hasta {destino}")


Cercanias().hacer("Alcalá")
AltaVelocidad().hacer("Sevilla")

/** La clase base fija el esqueleto del viaje; las subclases rellenan los pasos que cambian. */
class Viaje {
    /** El método plantilla: el orden de los pasos es siempre el mismo. */
    hacer(destino) {
        console.log(`Viaje a ${destino}:`);
        this.comprarBillete();
        if (this.necesitaControl()) console.log("  Pasar el control de equipajes");   // un gancho
        console.log("  Subir al tren");
        this.trayecto(destino);
        console.log(`  Bajar en ${destino}`);
    }

    comprarBillete() { throw new Error("Cada viaje compra su billete"); }        // pasos que escribe cada subclase
    trayecto(destino) { throw new Error("Cada viaje hace su trayecto"); }
    necesitaControl() { return false; }                                          // gancho: valor por defecto
}

class Cercanias extends Viaje {
    comprarBillete() { console.log("  Pasar el abono por el torno"); }
    trayecto(destino) { console.log(`  12 paradas de pie hasta ${destino}`); }
}

class AltaVelocidad extends Viaje {
    comprarBillete() { console.log("  Comprar un billete con asiento: coche 5, plaza 8A"); }
    necesitaControl() { return true; }
    trayecto(destino) { console.log(`  2 h 30 min sin paradas hasta ${destino}`); }
}

new Cercanias().hacer("Alcalá");
new AltaVelocidad().hacer("Sevilla");

using System;

// La clase base fija el esqueleto del viaje; las subclases rellenan los pasos que cambian.
abstract class Viaje {
    // El método plantilla: no es virtual, así que ninguna subclase puede cambiar el orden.
    public void Hacer(string destino) {
        Console.WriteLine(
quot;Viaje a {destino}:");
        ComprarBillete();
        if (NecesitaControl()) Console.WriteLine("  Pasar el control de equipajes");   // un gancho
        Console.WriteLine("  Subir al tren");
        Trayecto(destino);
        Console.WriteLine(
quot;  Bajar en {destino}");
    }

    protected abstract void ComprarBillete();                 // pasos que escribe cada subclase
    protected abstract void Trayecto(string destino);
    protected virtual bool NecesitaControl() => false;       // gancho: tiene un valor por defecto
}

class Cercanias : Viaje {
    protected override void ComprarBillete() => Console.WriteLine("  Pasar el abono por el torno");
    protected override void Trayecto(string destino) => Console.WriteLine(
quot;  12 paradas de pie hasta {destino}");
}

class AltaVelocidad : Viaje {
    protected override void ComprarBillete() => Console.WriteLine("  Comprar un billete con asiento: coche 5, plaza 8A");
    protected override bool NecesitaControl() => true;
    protected override void Trayecto(string destino) => Console.WriteLine(
quot;  2 h 30 min sin paradas hasta {destino}");
}

class Program {
    static void Main() {
        new Cercanias().Hacer("Alcalá");
        new AltaVelocidad().Hacer("Sevilla");
    }
}

<?php
/** La clase base fija el esqueleto del viaje; las subclases rellenan los pasos que cambian. */
abstract class Viaje {
    /** El método plantilla: final, así que ninguna subclase puede cambiar el orden. */
    final public function hacer(string $destino): void {
        echo "Viaje a $destino:\n";
        $this->comprarBillete();
        if ($this->necesitaControl()) echo "  Pasar el control de equipajes\n";   // un gancho
        echo "  Subir al tren\n";
        $this->trayecto($destino);
        echo "  Bajar en $destino\n";
    }

    abstract protected function comprarBillete(): void;                 // pasos que escribe cada subclase
    abstract protected function trayecto(string $destino): void;
    protected function necesitaControl(): bool { return false; }       // gancho: valor por defecto
}

class Cercanias extends Viaje {
    protected function comprarBillete(): void { echo "  Pasar el abono por el torno\n"; }
    protected function trayecto(string $destino): void { echo "  12 paradas de pie hasta $destino\n"; }
}

class AltaVelocidad extends Viaje {
    protected function comprarBillete(): void { echo "  Comprar un billete con asiento: coche 5, plaza 8A\n"; }
    protected function necesitaControl(): bool { return true; }
    protected function trayecto(string $destino): void { echo "  2 h 30 min sin paradas hasta $destino\n"; }
}

(new Cercanias())->hacer("Alcalá");
(new AltaVelocidad())->hacer("Sevilla");

import unittest

# unittest es un método plantilla: el framework llama a setUp, al test y a tearDown en su orden
class PruebasAgenda(unittest.TestCase):
    def setUp(self):
        self.agenda = Agenda()

    def test_anadir(self):
        self.agenda.anadir("Ana")
        self.assertEqual(self.agenda.total(), 1)

    def tearDown(self):
        self.agenda.cerrar()

# Django hace lo mismo con sus vistas: View.dispatch() llama a tu get() o post()

// Los componentes de clase de React siguen un esqueleto fijo: React llama a render y a los
// métodos del ciclo de vida (componentDidMount, componentWillUnmount…) cuando le toca
class Reloj extends React.Component {
    componentDidMount() { this.temporizador = setInterval(() => this.forceUpdate(), 1000); }
    componentWillUnmount() { clearInterval(this.temporizador); }
    render() { return <p>{new Date().toLocaleTimeString()}</p>; }
}

// Los custom elements también: el navegador llama a connectedCallback al insertarlos
class MiBoton extends HTMLElement {
    connectedCallback() { this.textContent = "Púlsame"; }
}

// Stream es un método plantilla: escribes Read y Write, y te da CopyTo, ReadAsync, etc.
// En ASP.NET Core, un BackgroundService ejecuta tu ExecuteAsync dentro de su ciclo de vida
public class Recordatorios : BackgroundService {
    protected override async Task ExecuteAsync(CancellationToken cancelar) {
        while (!cancelar.IsCancellationRequested) {
            await EnviarRecordatorios();
            await Task.Delay(TimeSpan.FromHours(1), cancelar);
        }
    }
}

<?php
// PHPUnit: el framework llama a setUp, a cada test y a tearDown en su orden
class AgendaTest extends PHPUnit\Framework\TestCase {
    private Agenda $agenda;

    protected function setUp(): void { $this->agenda = new Agenda(); }

    public function testAnadir(): void {
        $this->agenda->anadir("Ana");
        $this->assertSame(1, $this->agenda->total());
    }
}

// Los comandos de Laravel también: el framework prepara todo y llama a tu handle()