Abstract Factory Diseño y Aplicaciones Patricia Cano Fernández Rocío González García Irene Zamora del Río.

Presentación del tema: "Abstract Factory Diseño y Aplicaciones Patricia Cano Fernández Rocío González García Irene Zamora del Río."— Transcripción de la presentación:

1 Abstract Factory Diseño y Aplicaciones Patricia Cano Fernández Rocío González García Irene Zamora del Río

2 Abstract Factory2 Í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

3 Abstract Factory3 ¿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.

4 Abstract Factory4 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.

5 Abstract Factory5 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.

6 Abstract Factory6 Ejemplo

7 Abstract Factory7 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

8 Abstract Factory8 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).

9 Abstract Factory9 Estructura

10 Abstract Factory10 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.

11 Abstract Factory11 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.

12 Abstract Factory12 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.

13 Abstract Factory13 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.

14 Abstract Factory14 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.

15 Abstract Factory15 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

16 Abstract Factory16 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.

17 Abstract Factory17 Ejemplo con Código

18 Abstract Factory18 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 */ }

19 Abstract Factory19 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; }

20 Abstract Factory20 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" }}}

21 Abstract Factory21 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); }

22 Abstract Factory22 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; }

23 Abstract Factory23 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); }

24 Abstract Factory24 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); }

25 Abstract Factory25 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); }

26 Abstract Factory26 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); }

27 Abstract Factory27 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); }

28 Abstract Factory28 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(); }

29 Abstract Factory29 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; }

30 Abstract Factory30 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(); }

31 Abstract Factory31 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(); }

32 Abstract Factory32 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(); }

33 Abstract Factory33 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(); }

34 Abstract Factory34 Relacionados (Notas)  Se pueden implementar con Factory Method o Prototype  Las factorias concretas suelen ser Singleton

35 Abstract Factory35 Bibliografía  Design Patterns: Elements of Reusable Object-Oriented Software Autores: Gamma E., Helm R., Johnson R., Vlissides J. Editorial: Addison-Wesley, 1995