Abstract Factory

Diseño y Aplicaciones

Patricia Cano Fernández

Rocío González García

Irene Zamora del Río

Abstract Factory 2

Í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 3

¿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 4

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 5

EjemploEjemplo 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 6

Ejemplo

Abstract Factory 7

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 deScrollbar *sb = new MotifScrollBar();

Usar:Scrollbar *sb = WidgetFactory->CreateScrollBar();

WidgetFactory será una instancia de MotifWidgetFactory

Abstract Factory 8

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 9

Estructura

Abstract Factory 10

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 11

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 12

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 13

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 14

Detalles de Implementación Factorias como singletons

Sólo una instancia de ConcreteFactory por familia de productos.

Definir factorías extensibles 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 15

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 16

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 GramolaJazz-Latino), 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 17

Ejemplo con Código

Abstract Factory 18

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 19

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 20

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 21

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 22

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 23

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 24

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 25

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 26

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 27

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 28

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 29

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 30

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 31

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 32

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 33

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 34

Relacionados (Notas)

Se pueden implementar con Factory Method o Prototype

Las factorias concretas suelen ser Singleton

Abstract Factory 35

Bibliografía

Design Patterns: Elements of Reusable Object-Oriented Software Autores: Gamma E., Helm R., Johnson R.,

Vlissides J.Editorial: Addison-Wesley, 1995