Patrón de diseño Abstract Factory

El patrón Abstract Factory nos permite crear, mediante una interfaz, conjuntos o familias
de objetos (denominados productos) que dependen mutuamente y todo esto sin
especificar cuál es el objeto concreto.
¿Que usos tiene el patrón Abstract Factory?
Se aplica cuando:
 Un sistema debe ser independiente de cómo sus objetos son creados.
 Un sistema debe ser 'configurado' con una cierta familia de productos.
 Se necesita reforzar la noción de dependencia mutua entre ciertos objetos.
Estructura del Patrón Abstract Factory
 Elementos del Patrón Abstract Factory
FabricaAbstracta*: Define un conjunto de métodos (interfaz) para la creación de
productos abstractos.
FabricaConcreta1/2: Implementa la interfaz de la FabricaAbstracta para la creación de los
distintos productos concretos.
ProductoAbstractoA*/B*: Define la interfaz de los objetos de tipo ProductoA/B.
ProductoConcretoA1/A2/B1/B2: Implementan su respectiva interfaz representando un
producto concreto.
Ventajas y desventajas
1. + Brinda flexibilidad al aislar a las clases concretas.
2. + Facilita cambiar las familias de productos.
- Para agregar nuevos productos se deben modificar tanto las fabricas
abstractas como las concretas.
Ejemplo del Patrón Abstract Factory
Teniendo en cuenta la siguiente jerarquía de clases, la cual trata de representar muy por
arriba dos familias de productos (DVD y BluRay) cada uno con un par de variantes (simple
y doble capa) para que permiten mostrar diferentes aspectos a tener en cuenta a la hora
de usar este patrón.
Se visualiza como sería el producto abstracto:

1. public abstract class Disco implements Prototipo {

2. @Override
3. public abstract Prototipo clone();
4.
5. public abstract String getCapacidad();
6.
7. public abstract String getNombre();
8.
9. public abstract String getPrecio();
10.
11. @Override
12. public String toString() {
13. return getNombre() + " (" + getCapacidad() + ")";
14. }
15. }

El producto DVD extendemos del Disco

1. public abstract class DVD extends Disco {

2. ...
3. }

Y el producto concreto del DVD extenderá de la anterior clase:

1. public class DVD_CapaSimple extends DVD {

2.
3. @Override
4. public Prototipo clone() {
5. return new DVD_CapaSimple();
6. }
7.
8. @Override
9. public String getCapacidad() {
 10. return "4.7GB";
11. }
12.
13. @Override
14. public String getNombre() {
15. return "DVD Capa Simple";
16. }
17.
18. @Override
19. public String getPrecio() {
20. return "5.00$";
21. }
22.
23. }

construir un AbstractFactory que nos permita crear discos de DVD o BluRay de simple y
doble capa usando el siguiente diseño:
Y sobre ese interface implementamos una de las fábricas concretas, en este caso la de
FabricaDiscos_CapaSimple:

1. public class FabricaDiscos_CapaSimple implements FabricaDiscos {

2.
3. @Override
4. public BluRay crearBluRay() {
5. return new BluRay_CapaSimple();
6. }
7.
8. @Override
9. public DVD crearDVD() {
10. return new DVD_CapaSimple();
11. }
12.
13. }

Veamos como quedaría el código fuente en Java para utilizar el patrón Abstract Factory:

1. FabricaDiscos fabrica;
2. DVD dvd;
3. BluRay bluray;
4.
5. fabrica = new FabricaDiscos_CapaSimple();
6. dvd = fabrica.crearDVD();
7. bluray = fabrica.crearBluRay();
8.
9. System.out.println(dvd);
10. System.out.println(bluray);
11.
12. fabrica = new FabricaDiscos_CapaDoble();
13. dvd = fabrica.crearDVD();
14. bluray = fabrica.crearBluRay();
15.
16. System.out.println(dvd);
17. System.out.println(bluray);

En el código vemos que sobre la fábrica podemos crear objetos de diferentes tipos y que
podríamos ir creciendo en productos atendiendo a nuestras necesidades.

1. fabrica = new FabricaDiscos_CapaSimple();

2. dvd = fabrica.crearDVD();
3. bluray = fabrica.crearBluRay();