Abstract Factory - Historial de revisiones

Carlos idict: Texto reemplazado: «Category:» por «Categoría:»

2019-08-21T13:08:03Z

Texto reemplazado: «Category:» por «Categoría:»

Humberto0601ad jc en 22:18 7 nov 2011

2011-11-07T22:18:33Z

Ariel.perez jc.cmg en 12:55 6 nov 2011

2011-11-06T12:55:51Z

Ariel.perez jc.cmg: Página creada con ''''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...'

2011-11-04T21:29:33Z

Página creada con ''''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...'

Página nueva

'''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.

== 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 ==
[[Archivo:Diagrama_Abstract_Factory.png]]

La estructura típica del patrón '''Abstract Factory''' es la siguiente:
* '''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:

<source lang=java>public abstract class Reloj {

abstract String dameLaHora();
}</source>

La clase que se da la hora en formato AM/PM:

<source lang=java>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;
}

}</source>

La que nos da la hora en formato de 24 horas:

<source lang=java>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;
}
}</source>

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:

<source lang=java>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;
}

}</source>

Y finalmente la clase cliente, que será la usuario final:

<source lang=java>public class MainClient {

public static void main(String[] args) {
Reloj r = RelojFactory.createReloj(RelojFactory.RELOJ_24_HRS);
System.out.println(r.dameLaHora());
}
}</source>

Hasta aquí tenemos dos fábricas: una de palabras, y la que acabamos de hacer que nos da la hora.

== Véase también ==
[[Factory Method (patrón de diseño)|Factory Method]]

== Enlaces externos ==

* [http://software.guisho.com/abstract-factory-pattern-patrones Abstract Factory Pattern – Patrones]

* [http://www.apwebco.com/gofpatterns/creational/AbstractFactory.html Ejemplo en Java con Diagrama UML]

== Fuentes ==

* [http://software.guisho.com/abstract-factory-pattern-patrones Abstract Factory Pattern – Patrones]

*[http://www.slideshare.net/dialheca/abstract-factory Abstract Factory - Presentation Transcript]

*[http://highscalability.wordpress.com/2010/03/08/patrones-de-diseno-introduccion-y-el-patron-abstract-factory/ Patrones de diseño: Introducción y el patrón Abstract Factory]

[[Category: Informática]]

← Revisión anterior		Revisión del 13:08 21 ago 2019
Línea 157:		Línea 157:
	*[http://highscalability.wordpress.com/2010/03/08/patrones-de-diseno-introduccion-y-el-patron-abstract-factory/ Patrones de diseño: Introducción y el patrón Abstract Factory]		*[http://highscalability.wordpress.com/2010/03/08/patrones-de-diseno-introduccion-y-el-patron-abstract-factory/ Patrones de diseño: Introducción y el patrón Abstract Factory]

−	[[~~Category~~: Informática]]	+	[[Categoría: Informática]]

← Revisión anterior		Revisión del 22:18 7 nov 2011
Línea 1:		Línea 1:
		+	{{Definición
		+	\|nombre=Abstract Factory
		+	\|imagen=
		+	\|tamaño=
		+	\|concepto=[[Patrón de diseño]] para el desarrollo de [[software]].
		+	}}
		+
	'''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		'''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.		dependientes entre ellos sin especificar una clase en concreto.

@@ Línea 12: / Línea 12: @@
 [[Archivo:Diagrama_Abstract_Factory.png]]
-La estructura típica del patrón '''Abstract Factory''' es la siguiente:
+== 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.
+* '''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.