Template Method (patrón de diseño)

De Wikipedia, la enciclopedia libre
Saltar a: navegación, búsqueda
Método de plantilla: UML esquema de clase.

En ingeniería de software, el patrón de método de la plantilla es un patrón de diseño de comportamiento que define el esqueleto de programa de un algoritmo en un método, llamado método de plantilla, el cual difiere algunos pasos a las subclases.[1] Permite redefinir ciertos pasos seguros de un algoritmo sin cambiar la estructura del algoritmo.[2] Este uso de "plantilla", no está relacionado a plantillas de #C++.

Uso[editar]

Método de plantilla en LePUS3 (leyenda)

El método de plantilla está diseñado para marcos, donde cada cual implementa las partes invariables de la arquitectura de un ámbito, dejando "placeholders" para personalizar las opciones. Esto es un ejemplo de inversion de control. Alguna razones por la que se utiliza el método de plantilla son:[3]

  • Dejar que las subclases que se implementan (a través del método primordial) tengan un comportamiento que puede variar.
  • Evitar duplicación en el código: la estructura general de flujo de trabajo, está implementada una vez en el algoritmo de clase abstracta, y variaciones necesarias son implementadas en cada de las subclases.
  • Control en qué punto(s) la subclassing está permitida. En oposición a una sencilla sobrecarga polimórfica, donde el método de base sería enteramente reescrito, permitiendo un cambio radical en el flujo. Sólo los detalles específicos del flujo se pueden cambiar.

Ejemplo en Java[editar]

/**
 * An abstract class that is common to several games in
 * which players play against the others, but only one is
 * playing at a given time.
 */

abstract class Game {
 /* Hook methods. Concrete implementation may differ in each subclass*/
    protected int playersCount;
    abstract void initializeGame();
    abstract void makePlay(int player);
    abstract boolean endOfGame();
    abstract void printWinner();

    /* A template method : */
    public final void playOneGame(int playersCount) {
        this.playersCount = playersCount;
        initializeGame();
        int j = 0;
        while (!endOfGame()) {
            makePlay(j);
            j = (j + 1) % playersCount;
        }
        printWinner();
    }
}

//Now we can extend this class in order 
//to implement actual games:

class Monopoly extends Game {

    /* Implementation of necessary concrete methods */
    void initializeGame() {
        // Initialize players
        // Initialize money
    }
    void makePlay(int player) {
        // Process one turn of player
    }
    boolean endOfGame() {
        // Return true if game is over 
        // according to Monopoly rules
    }
    void printWinner() {
        // Display who won
    }
    /* Specific declarations for the Monopoly game. */

    // ...
}

class Chess extends Game {

    /* Implementation of necessary concrete methods */
    void initializeGame() {
        // Initialize players
        // Put the pieces on the board
    }
    void makePlay(int player) {
        // Process a turn for the player
    }
    boolean endOfGame() {
        // Return true if in Checkmate or 
        // Stalemate has been reached
    }
    void printWinner() {
        // Display the winning player
    }
    /* Specific declarations for the chess game. */

    // ...
}


Véase también[editar]

Referencias[editar]

  1. Gamma, Erich; Helm, Richard; Johnson, Ralph; Vlissides, John (1994). «Template Method». Design Patterns. Addison-Wesley. pp. 325-330. ISBN 0-201-63361-2. 
  2. Freeman, Eric; Freeman, Elisabeth; Kathy, Sierra; Bert, Bates (2004). Hendrickson, Mike; Loukides, Mike, eds. Head First Design Patterns (paperback) 1. O'REILLY. p. 289. ISBN 978-0-596-00712-6. Consultado el 12 de septiembre de 2012. 
  3. «Template Method Design Pattern». Source Making - teaching IT professional. Consultado el 12 de septiembre de 2012. «Template Method is used prominently in frameworks.» 

Enlaces externos[editar]