Abstract
Factory
Diseño y Aplicaciones
Patricia Cano Fernández
Rocío González García
Irene Zamora del Río
Índice











¿Qué son los Patrones de Creación?
Definición del Abstract Factory
Ejemplo
Aplicaciones
Estructura
Participantes
Colaboraciones
Consecuencias
Detalles de Implementación
Ejemplo con Código
Bibliografía
Abstract Factory
2
¿Qué son los Patrones de Creación?





Abstraen el proceso de
instanciación.
Hacen al sistema independiente de
las creaciones de objetos.
Encapsulan conocimientos sobre
clases concretas usadas por el
sistema.
Ocultan la forma en que se crean y
ponen en contacto las instancias.
No son siempre excluyentes: a
veces complementarios.
Abstract Factory
3
Definición del Abstract Factory





El patrón Abstract Factory ofrece una
interfaz para la creación de familias de
productos relacionados o dependientes
sin especificar las clases concretas a las
que pertenecen.
Look-And-Feel múltiple: diseño de GUI en
entorno de ventanas.
Su objetivo es soportar múltiples
estándares (MS-Windows, Motif, Open
Look,…).
Extensible para futuros estándares.
Restricciones: cambiar el Look-and-Feel
sin recompilar y cambiar el Look-and-Feel
en tiempo de ejecución.
Abstract Factory
4
Ejemplo
Ejemplo de partida: Creación de Widgets en
aplicación cliente.
 Un armazón para interfaces gráficas que
soporte distintos tipos de presentación
(look-and-feel).
 Las aplicaciones cliente no deben cambiar
porque cambie el aspecto de la interfaz
de usuario.
 Los clientes no son conscientes de las
clases concretas, sino sólo de las
abstractas.
 Sin embargo los WidgetFactory imponen
dependencias entre las clases concretas
de los Widgets que contiene.
Abstract Factory
5
Ejemplo
Abstract Factory
6
Ejemplo

Problema: Las aplicaciones clientes
NO deben crear sus widgets para un
Look-and-Feel concreto.
Scrollbar *sb = new MotifScrollBar();
Menu *menu = new MotifMenu();

Solución: Abstraer el proceso de
creación de widgets. En lugar de
Scrollbar *sb = new MotifScrollBar();
Usar:
Scrollbar *sb = WidgetFactory->CreateScrollBar();

WidgetFactory será una instancia de
MotifWidgetFactory
Abstract Factory
7
Aplicaciones




Un sistema debe ser independiente de los
procesos de creación, composición y
representación de sus productos.
Un sistema debe ser configurado con una
familia múltiple de productos.
Una familia de productos relacionados se
ha diseñado para ser usados
conjuntamente (y es necesario reforzar
esta restricción).
Se quiere proporcionar una librería de
productos y no revelar su implementación
(simplemente revelando sus interfaces).
Abstract Factory
8
Estructura
Abstract Factory
9
Participantes





AbstractFactory (WidgetFactory): Declara un
interfaz para las operaciones de creación de
objetos de productos abstractos
ConcreteFactory (MotifWidgetFactory,
PMWidgetFactory): Implementa las operaciones
para la creación de objetos de productos
concretos.
AbstractProduct (Window, ScrollBar): Declara
una interfaz para los objetos de un tipo de
productos.
ConcreteProduct (MotifWindow, MotifScrollBar):
Define un objeto de producto que creará la
correspondiente Concrete Factory, a la vez que
implementa la interfaz de AbstractProduct.
Client: Usa solamente las interfaces declaradas
por las clases AbstractFactory y AbstractProduct.
Abstract Factory
10
Colaboraciones


Una única instancia de cada
ConcreteFactory es creada en
tiempo de ejecución.
AbstractFactory delega la creación
de productos a sus subclases
ConcreteFactory.
Abstract Factory
11
Consecuencias

Ventajas:



Aisla las clases de implementacion:
ayuda a controlar los objetos que se
creen y encapsula la responsabilidad de
creación.
Hace fácil el intercambio de familias de
productos sin mezclarse, permitiendo
configurar un sistema con una de entre
varias familias de productos:
cambio de factory  cambio de familia.
Fomenta la consistencia entre
productos.
Abstract Factory
12
Consecuencias

Desventajas:

Puede ser difícil incorporar nuevos tipos
de productos (cambiar
AbstractFactory y sus factorias
concretas). Posible Solución:

Pasarle un parámetro a los métodos de
creación de productos  clase abstracta
común  necesidad de downcast 
solución no segura.
Abstract Factory
13
Detalles de Implementación

Factorias como singletons


Definir factorías extensibles


Sólo una instancia de ConcreteFactory
por familia de productos.
Añadiendo un parámetro en las
operaciones de creación que indique el
tipo de objeto a crear: mas flexible y
menos seguro.
¿Cómo crear los productos?
Utilizando un Factory Method para
cada producto.
Abstract Factory
14
Ejemplo con Código


Se dispone de una aplicación llamada Gramola que
elige aleatoriamente una serie de temas musicales
para tocar. La aplicación dispone de una base de
datos de temas o canciones de distintos estilos
musicales y reproducidos con distintos instrumentos.
Se dispone del siguiente diagrama UML que define a
la aplicación
Abstract Factory
15
Ejemplo con Código


A la gramola se le pide que elija aleatoriamente y
reproduzca temas de uno de tres estilos musicales, sin
mezclarlos.
Para resolver el problema que surge a la hora de reproducir
los temas y evitar que se mezclen, aplicamos el patrón
creacional abstract factory. En la implementación del patrón
Abstract Factory, la clase Gramola desempeña el papel de
abstract factory, quedando definidas actualmente dos
factorías concretas (GramolaFlamenco y GramolaJazzLatino), aunque se puede ampliar en el futuro con otras
factorías concretas. Los productos TemaGuitarra, TemaPiano
y TemaViento se convierten en abstractos, mientras que se
definen productos concretos (TemaXY , con X Є{Guitarra,
Piano, Viento} e Y Є{Flamenco, JazzLatino}) para cada uno
de los dos estilos musicales (familias de productos)
definidos.
Abstract Factory
16
Ejemplo con Código
Abstract Factory
17
Ejemplo con Código

Clase reproductor
class Reproductor {
/* Sabe cómo reproducir un tema*/
public void play(Tema tema) {
/* Aquí se localiza el medio (fichero,
etc.) que almacena el tema y lo reproduce
*/
}
}
Abstract Factory
18
Ejemplo con Código
/* Agrupación de constantes de estilos musicales
*/
interface EstiloMusical {
public int FLAMENCO = 0;
public int JAZZ_LATINO = 1;
}
/*Agrupación de constantes de instrumentos
musicales*/
interface InstrumentoMusical {
public int GUITARRA = 0;
public int PIANO = 1;
public int VIENTO = 2;
}
Abstract Factory
19
Ejemplo con Código

Clase BaseDeTemas
/** Simula la base de datos de temas
disponibles:
* El tema nombreTema[i][j] es del autor
nombreAutor[i][j], corresponde al estilo
musical i y al instrumento j*/
class BaseDeTemas implements EstiloMusical,
InstrumentoMusical {
public static final String nombreTema[][][]=
{{{ "Entre Dos Aguas", "De Colores" },
{"Orobroy", "Oye C´omo Viene" },{
"Hechizo","Aigua" }},{{ "Oye cómo va",
"Pajarito"},{"From Within", "El
Cumbanchero" },{"Panamericana", "Earth
Dance" }}}
Abstract Factory
20
Ejemplo con Código
public static final String nombreAutor[][][] =
{{{"Paco de Lucía", "Oscar Herrero" },{"David
Peña Dorantes", "Chano Domínguez" },{"Pedro
Esparza","Carles Benavent"}},{{"Carlos
Santana", "David Tabarez" },{"Michel
Camilo","Chucho Valdés"}, {"Paquito
D’Rivera","Jerry González"}}}
public static int elegirTemaAleatorio() {
// Elige un número aleatorio de tema
// (la base de datos de ejemplo sólo tiene 2
temas por cada estilo e instrumento)
return _random.nextInt(nombreTema[0][0].length);
}
}
Abstract Factory
21
Ejemplo con Código
Clase Tema
/* Representa un tema de un cierto estilo musical */
abstract class Tema {
protected String _nombre;
protected String _autor;
protected int _estilo;
public Tema(int estilo, int instrumento) {
int i = BaseDeTemas.elegirTemaAleatorio();
_nombre =
BaseDeTemas.nombreTema[estilo][instrumento][i];
_autor =
BaseDeTemas.nombreAutor[estilo][instrumento][i];
_estilo = estilo;
}
}

Abstract Factory
22
Ejemplo con Código
// Estos son los productos abstractos...
/*Representa un tema de guitarra. Desempeña el papel
de producto abstracto en la gramola (factoría
abstracta)*/
abstract class TemaGuitarra extends Tema implements
InstrumentoMusical {
public TemaGuitarra(int estilo) {
super(estilo, GUITARRA);
}
}
/** Representa un tema de piano. Desempeña el papel de
producto abstracto en la gramola (factoría
abstracta)*/
abstract class TemaPiano extends Tema implements
InstrumentoMusical {
public TemaPiano(int estilo) {
super(estilo, PIANO);
}
}
Abstract Factory
23
Ejemplo con Código
/**
* Representa un tema de viento.
* Desempeña el papel de producto abstracto
en la gramola (=factor´ıa abstracta)
*/
abstract class TemaViento extends Tema
implements InstrumentoMusical {
public TemaViento(int estilo) {
super(estilo, VIENTO);
}
}
Abstract Factory
24
Ejemplo con Código
/* Estos son los productos concretos... */
class TemaGuitarraFlamenco extends TemaGuitarra
implements EstiloMusical {
public TemaGuitarraFlamenco() {
super(FLAMENCO);
}
}
class TemaGuitarraJazzLatino extends TemaGuitarra
implements EstiloMusical{
public TemaGuitarraJazzLatino() {
super(JAZZ_LATINO);
}
}
Abstract Factory
25
Ejemplo con Código
class TemaPianoFlamenco extends TemaPiano
implements EstiloMusical {
public TemaPianoFlamenco() {
super(FLAMENCO);
}
}
class TemaPianoJazzLatino extends TemaPiano
implements EstiloMusical {
public TemaPianoJazzLatino() {
super(JAZZ_LATINO);
}
}
Abstract Factory
26
Ejemplo con Código
class TemaVientoFlamenco extends TemaViento
implements EstiloMusical {
public TemaVientoFlamenco() {
super(FLAMENCO);
}
}
class TemaVientoJazzLatino extends TemaViento
implements EstiloMusical {
public TemaVientoJazzLatino() {
super(JAZZ_LATINO);
}
}
Abstract Factory
27
Ejemplo con Código

Clase ListaReproduccion
/**Almacena listas de reproducción de varios
temas*/
class ListaReproduccion implements Cloneable {
java.util.List _lista;
/*Construye una lista de reproducción de varios
temas*/
public ListaReproduccion() {
_lista = new java.util.ArrayList();
}
Abstract Factory
28
Ejemplo con Código
/** Crea una lista de reproducción de varios
temas*/
public static ListaReproduccion
crearLista(Gramola gramola) {
ListaReproduccion lista = new
ListaReproduccion();
Tema t1 = gramola.crearTemaGuitarra();
Tema t2 = gramola.crearTemaPiano();
Tema t3 = gramola.crearTemaViento();
lista.aniadir(t1);
lista.aniadir(t2);
lista.aniadir(t3);
return lista;
}
Abstract Factory
}
29
Ejemplo con Código
Clase Gramola
/** Crea y reproduce listas de varios temas
musicales.Funciona como factoría abstracta de
temas (productos)*/

abstract class Gramola {
/** Reproductor asociado a esta gramola */
Reproductor _player;
/** Lista de reproducción cargada */
ListaReproduccion _lista;
/* otros atributos y métodos... */
public Gramola() {
_player = new Reproductor();
}
Abstract Factory
30
Ejemplo con Código
/** Método de factoría para crear temas de
guitarra */
public abstract TemaGuitarra
crearTemaGuitarra();
/** Método de factoría para crear temas de
piano */
public abstract TemaPiano crearTemaPiano();
/** Método de factoría para crear temas de
viento */
public abstract TemaViento
crearTemaViento();
}
Abstract Factory
31
Ejemplo con Código
Clase GramolaFlamenco
/**Fabrica temas musicales de estilo flamenco y
los reproduce. Desempeña el papel de factor´ıa
concreta de temas de flamenco*/
class GramolaFlamenco extends Gramola {
public TemaGuitarra crearTemaGuitarra() {
return new TemaGuitarraFlamenco();
}
public TemaPiano crearTemaPiano() {
return new TemaPianoFlamenco();
}
public TemaViento crearTemaViento() {
return new TemaVientoFlamenco();
}
}

Abstract Factory
32
Ejemplo con Código
Clase GramolaJazzLatino
/**Fabrica temas musicales de jazz latino y los
reproduce. Desempe~na el papel de factor´ıa
concreta de temas de jazz latino*/

class GramolaJazzLatino extends Gramola {
public TemaGuitarra crearTemaGuitarra() {
return new TemaGuitarraJazzLatino();
}
public TemaPiano crearTemaPiano() {
return new TemaPianoJazzLatino();
}
public TemaViento crearTemaViento() {
return new TemaVientoJazzLatino();
}
}
Abstract Factory
33
Relacionados (Notas)


Se pueden implementar con Factory
Method o Prototype
Las factorias concretas suelen ser
Singleton
Abstract Factory
34
Bibliografía

Design Patterns: Elements of
Reusable Object-Oriented Software
Autores: Gamma E., Helm R., Johnson R.,
Vlissides J.
Editorial: Addison-Wesley, 1995
Abstract Factory
35
Descargar

Abstract Factory