b"\n_START_ARTICLE_\nM\xc3\xa8tode Template\n_START_PARAGRAPH_\nA dins del marc de la programaci\xc3\xb3 orientada a objectes, el patr\xc3\xb3 m\xc3\xa8tode Template (m\xc3\xa8tode plantilla o model) \xc3\xa9s un patr\xc3\xb3 per solucionar problemes comuns de programari. El patr\xc3\xb3 de disseny Template Method \xc3\xa9s un patr\xc3\xb3 de comportament, aquest patr\xc3\xb3 ens permet definir una estructura algor\xc3\xadtmica a la superclasse, delegant la implementaci\xc3\xb3 d'alguns m\xc3\xa8todes a les subclasses. \xc3\x89s un patr\xc3\xb3 que utilitza el principi de Hollywood: Don't call us, we'll call you! a m\xc3\xa9s ens facilita la utilitzaci\xc3\xb3 de hooks._NEWLINE_El m\xc3\xa8tode Template \xc3\xa9s un patr\xc3\xb3 de comportament que serveix per definir l'esquelet d'un algorisme, delegant a les seves subclasses alguns dels passos d'aquest algorisme. El m\xc3\xa8tode Template \xc3\xa9s utilitzat quan moltes classes han d'implementar un mateix comportament que nom\xc3\xa9s varia en algunes parts, tamb\xc3\xa9 ens trobem amb la implementaci\xc3\xb3 de m\xc3\xa8todes de ganxo (hooks), petits salts en el flux del programa que ens permeten realitzar consultes a les classes concretes, el patr\xc3\xb3 template tamb\xc3\xa9 utilitza el principi de Hollywood (o principi d'inversi\xc3\xb3): Don't call us, we'll call you.\n_START_SECTION_\nProp\xc3\xb2sit\n_START_PARAGRAPH_\nPermetre que certs passos d'un algorisme definit en una operaci\xc3\xb3 d'una superclasse, siguin redefinits en les subclasses sense necessitat d'haver de sobreescriure l'operaci\xc3\xb3 sencera.\n_START_SECTION_\nEstructura\n_START_PARAGRAPH_\nEs mostra a continuaci\xc3\xb3 l'estructura que utilitza el patr\xc3\xb3 Template:\n_START_SECTION_\nClasse Abstracta\n_START_PARAGRAPH_\nProporciona la definici\xc3\xb3 d'una s\xc3\xa8rie d'operacions primitives (normalment abstractes) que implementen els passos d'un algorisme i que seran definits en les subclasses. S'encarrega tamb\xc3\xa9 de la implementaci\xc3\xb3 d'un m\xc3\xa8tode en el que s'invocaran entre altres les operacions primitives. Aquest m\xc3\xa8tode actua com plantilla, per aix\xc3\xb2 el nom del patr\xc3\xb3, definint la seq\xc3\xbc\xc3\xa8ncia d'operacions d'un algorisme.\n_START_SECTION_\nClasse Concreta\n_START_PARAGRAPH_\nImplementa les operacions primitives definides en la classe abstracta de la qual hereta, quedant determinat el comportament espec\xc3\xadfic de l'algorisme definit en el m\xc3\xa8tode plantilla, per cada subclasse.\n_START_SECTION_\nCol\xc2\xb7laboracions\n_START_PARAGRAPH_\nLes classes concretes es basen en la classe abstracta per implementar la part invariant de l'algorisme.\n_START_SECTION_\nExemple\n_START_PARAGRAPH_\n/** * 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. */public abstract class Joc{_NEWLINE__NEWLINE_    protected int torn;_NEWLINE_    abstract void inicialitzarJoc();_NEWLINE_    abstract void ferJugada(int player);_NEWLINE_    abstract boolean fiJoc();_NEWLINE_    abstract void mostrarGuanyador();_NEWLINE__NEWLINE_    /* A template method */_NEWLINE_    public final void jugar(int torn) {_NEWLINE_        this.torn = torn;_NEWLINE_        inicialitzarJoc();_NEWLINE_        int j = 0;_NEWLINE_        while (!fiJoc()) {_NEWLINE_            ferJugada(j);_NEWLINE_            j = (j + 1) % torn;_NEWLINE_        }_NEWLINE_        mostrarGuanyador();_NEWLINE_    }}//Now we can extend this class in order //to implement actual games:public class Monopoli extends Joc {_NEWLINE__NEWLINE_    /* Implementation of necessary concrete methods */_NEWLINE_    public void inicialitzarJoc() {_NEWLINE_        // Inicialitzar jugadors_NEWLINE_        // Inicialitzar diners inicials_NEWLINE_    }_NEWLINE_    public void ferJugada(int jugador) {_NEWLINE_        // Fer una tirada_NEWLINE_    }_NEWLINE_    public boolean fiJoc() {_NEWLINE_        // Retorna true si el joc a finalitzat_NEWLINE_        // segons les regles del Monopoliu_NEWLINE_    }_NEWLINE_    public int intGuanyador() {_NEWLINE_        // Mostra qui guanya_NEWLINE__NEWLINE_    }_NEWLINE_    /* Altres funcions del joc. */_NEWLINE__NEWLINE_    // ...}public class Trivial extends Joc {_NEWLINE__NEWLINE_    /* Implementation of necessary concrete methods */_NEWLINE_    public void inicialitzarJoc() {_NEWLINE_        // Initialize players_NEWLINE_        // Put the pieces on the board_NEWLINE_    }_NEWLINE_    public void ferJugada(int player) {_NEWLINE_        // Process a turn for the player_NEWLINE_    }_NEWLINE_    public boolean fiJoc() {_NEWLINE_        // Return true if in Checkmate or _NEWLINE_        // Stalemate has been reached_NEWLINE_    }_NEWLINE_    public void mostrarGuanyador() {_NEWLINE_        // Mostrar el guanyador_NEWLINE_    }_NEWLINE_    /* Altres funcions del joc. */_NEWLINE__NEWLINE_    // ...}"