¿Cuál es la diferencia básica entre los patrones de diseño de fábrica y de fábrica abstracta? [cerrado]
https://stackoverflow.com/questions/1001767
-
05-07-2019 - |
italiano
english
français
española
中国
日本の
العربية
Deutsch
한국어
Português
RussianPregunta
¿Cuál es la diferencia básica entre los patrones Factory y Abstract Factory?
Solución
Con el patrón de Factory, produce instancias de implementaciones ( Apple , Banana , Cherry , etc.) de una interfaz particular - diga, IFruit .
Con el patrón de Abstract Factory, usted proporciona una manera para que cualquiera pueda proporcionar su propia fábrica. Esto permite que su almacén sea un IFruitFactory o un IJuiceFactory , sin que sea necesario que su almacén sepa nada sobre frutas o jugos.
Otros consejos
Fuente de esta información tomada de: http://java.dzone.com / news / intro-design-patterns-abstract
Resumen Fábrica vs. Método de Fábrica
Los métodos de una Fábrica abstracta se implementan como Métodos de fábrica. Tanto el Abstract Factory Pattern como el Factory Method Pattern desacoplan el sistema del cliente de las clases de implementación reales a través de los tipos abstractos y las fábricas. El Método Factory crea objetos a través de la herencia, donde Abstract Factory crea objetos a través de la composición.
El patrón de Abstract Factory consta de un AbstractFactory, ConcreteFactory, AbstractProduct, ConcreteProduct and Client.
Cómo implementar
El patrón abstracto de fábrica se puede implementar utilizando el patrón de método de fábrica, el patrón de prototipo o el patrón de Singleton. El objeto ConcreteFactory se puede implementar como Singleton ya que solo se necesita una instancia del objeto ConcreteFactory.
El patrón de método de fábrica es una versión simplificada del patrón de Abstract Factory. El patrón Factory Method es responsable de crear productos que pertenecen a una familia, mientras que el patrón Abstract Factory trata con múltiples familias de productos.
El método de fábrica utiliza interfaces y clases abstractas para desacoplar al cliente de la clase generadora y los productos resultantes. Abstract Factory tiene un generador que es un contenedor para varios métodos de fábrica, junto con interfaces que desacoplan al cliente del generador y los productos.
Cuándo usar el patrón de método de fábrica
Use el patrón de método de fábrica cuando sea necesario desacoplar un cliente de un producto en particular que utiliza. Use el Método de fábrica para liberar a un cliente de la responsabilidad de crear y configurar instancias de un producto.
Cuándo usar el patrón abstracto de fábrica
Use el patrón Abstract Factory cuando los clientes deben estar desacoplados de las clases de productos. Especialmente útil para la configuración y modificación del programa. El patrón de Abstract Factory también puede imponer restricciones sobre qué clases deben usarse con otras. Puede ser mucho trabajo hacer nuevas fábricas de concreto.
Ejemplos:
Ejemplo de fábrica abstracta 1
Esta especificación para los discos para preparar diferentes tipos de pasta en un fabricante de pasta es la fábrica abstracta, y cada disco específico es una fábrica. todas las fábricas (discos de fabricación de pasta) heredan sus propiedades de la fábrica abstracta. Cada disco individual contiene la información de cómo crear la pasta, y el fabricante de la pasta no.
Ejemplo 2 de Abstract Factory:
El equipo de estampado corresponde a la fábrica abstracta, ya que es un Interfaz para operaciones que crean objetos de producto abstractos. Las matrices corresponden a la Fábrica de Concreto, ya que crean un producto concreto. Cada categoría de pieza (campana, puerta, etc.) corresponde al producto abstracto. Las partes específicas (es decir, la puerta del lado del conductor para 99 camry) corresponden a Los productos de hormigón.
Ejemplo de método de fábrica:
La compañía de juguetes corresponde al Creador, ya que puede usar la fábrica para crear objetos de productos. La división de la compañía de juguetes que fabrica un tipo específico de juguete (caballo o automóvil) corresponde al ConcreteCreator.
Patrón de fábrica: La fábrica produce IProduct-implementations
Patrón de fábrica abstracto: Una fábrica-fábrica produce IFactories, que a su vez produce productos de IP :)
[Actualizar según los comentarios]
Lo que escribí anteriormente no es correcto según Wikipedia al menos. Una fábrica abstracta es simplemente una interfaz de fábrica. Con él, puede cambiar sus fábricas en tiempo de ejecución, para permitir diferentes fábricas en diferentes contextos. Los ejemplos podrían ser fábricas diferentes para diferentes sistemas operativos, proveedores de SQL, controladores de middleware, etc.
El patrón abstracto de fábrica
-
Proporciona una interfaz para crear familias de familiares o dependientes objetos sin especificar su Clases concretas.
-
El patrón de Abstract Factory es muy similar al método de fábrica modelo. Una diferencia entre la Dos es que con el Abstract Factory. patrón, una clase delega responsabilidad del objeto instanciación a otro objeto a través de composición mientras que la fábrica Método patrón utiliza herencia y se basa en una subclase para manejar el instanciación de objeto deseada.
-
En realidad, el objeto delegado utiliza con frecuencia métodos de fábrica para ¡Realiza la instanciación!
Patrón de fábrica
-
Los patrones de fábrica son ejemplos de patrones creacionales
-
Los patrones de creación resumen el proceso de instanciación de objetos. Ellos Oculta cómo se crean los objetos y ayuda. hacer que el sistema general sea independiente de cómo se crean sus objetos y compuesto.
-
Los patrones de creación de clase se centran en el uso de la herencia para decidir el objeto a ser instanciado Método de fábrica
-
Los patrones de creación de objetos se centran en La delegación de la instanciación. a otro objeto Fábrica abstracta
Referencia: Factory vs Abstract Factory
Método de fábrica: tienes una fábrica que crea objetos que derivan de una clase base particular
Fábrica abstracta: tienes una fábrica que crea otras fábricas , y estas fábricas a su vez crean objetos derivados de las clases base. Lo hace porque a menudo no solo desea crear un solo objeto (como con el método Factory), sino que desea crear una colección de objetos relacionados.
Abstract factory es una interfaz para crear objetos relacionados, pero el método factory es un método. Resumen de fábrica se implementa por el método de fábrica.
Diferencia básica:
Factory: Crea objetos sin exponer la lógica de creación de instancias al cliente.
Método de fábrica : defina una interfaz para crear un objeto, pero deje que las subclases decidan qué clase crear. El método Factory permite que una clase difiera la creación de instancias en subclases
Abstract Factory : proporciona una interfaz para crear familias de objetos relacionados o dependientes sin especificar sus clases concretas.
El patrónAbstractFactory usa composición para delegar la responsabilidad de crear objetos a otra clase, mientras que el patrón Método de fábrica usa la herencia y se basa en la clase derivada o subclase para crear el objeto
De oodesign artículos:
Factory diagrama de clase:
Ejemplo: StaticFactory
public class ShapeFactory {
//use getShape method to get object of type shape
public static Shape getShape(String shapeType){
if(shapeType == null){
return null;
}
if(shapeType.equalsIgnoreCase("CIRCLE")){
return new Circle();
} else if(shapeType.equalsIgnoreCase("RECTANGLE")){
return new Rectangle();
} else if(shapeType.equalsIgnoreCase("SQUARE")){
return new Square();
}
return null;
}
}
El ejemplo de FactoryMethod que implementa Factory no estático está disponible en esta publicación:
Diseño Patrones: Método de fábrica vs Fábrica vs Fábrica abstracta
Cuándo usar: el cliente solo necesita una clase y no le importa qué implementación concreta está obteniendo.
Método de fábrica clase digaram:
Cuándo usar: El cliente no sabe qué clases concretas se requerirán para crear en tiempo de ejecución, pero solo quiere obtener una clase que haga el trabajo.
Abstract Factory diagrama de clase de dzone
Cuándo usar: cuándo su sistema tiene que crear varias familias de productos o si desea proporcionar una biblioteca de productos sin exponer los detalles de implementación.
Los ejemplos de código fuente en los artículos anteriores son muy buenos para comprender los conceptos claramente.
Pregunta SE relacionada con el ejemplo de código:
Patrón de fábrica. ¿Cuándo usar los métodos de fábrica?
Differences:
- Las clases abstractas de fábrica a menudo se implementan con métodos de fábrica, pero también pueden implementarse utilizando prototipos
- Los diseños comienzan usando el Método Factory (menos complicado, más personalizable, las subclases proliferan) y evolucionan hacia otros patrones de creación (más flexibles, más complejos) donde se necesita más flexibilidad.
- Los métodos de fábrica se suelen llamar dentro de los métodos de plantilla.
Otros artículos útiles:
factory_method de sourcemaking
abstract_factory de sourcemaking
abstract-factory-design-pattern de journaldev
Ejemplo / Escenario para Abstract Factory
Vivo en un lugar donde llueve en la estación lluviosa, nieva en invierno y caluroso y soleado en veranos. Necesito diferentes tipos de ropa para protegerme de los elementos. Para hacerlo, voy a la tienda cerca de mi casa y pido ropa / artículos para protegerme. El encargado de la tienda me da el artículo apropiado según el entorno y la profundidad de mi bolsillo. Los artículos que me da son del mismo nivel de calidad y rango de precios. Ya que él es consciente de mis estándares, es fácil para él hacerlo. Pero cuando un hombre rico de la calle tiene los mismos requisitos, obtiene un artículo caro y de marca. Una cosa notable es que todos los artículos que me da se complementan entre sí en términos de calidad, estándar y costo. Se puede decir que van juntos. Igual es el caso con los artículos que obtiene este rico.
Entonces, al observar el escenario anterior, ahora aprecio la eficiencia del encargado de la tienda. Puedo reemplazar a este tendero con una tienda abstracta. Los artículos que obtenemos con elementos abstractos y yo y los ricos como clientes en perspectiva. Todo lo que necesitamos es el producto / artículo que se adapte a nuestras necesidades.
Ahora puedo verme fácilmente considerando una tienda en línea que brinda un conjunto de servicios a sus numerosos clientes. Cada cliente pertenece a uno de los tres grupos. Cuando un usuario de un grupo premium abre el sitio, obtiene una gran interfaz de usuario, un panel de publicidad altamente personalizado, más opciones en los menús, etc. Este mismo conjunto de características se presenta al usuario de oro, pero la funcionalidad en el menú es menor, la mayoría de las publicidades son relevantes, y UI ligeramente menos egronómica. El último es mi tipo de usuario, un & # 8216; grupo libre & # 8217; usuario. Solo me han servido lo suficiente para no ofenderme. La interfaz de usuario es un mínimo, los anuncios están tan desviados que no sé qué viene, por último, el menú solo ha cerrado sesión.
Si tengo la oportunidad de crear algo como este sitio web, definitivamente consideraría Abstract Factory Pattern.
Productos abstractos: panel de anuncios, menú, pintor de interfaces de usuario.
Abstract Factory: experiencia de usuario de la tienda web
Concreate Factory: Experiencia de usuario Premium, Experiencia de usuario Gold, Experiencia de usuario general.
Quizás muchas personas se sorprendan, pero esta pregunta es incorrecta . Si escucha esta pregunta durante una entrevista, debe ayudar al entrevistador a comprender dónde está la confusión.
Comencemos por el hecho de que no hay un patrón concreto que se llame simplemente "Fábrica". Hay un patrón que se llama " Fábrica abstracta " ;, y hay un patrón que se llama " Método de fábrica " ;.
Entonces, ¿qué significa " Fábrica " significa entonces? uno de los siguientes (todos pueden considerarse correctos, dependiendo del alcance de la referencia):
- Algunas personas lo usan como un alias (acceso directo) para " Abstract Factory " ;.
- Algunas personas lo usan como alias (acceso directo) para " Método de fábrica " ;.
- Algunas personas lo usan como un nombre más general para todos los patrones de fábrica / creación. P.ej. ambos " Fábrica abstracta " y " Método de fábrica " son fábricas.
Y, desafortunadamente , muchas personas usan " Factory " para denotar otro tipo de fábrica, que crea fábrica o fábricas (o sus interfaces). Basado en su teoría:
El producto implementa IProduct, que es creado por Factory, que implementa IFactory, que es creado por AbstractFactory.
Para entender lo tonto que es esto, continuemos con nuestra ecuación:
AbstractFactory implementa IAbstractFactory, que es creado por ... AbstractAbstractFactory ???
Espero que veas el punto. No se confunda, y por favor no invente cosas que no existen por razones.
-
P.S. : Factory for Products es AbstractFactory, y Factory for Abstract Factories también sería otro ejemplo de AbstractFactory.
//Abstract factory - Provides interface to create factory of related products
interface PizzaIngredientsFactory{
public Dough createDough(); //Will return you family of Dough
public Clam createClam(); //Will return you family of Clam
public Sauce createSauce(); //Will return you family of Sauce
}
class NYPizzaIngredientsFactory implements PizzaIngredientsFactory{
@Override
public Dough createDough(){
//create the concrete dough instance that NY uses
return doughInstance;
}
//override other methods
}
Las definiciones de los libros de texto ya están proporcionadas por otras respuestas. Pensé que también daría un ejemplo de ello.
Entonces, aquí PizzaIngredientsFactory es una fábrica abstracta ya que proporciona métodos para crear una familia de productos relacionados.
Tenga en cuenta que cada método en la fábrica abstracta es un Método de fábrica en sí mismo. Al igual que createDough () es en sí mismo un método de fábrica cuyas implementaciones concretas serán proporcionadas por subclases como NYPizzaIngredientsFactory . Por lo tanto, usar esta ubicación diferente puede crear instancias de ingredientes concretos que pertenecen a su ubicación.
Método de fábrica
Proporciona instancia de implementación concreta
En el ejemplo:
- createDough () - proporciona una implementación concreta para la masa. Entonces este es un método de fábrica
Fábrica abstracta
Proporciona una interfaz para crear una familia de objetos relacionados
En el ejemplo:
- PizzaIngredientsFactory es una fábrica abstracta ya que permite crear un conjunto relacionado de objetos como Dough , Clams , Sauce . Para crear cada familia de objetos, proporciona un método de fábrica.
Ejemplo de Patrones de diseño Head First
Tengo algunos puntos para contribuir con la respuesta de John de la siguiente manera:
¡La fábrica abstracta es una fábrica de fábricas!
Con el " Método de fábrica " (porque solo "Fábrica" ??es ambiguo), produce implementaciones ( Lemon , Orange , etc.) de una interfaz particular, por ejemplo, IFruit . Esta fábrica podría denominarse CitricFruitFactory .
Pero ahora desea crear otro tipo de fruta que CitricFruitFactory no pueda crear. Tal vez el código de CitricFruitFactory no tendría sentido si creas una Strawberry (¡la fresa no es una fruta cítrica!).
Para poder crear una nueva Fábrica llamada RedFruitFactory que produce Strawberry , Raspberry , etc.
Como dijo John Feminella:
" Con el patrón Abstract Factory, usted produce implementaciones de una interfaz Factory en particular, por ejemplo, IFruitFactory . Cada uno de ellos sabe cómo crear diferentes tipos de fruta. & Quot;
¡Que las implementaciones de IFruitFactory son CitricFruitFactory y RedFruitFactory !
Mis fuentes son: StackOverflow , tutorialspoint.com , programmers.stackexchange.com y CodeProject.com .
Factory Method (también llamado Factory ) es para el cliente de desacoplamiento de una implementación de Interface . Para la muestra, tenemos una interfaz Shape con dos implementaciones Circle y Square . Hemos definido una clase de fábrica con un método de fábrica con un parámetro determinante como Type y una nueva implementación relacionada de la interfaz de Shape .
Abstract Factory contiene varios métodos de fábrica o una interfaz de fábrica por varias implementaciones de fábrica.
Para el siguiente ejemplo, tenemos una interfaz Color con dos implementaciones de Red y Yellow .
Hemos definido una interfaz ShapeColorFactory con dos RedCircleFactory y YellowSquareFactory . Siguiente código para explicar este concepto:
interface ShapeColorFactory
{
public Shape getShape();
public Color getColor();
}
class RedCircleFactory implements ShapeColorFactory
{
@Override
public Shape getShape() {
return new Circle();
}
@Override
public Color getColor() {
return new Red();
}
}
class YellowSquareFactory implements ShapeColorFactory
{
@Override
public Shape getShape() {
return new Square();
}
@Override
public Color getColor() {
return new Yellow();
}
}
Aquí la diferencia entre FactoryMethod y AbstractFactory . Factory Method como simplemente devuelve una clase concreta de una interfaz pero Abstract Factory devuelve factory of factory . En otras palabras, Abstract Factory devuelve una combinación diferente de una serie de interfaces.
Espero que mi explicación sea útil.
La principal diferencia en esas fábricas es cuando lo que quieres hacer con las fábricas y cuando quieres usarlo.
A veces, cuando está haciendo IOC (inversión de control, por ejemplo, inyección de constructor), sabe que puede crear objetos sólidos. Como se mencionó en el ejemplo anterior de frutas, si está listo para crear objetos de frutas, puede usar el patrón de fábrica simple .
Pero muchas veces, no desea crear objetos sólidos, aparecerán más adelante en el flujo del programa. Pero la configuración le indica qué tipo de fábrica desea utilizar al inicio, en lugar de crear objetos, puede pasar las fábricas derivadas de una clase de fábrica común al constructor en IOC.
Entonces, creo que también se trata de la vida útil y la creación del objeto.
Tanto Factory Method como Abstract Factory mantienen a los clientes desconectados de los tipos concretos. Ambos crean objetos, pero el método Factory usa la herencia, mientras que Abstract Factory usa la composición.
El Factory Method se hereda en las subclases para crear los objetos concretos (productos), mientras que Abstract Factory proporciona una interfaz para crear la familia de productos relacionados y la subclase de esta interfaz define Cómo crear productos relacionados.
Luego, estas subclases cuando se crean instancias se pasan a clases de productos donde se usan como tipo abstracto. Los productos relacionados en un Abstract Factory a menudo se implementan usando Factory Method .
Extendiendo la respuesta de John Feminella:
Apple , Banana , Cherry implementa FruitFactory y tiene un método llamado Crear que es el único responsable de crear Apple o Banana o Cherry. Ya ha terminado, con su método Factory .
Ahora, quiere Crear una ensalada especial de sus frutas y ahí viene su Fábrica de abstractos . Abstract Factory sabe cómo crear su ensalada especial con Apple, Banana y Cherry.
public class Apple implements Fruit, FruitFactory {
public Fruit Create() {
// Apple creation logic goes here
}
}
public class Banana implements Fruit, FruitFactory {
public Fruit Create() {
// Banana creation logic goes here
}
}
public class Cherry implements Fruit, FruitFactory {
public Fruit Create() {
// Cherry creation logic goes here
}
}
public class SpecialSalad implements Salad, SaladFactory {
public static Salad Create(FruitFactory[] fruits) {
// loop through the factory and create the fruits.
// then you're ready to cut and slice your fruits
// to create your special salad.
}
}
Por definición, podemos arrastrar las diferencias de dos:
Fábrica: se usa una interfaz para crear un objeto, pero la subclase decide qué clase crear una instancia. La creación del objeto se realiza cuando es necesario.
Abstract Factory: el patrón Abstract Factory actúa como una superfábrica que crea otras fábricas. En el patrón de Abstract Factory, una interfaz es responsable de crear un conjunto de objetos relacionados u objetos dependientes sin especificar sus clases concretas.
Entonces, en las definiciones anteriores, podemos enfatizar una diferencia particular. es decir, Factory Pattern es responsable de crear objetos y Abstract Factory es responsable de crear un conjunto de objetos relacionados; obviamente ambos a través de una interfaz.
Patrón de fábrica:
public interface IFactory{
void VehicleType(string n);
}
public class Scooter : IFactory{
public void VehicleType(string n){
Console.WriteLine("Vehicle type: " + n);
}
}
public class Bike : IFactory{
public void VehicleType(string n) {
Console.WriteLine("Vehicle type: " + n);
}
}
public interface IVehicleFactory{
IFactory GetVehicleType(string Vehicle);
}
public class ConcreteVehicleFactory : IVehicleFactory{
public IFactory GetVehicleType(string Vehicle){
switch (Vehicle){
case "Scooter":
return new Scooter();
case "Bike":
return new Bike();
default:
return new Scooter();
}
}
class Program{
static void Main(string[] args){
IVehicleFactory factory = new ConcreteVehicleFactory();
IFactory scooter = factory.GetVehicleType("Scooter");
scooter.VehicleType("Scooter");
IFactory bike = factory.GetVehicleType("Bike");
bike.VehicleType("Bike");
Console.ReadKey();
}
}
Patrón abstracto de fábrica:
interface IVehicleFactory{
IBike GetBike();
IScooter GetScooter();
}
class HondaFactory : IVehicleFactory{
public IBike GetBike(){
return new FZS();
}
public IScooter GetScooter(){
return new FZscooter();
}
}
class HeroFactory: IVehicleFactory{
public IBike GetBike(){
return new Pulsur();
}
public IScooter GetScooter(){
return new PulsurScooter();
}
}
interface IBike
{
string Name();
}
interface IScooter
{
string Name();
}
class FZS:IBike{
public string Name(){
return "FZS";
}
}
class Pulsur:IBike{
public string Name(){
return "Pulsur";
}
}
class FZscooter:IScooter {
public string Name(){
return "FZscooter";
}
}
class PulsurScooter:IScooter{
public string Name(){
return "PulsurScooter";
}
}
enum MANUFACTURERS
{
HONDA,
HERO
}
class VehicleTypeCheck{
IBike bike;
IScooter scooter;
IVehicleFactory factory;
MANUFACTURERS manu;
public VehicleTypeCheck(MANUFACTURERS m){
manu = m;
}
public void CheckProducts()
{
switch (manu){
case MANUFACTURERS.HONDA:
factory = new HondaFactory();
break;
case MANUFACTURERS.HERO:
factory = new HeroFactory();
break;
}
Console.WriteLine("Bike: " + factory.GetBike().Name() + "\nScooter: " + factory.GetScooter().Name());
}
}
class Program
{
static void Main(string[] args)
{
VehicleTypeCheck chk = new VehicleTypeCheck(MANUFACTURERS.HONDA);
chk.CheckProducts();
chk= new VehicleTypeCheck(MANUFACTURERS.HERO);
chk.CheckProducts();
Console.Read();
}
}
Abstract Factory es una plantilla para crear diferentes tipos de interfaces. Supongamos que tiene un proyecto que requiere que analice diferentes tipos de archivos csv que contienen información específica sobre cantidad, precio y artículo, como algunos contienen información sobre otras frutas sobre chocolates y luego, después de analizar, necesita actualizar esta información en su base de datos correspondiente para que ahora pueda tener Una fábrica abstracta le devuelve el analizador y la fábrica de modificadores y, a continuación, esta fábrica de analizadores puede devolverle el objeto del analizador de chocolate, el objeto del analizador de frutas, etc. y, de manera similar, la fábrica de modificadores puede devolver el objeto del modificador de chocolate, el objeto del modificador de frutas, etc.
Creo que podemos entender la diferencia entre estos dos al ver un código de ejemplo de Java8:
interface Something{}
interface OneWhoCanProvideSomething {
Something getSomething();
}
interface OneWhoCanProvideCreatorsOfSomething{
OneWhoCanProvideSomething getCreator();
}
public class AbstractFactoryExample {
public static void main(String[] args) {
//I need something
//Let's create one
Something something = new Something() {};
//Or ask someone (FACTORY pattern)
OneWhoCanProvideSomething oneWhoCanProvideSomethingOfTypeA = () -> null;
OneWhoCanProvideSomething oneWhoCanProvideSomethingOfTypeB = () -> null;
//Or ask someone who knows soemone who can create something (ABSTRACT FACTORY pattern)
OneWhoCanProvideCreatorsOfSomething oneWhoCanProvideCreatorsOfSomething = () -> null;
//Same thing, but you don't need to write you own interfaces
Supplier<Something> supplierOfSomething = () -> null;
Supplier<Supplier<Something>> supplierOfSupplier = () -> null;
}
}
Ahora la pregunta es qué forma de creación debe usar y por qué: La primera forma (sin patrón, solo constructor simple): crear por sí mismo no es una buena idea, tiene que hacer todo el trabajo y su código de cliente está vinculado a la implementación en particular.
La segunda forma (usando el patrón Factory): le brinda el beneficio de que puede pasar cualquier tipo de implementación, que puede proporcionar diferentes tipos de algo en función de alguna condición (tal vez un parámetro pasado al método de creación).
La tercera forma (usando el patrón Abstract Factory): esto le da más flexibilidad. Puede encontrar diferentes tipos de creadores de algo en función de alguna condición (tal vez un parámetro pasado).
Tenga en cuenta que siempre puede salirse con la suya con el patrón Factory combinando dos condiciones (lo que aumenta ligeramente la complejidad del código y el acoplamiento), supongo que es por eso que rara vez vemos casos de uso en la vida real del patrón Abstract Factory .
