El patrón Strategy
En internet existen varios sitios donde se explican los patrones de diseño con sumo detalle, por ejemplo:
La intención de este post es asentar los conocimientos adquiridos en un curso sobre patrones de diseño que estoy realizando (octubre y noviembre del 2010).
El patrón Strategy es un patrón que se engloba dentro de los conocidos como patrones de comportamiento.
El patrón Strategy nos permite definir varios algoritmos para un mismo método, de tal manera que podamos escoger en cada momento cómo queremos que se comporte nuestra clase cliente.
Veamos un ejemplo, imaginemos que tenemos una clase cliente con un método contador o cuenta sobre el cual decidiremos qué comportamiento darle en tiempo de ejecución. Una estrategia podría ser que nuestro contador cuente incrementalmente, y otra que lo haga forma decremental.
El patrón Strategy nos dice que debemos tener un Interface donde albergar la abstracción y unas clases donde implementar el comportamiento, además de una clase cliente.
Ficheros implicados en nuestro ejemplo:
* ContadorInterace.php
* ContadorIncrementa.php
* ContadorDecrementa.php
* Cliente.php
Interfaz
1 2 3 | interface ContadorInterface { public function cuenta(); } |
Estrategia 1, el contador cuenta de manera incremental
1 2 3 4 5 6 7 8 9 | class ContadorIncrementa implements ContadorInterface { public function cuenta() { for ($i = 1; $i <= 10; $i++) { echo $i, ','; } } } |
Estrategia 2, el contador cuenta de forma decremental
1 2 3 4 5 6 7 8 9 | class ContadorDecrementa implements ContadorInterface { public function cuenta() { for ($i = 10; $i > 0; $i--) { echo $i, ','; } } } |
Clase cliente
1 2 3 4 5 6 7 8 9 10 11 12 13 | class Cliente { private $contador; public function setContador(ContadorInterface $cuenta) { $this->contador = $cuenta; } public function cuenta() { $this->contador->cuenta(); } } |
Finalmente, tenemos nuestro fichero example.php
1 2 3 4 5 6 7 8 9 10 11 | include_once('class/Cliente.php'); include_once('class/ContadorInterface.php'); include_once('class/ContadorIncrementa.php'); include_once('class/ContadorDecrementa.php'); $cliente = new Cliente(); $cliente->setContador(new ContadorIncrementa()); $cliente->cuenta(); echo '<br />'; $cliente->setContador(new ContadorDecrementa()); $cliente->cuenta(); |
Y esto da como resultado
1,2,3,4,5,6,7,8,9,10, 10,9,8,7,6,5,4,3,2,1,






Buenas, buen post!
Este patrón me resulta muy parecido al patrón Dependency Injection (tan usado por Symfony): la clase recibe un contenedor que luego usará en alguno de sus métodos (en este caso cuenta).
Veo varias diferencias, por ejemplo, en Strategy la finalidad es englobar algoritmos y para ello se usa una clase por algoritmo y todas se modelan mediante un interfaz. Mientras que en Dependency Injection se externaliza no solo un algoritmo si no todo un modelo completo.
Qué opinas acerca de ésto?
Un saludo!
Hola @aRamirez,
No tengo mucha experiencia en patrones, ya que como dije al principio del artículo, estoy descubriéndolos ahora.
De todas formas, estoy de acuerdo en todo lo que comentas.
Strategy se centra en la funcionalidad de un método, mientras Denpendency Injection es más amplio.
Poco más puedo aportar, lo has descrito muy bien.
Saludos!