Podemos hacer uso de este patrón para crear un objeto que pueda comportarse de formas diferentes (lo cual se definirá en el momento de su instanciación o creación).
Para comprender mejor cómo funciona veamos un sencillo ejemplo:
Main.java:
package Strategy;
public class Main
{
public static void main(String[] args)
{
OperacionAritmetica context;
context = new OperacionAritmetica( new Sumar() );
int suma = context.procesar(3,4);
context = new OperacionAritmetica( new Restar() );
int resta = context.procesar(3,4);
context = new OperacionAritmetica( new Multiplicar() );
int multip = context.procesar(3,4);
System.out.println("Suma: " + suma );
System.out.println("Resta: " + resta );
System.out.println("Multiplicación: " + multip );
}
}
IAritmetica.java (una interface IAritmetica en el diagrama anterior):
package Strategy;
public interface IAritmetica
{
public int realizarOperacion(int a, int b);
}
Sumar.java (una EstrategiaConcreta en el diagrama anterior):
package Strategy;
public class Sumar implements IAritmetica
{
public Sumar() {
}
// -------------------------------
@Override
public int realizarOperacion(int a, int b)
{
return a + b;
}
}
Restar.java (una EstrategiaConcreta en el diagrama anterior):
package Strategy;
public class Restar implements IAritmetica
{
public Restar() {
}
// -------------------------------
@Override
public int realizarOperacion(int a, int b)
{
return a - b;
}
}
Multiplicar.java (una EstrategiaConcreta en el diagrama anterior):
package Strategy;
public class Multiplicar implements IAritmetica
{
public Multiplicar() {
}
// -------------------------------
@Override
public int realizarOperacion(int a, int b)
{
return a * b;
}
}
OperacionAritmetica.java (un Contexto en el diagrama anterior):
package Strategy;
public class OperacionAritmetica
{
private IAritmetica strategy;
// ----------------------------------
public OperacionAritmetica(IAritmetica strategy) {
this.strategy = strategy;
}
// ----------------------------------
public int procesar(int a, int b) {
return strategy.realizarOperacion(a, b);
}
}
Al ejecutarlo obtendríamos como resultado:
EXPLICACIÓN:
- Se crea la interface IAritmetica, en la que definimos el método que deberán contener las clases que la implementen.
- La clase OperacionAritmetica contiene una referencia a un objeto de tipo IAritmetica, para así poder utilizarlo cuando sea necesario.
- Al inicio del programa creamos tres instancias de OperacionAritmetica, indicando el comportamiento que deberá tener cada una de ellas.
- A continuación se realizan las operaciones y se muestra el resultado.
Este patrón de diseño es parecido al patrón State (en el que un objeto puede cambiar su estado interno durante la ejecución del programa pudiendo comportarse de forma diferente entonces), mientras que con Strategy se crean varios objetos de un mismo tipo pero pudiendo tener distintos comportamientos cada uno de ellos.
