Patrones de Diseño (IV): Patrones de Creación – Método Factoría

28 de julio de 2015Por Jorge López4 min de lectura
Patrones de Diseño (IV): Patrones de Creación – Método Factoría
Hasta ahora hemos descrito los patrones creacionales enfocados a la Clase. Recordemos, el patrón Factoría Abstracta (Abstract Factory) nos permitía crear objetos de diferentes familias (con una interfaz común) mediante una única clase que englobaba a todas, siendo útil cuando es probable que se añadan nuevas familias. El patrón Constructor (Builder) daba la posibilidad de crear objetos complejos mediante la construcción incremental de los mismos, de manera transparente, y es útil cuando trabajamos con objetos complejos de configuraciones limitadas y la construcción del objeto puede ser independizada de las partes que lo componen.

En esta entrega cambiamos de tercio, y empezamos a describir los patrones creacionales enfocados al objeto, es decir, el objeto a crear es creado por otro objeto (recordemos que en los patrones creacionales enfocados a la clase, utilizábamos las características de las clases, como herencia e interfaces).

El patrón que vamos a tratar es uno de los más utilizados debido a su gran utilidad: El método Factoría. El Método Factoría es una simplificación de la Factoría Abstracta (en realidad, la Factoría Abstracta es implementada con Métodos Factoría), que permite a una clase crear instancias de un objeto, pero son las subclases de la misma las que deciden el objeto concreto a instanciar. Sin más preámbulo, vamos con nuestra plantilla:

Método Factoría


Nombre: Factory Method

Problema y Contexto:

Una clase debe poder crear un objeto para trabajar con el, pero debido a la jerarquía de clases ésta no puede saber el objeto concreto con el que trabaja, por lo que debe delegar la instanciación a sus subclases.

Se aplica cuando:
  • La clase desconoce el tipo de objetos que debe crear.
  • Las subclases tienen la responsabilidad de concretar el objeto a crear.

Solución y Estructura:

La solución será crear una método abstracto en nuestra clase, que es definido por sus subclases a la hora de heredar de la misma.

La estructura es la siguiente:

https://upload.wikimedia.org/wikipedia/commons/e/ed/Factory_Method_UML_class_diagram.png

Donde:

Product: Interfaz que define las operaciones que poseé la instancia a implementar.

Creator: Es la clase la cual poseé el Método Factoría. Esta clase trabaja con la interfaz Product, y su Método Factoría creará objetos que implementen esta interfaz, pero éste es abstracto y debe ser implementado por sus subclases.

ConcreteCreator: Hijo de la clase Creator que definirá una implementación para el Método Factoría. Devolverá objetos de la clase ConcreteProduct.

ConcreteProduct: Clase concreta con la que trabajará Creator. Debe implementar la interfaz Product para que esto sea posible.

Consecuencias:
  • POSITIVAS:
    • Flexibilidad al abstraerse del tipo concreto de objeto a crear.
  • NEGATIVAS:
    • Aumenta la complejidad, por lo que es mas complejo entender la mecánica de la aplicación.

Patrones Relacionados: Factoría Abstracta (Abstract Factory)

Ejemplo:

Como venimos haciendo, ilustraremos el patrón mediante un ejemplo práctico. En este caso tomaremos como marco una cadena de producción en la que se expenderán refrescos de distintos tipos (Cola y Limón)

Para empezar definiremos la interfaz Refresco, que viene a ser el Product del patrón :


public interface Refresco
{
public Refresco crear();
public void operacionA();
public void operacionB();
public void operacionC();
}


El siguiente paso será definir el Creator, al que llamaremos Fábrica. Esta clase contendrá el Método Factoría que como sabemos, debe ser abstracto.


public class Fabrica{

/* Atributos … */

// Método Factoría
public abstract Refresco obtenerRefresco();

/* Otros Métodos … */

}


Ahora definiremos los productos concretos junto con sus respectivas fábricas, que vienen a representar los Concrete Products y Concrete Creators respectivamente:


public class RefrescoCola implements Refresco
{
public Refresco crear()
{
// Definimos como se crea el producto
}
public void operacionA()
{
// Definimos la operación A
}
public void operacionB()
{
// Definimos la operación B
}
public void operacionC()
{
// Definimos la operación C
}
}

public class FabricaCola extends Fabrica
{
public Refresco obtenerRefresco()
{
RefrescoCola r = new RefrescoCola();
return r;
}
/* Resto de Operaciones */
}

public class Limonada implements Refresco
{
public Refresco crear()
{
// Definimos como se crea el producto
}
public void operacionA()
{
// Definimos la operación A
}
public void operacionB()
{
// Definimos la operación B
}
public void operacionC()
{
// Definimos la operación C
}
}

public class FabricaLimonada extends Fabrica
{
public Refresco obtenerRefresco()
{
Limonada r = new Limonada();
return r;
}
/* Resto de Operaciones */
}

Ya tenemos definidos todos los elementos del patrón, así que vamos a ver como deben interactuar:


public static void main(String[] args)
{
Fabrica fabrica;
Refresco refresco;

if(args[0].equals(“Cola”))
{
fabrica = new FabricaCola();
}
else if(args[0].equals(“Limón”))
{
fabrica = new FabricaLimonada();
}

refresco = fabrica.obtenerRefresco();
refresco.operacionA();
refresco.operacionB();
refresco.operacionC();
}

Sigue leyendo