Abstract Factory
| ||||
Abstract Factory (Fábrica Abstracta) es un patrón de diseño para el desarrollo de software. Provee una interfaz para crear familias de objetos relacionados o dependientes entre ellos sin especificar una clase en concreto.
Sumario
Contexto y problema
Contexto: Debemos crear diferentes objetos, todos pertenecientes a la misma familia. Por ejemplo: las librerías para crear interfaces gráficas suelen utilizar este patrón y cada familia sería un sistema operativo distinto. Así pues, el usuario declara un Botón, pero de forma más interna lo que está creando es un BotónWindows o un BotónLinux, por ejemplo.
El problema que intenta solucionar este patrón es el de crear diferentes familias de objetos.
El patrón Abstract Factory está aconsejado cuando se prevé la inclusión de nuevas familias de productos, pero puede resultar contraproducente cuando se añaden nuevos productos o cambian los existentes, puesto que afectaría a todas las familias creadas.
Aspecto estático
Estructura típica
- Cliente: La clase que llamará a la factoría adecuada ya que necesita crear uno de los objetos que provee la factoría, es decir, Cliente lo que quiere es obtener una instancia de alguno de los productos (ProductoA, ProductoB).
- AbstractFactory: Es de definición de la interfaces de las factorías. Debe de proveer un método para la obtención de cada objeto que pueda crear. ("crearProductoA()" y "crearProductoB()")
- Factorías Concretas: Estas son las diferentes familias de productos. Provee de la instancia concreta de la que se encarga de crear. De esta forma podemos tener una factoría que cree los elementos gráficos para Windows y otra que los cree para Linux, pudiendo poner fácilmente (creando una nueva) otra que los cree para MacOS, por ejemplo.
- Producto abstracto: Definición de las interfaces para la familia de productos genéricos. En el diagrama son "ProductoA" y "ProductoB". En un ejemplo de interfaces gráficas podrían ser todos los elementos: Botón, Ventana, Cuadro de Texto, Combo... El cliente trabajará directamente sobre esta interfaz, que será implementada por los diferentes productos concretos.
- Producto concreto: Implementación de los diferentes productos. Podría ser por ejemplo "BotónWindows" y "BotónLinux". Como ambos implementan "Botón" el cliente no sabrá si está en Windows o Linux, puesto que trabajará directamente sobre la superclase o interfaz.
Un ejemplo
Para mostrar el concepto del Abstract Factory vamos a hacer un sencillo reloj que nos muestra la hora actual. Como sabemos, la hora puede ser desplegada en formato de 24Hrs o puede ser desplegada en formato AM/PM. Recordando que es a manera de ejemplo, vamos a utilizar la clase Date de una manera que no se debe, y probablemente el reloj lo haríamos de una manera más sencilla, pero para nuestro ejemplo queda perfecta su uso. Como en el caso del diccionario, haremos una clase abstracta de Reloj y dos implementaciones para cada una de los formatos, y una clase que contenga el método del Factory Method. La cosa quedaría algo así:
La clase Reloj:
public abstract class Reloj {
abstract String dameLaHora();
}
La clase que se da la hora en formato AM/PM:
public class RelojAmPm extends Reloj{
public RelojAmPm(){
}
public String dameLaHora() {
Date d = new Date();
int hora = d.getHours();
int minutos = d.getMinutes();
int segundos = d.getSeconds();
String tr;
if (hora<=12){
tr="Son las "+hora+":"+minutos+":"+segundos+" AM";
} else {
tr="Son las "+(hora-12)+":"+minutos+":"+segundos+" PM";
}
return tr;
}
}
La que nos da la hora en formato de 24 horas:
public class Reloj24Hrs extends Reloj {
public String dameLaHora() {
Date d = new Date();
int hora = d.getHours();
int minutos = d.getMinutes();
int segundos = d.getSeconds();
String tr;
tr = "Son las " + hora + ":" + minutos + ":" + segundos + " ";
return tr;
}
}
Nuestra clase que contiene la el método que elije las instancias. A
diferencia del post anterior, ahora el parámetro que recibe el método
es un entero, que acepta los enteros especificados como constantes
estáticas en la clase. Esto se usa mucho para no estar adivinando los
paráemetros que acepta el método:
public class RelojFactory {
public static final int RELOJ_AM_PM=0;
public static final int RELOJ_24_HRS=1;
public RelojFactory(){
}
public static Reloj createReloj(int tipoDeReloj){
if (tipoDeReloj==RelojFactory.RELOJ_24_HRS){
return new Reloj24Hrs();
}
if (tipoDeReloj==RelojFactory.RELOJ_AM_PM){
return new RelojAmPm();
}
return null;
}
}
Y finalmente la clase cliente, que será la usuario final:
public class MainClient {
public static void main(String[] args) {
Reloj r = RelojFactory.createReloj(RelojFactory.RELOJ_24_HRS);
System.out.println(r.dameLaHora());
}
}
Hasta aquí tenemos dos fábricas: una de palabras, y la que acabamos de hacer que nos da la hora.
