¿Cuál es la diferencia básica entre los patrones de diseño Factory y Abstract Factory? [cerrado]

483

¿Cuál es la diferencia básica entre los patrones Factory y Abstract Factory?

usuario366312
fuente
11
En mi opinión, la calidad de las respuestas en Diferencias entre el patrón abstracto de la fábrica y el método de la fábrica son mucho mejores que las de aquí.
KurzedMetal
1
La diferencia clave es que Factory Method usa la herencia (la indirección es vertical, por ejemplo createThing()) y Abstract Factory usa la composición (la indirección es horizontal, por ejemplo getFactory().createThing())
David James
1
Esta pregunta no es lo que algunos de sus respondedores piensan que es. No se pierda la respuesta de Tengiz , que define los tres términos distintos Factory, Abstract Factory y Factory Method.
Dave Schweisguth

Respuestas:

412

Con el patrón de la fábrica, que produce casos de implementaciones ( Apple, Banana, Cherry, etc.) de una interfaz en particular - por ejemplo, IFruit.

Con el patrón Abstract Factory, proporciona una manera para que cualquiera pueda proporcionar su propia fábrica. Esto permite que su almacén sea una IFruitFactoryo una IJuiceFactory, sin requerir que su almacén sepa nada sobre frutas o jugos.

John Feminella
fuente
55
@ SPI Creo que me malinterpretas; la Fábrica en sí misma no necesita implementarse IFruit: crea instancias de cosas que implementan IFruit. Por supuesto, no necesita producir instancias de cosas que implementen una interfaz particular, pero probablemente sea un olor a código si tiene una Fábrica que produce cosas que no están relacionadas entre sí.
John Feminella
75
Fábrica que produce fábricas. Tenemos que ir más profundo ...
Paul Annekov
11
Nunca he oído hablar de algo más incorrecto que esto. ¿Cómo llamarías a una fábrica que produce interfaces de fábricas abstractas (IAbstractFactory)? - Ah, ya veo, eso sería AbstractAbstractFactory ...
Tengiz
3
@joaquin Por ejemplo, cuando necesita tener una fábrica de IFruitFactory. Y como ya mencioné, esto es completamente incorrecto, y es solo el resultado de la confusión sobre los patrones. Mi respuesta a continuación aclara: existe el patrón Abstract Factory, luego está el patrón Factory Method, y luego hay personas confundidas que piensan que Abstract Factory significa fábrica de otras fábricas. Fábrica es solo un término genérico utilizado para denotar cualquiera de los patrones existentes. Vea mi respuesta a continuación para obtener más detalles si es necesario.
Tengiz
99
¡Esta respuesta es simplemente incorrecta! De acuerdo con este libro de GoF , una fábrica abstracta es un objeto de fábrica que implementa una interfaz de fábrica, de modo que la fábrica de concreto puede intercambiarse por otra subclase. No tiene nada que ver con la creación de fábricas. Elimine esta respuesta, ¡es engañosa y confusa para las personas!
Lii
142

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 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 fábrica abstracta consta de una fábrica abstracta, una fábrica concreta, un producto abstracto, un producto concreto y un cliente.

Cómo implementar

El patrón de fábrica abstracto 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 Factory Method es una versión simplificada del patrón 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.

Factory Method utiliza interfaces y clases abstractas para desacoplar el 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 del método de fábrica

Use el patrón 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 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:

Resumen Fábrica Ejemplo 1

Esta especificación para los discos para preparar diferentes tipos de pasta en una máquina para hacer pasta es Abstract Factory, y cada disco específico es Factory. Todas las fábricas (discos 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.

Resumen Fábrica Ejemplo 2:

El equipo de estampado corresponde a Abstract Factory, ya que es una interfaz para operaciones que crean objetos abstractos de productos. Los troqueles corresponden a la fábrica de hormigón, ya que crean un producto de hormigón. 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 concreto.

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.

Sudhakar Kalmari
fuente
66
Gracias por explicar Abstract Factory y Factory Method. No entendí dónde usamos la composición en fábrica abstracta para la creación de objetos y dónde usamos la herencia en el método de fábrica. Será muy útil si publicas un código para explicar esto. Muchas gracias. esperando tu código Gracias de nuevo.
Harsha
lo mismo aquí, sería mucho más claro si los enfoques de composición y herencia se muestran con un breve ejemplo (código fuente).
Aakash
Código de ejemplo @ sourcemaking.com/design_patterns/abstract_factory
pramodc84
ejemplo de composición: cliente de clase pública {Producto de AbstractProduct; ResumenProductoAccesorios accesorios; Cliente público (fábrica AbstractFactory) {Producto AbstractProduct = factory.createProduct (); } public void run () {product.print (); accesorios = product.getAccessories (); }}
Asim Ghaffar
¿Es posible detectar en el código cuál de estos dos patrones se utilizó?
Brujo
98

Patrón de fábrica: la fábrica produce implementaciones de IProduct

Abstract Factory Pattern: una fábrica-fábrica produce IFactories, que a su vez produce IProducts :)

[Actualización según los comentarios]
Lo que escribí antes 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 diferentes fábricas para diferentes sistemas operativos, proveedores de SQL, controladores de middleware, etc.

cwap
fuente
44
¡Agradable! ¿Es correcto decir que Abstract Factory es un conjunto de métodos de fábrica?
Brujo
2
Supongo que sería correcto, pero también perdería el punto :) Un ejemplo no análogo podría ser un FileFactory que tuviera métodos como CreateBitmapFile () o CreateTextFile (). Ahora, pasará una referencia a esa fábrica en algún tipo de servicio. Pero, ¿qué pasaría una vez que quiera probar su servicio? Tendría que crear una interfaz IFileFactory para burlarse del acceso al sistema de archivos. Ahora, en el mundo real, probablemente tendría un marco DI / IoC que instanciaría IFileFactories según sus necesidades. En este caso, el marco de IoC serviría como la fábrica abstracta.
cwap
55
Si lo entiendo correctamente, esta respuesta parece implicar que Abstract Factory siempre produce más IFactories, que a su vez se pueden usar para crear IProducts. La presentación en el GoF no me parece que respalde esto, y de hecho lo contradice: una instancia de una Fábrica abstracta produce directamente los propios productos IP. En otras palabras, una Fábrica abstracta de GoF no es (o más bien, no necesita ser ) una "fábrica-fábrica".
SSJ_GZ
1
La definición del patrón abstracto de fábrica es incorrecta. Una fábrica abstracta contiene uno o más métodos de fábrica, cada uno de los cuales produce una instancia de la misma familia de objetos (que no debe confundirse con la jerarquía de objetos). Si bien una fábrica abstracta puede ser una fábrica de fábricas, no tiene por qué ser una. Es un productor de productos relacionados.
GiddyUpHorsey
1
¡Esta respuesta es simplemente incorrecta! De acuerdo con este libro de GoF , una fábrica abstracta es un objeto de fábrica que implementa una interfaz de fábrica, de modo que la fábrica de concreto puede cambiarse por otra subclase. No tiene nada que ver con la creación de fábricas. Elimine esta respuesta, ¡es engañosa y confusa para las personas!
Lii
42

El patrón abstracto de fábrica

  • Proporcione una interfaz para crear familias de objetos relacionados o dependientes sin especificar sus clases concretas.

  • El patrón Abstract Factory es muy similar al patrón Método Factory. Una diferencia entre los dos es que con el patrón Abstract Factory, una clase delega la responsabilidad de la creación de instancias de objeto a otro objeto a través de la composición, mientras que el patrón Factory Method utiliza la herencia y se basa en una subclase para manejar la creación de objetos deseada.

  • En realidad, el objeto delegado con frecuencia utiliza métodos de fábrica para realizar la creación de instancias.

Patrón de fábrica

  • Los patrones de fábrica son ejemplos de patrones de creación.

  • Los patrones de creación abstraen el proceso de instanciación de objetos. Ocultan cómo se crean los objetos y ayudan a que el sistema general sea independiente de cómo se crean y componen sus objetos.

  • Los patrones de creación de clase se centran en el uso de la herencia para decidir el objeto que se instanciará 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 Abstract Factory

Referencia: Factory vs Abstract Factory

Syed Tayyab Ali
fuente
3
enlace de referencia está muerto
mkobit
39

Método de fábrica: tiene una fábrica que crea objetos que derivan de una clase base particular

Fábrica abstracta: tiene una fábrica que crea otras fábricas , y estas fábricas a su vez crean objetos derivados de clases base. Hace esto 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.

Craig Schwarze
fuente
66
Este es un duplicado de la respuesta aceptada, y es igualmente incorrecto.
jaco0646
36

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.

ingrese la descripción de la imagen aquí

Molesto
fuente
36

Diferencia básica:

Fábrica: Crea objetos sin exponer la lógica de instanciación al cliente.

Método de fábrica : defina una interfaz para crear un objeto, pero deje que las subclases decidan qué clase instanciar. 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ón AbstractFactory utiliza la composición para delegar la responsabilidad de crear objetos a otra clase mientras que el método Factory patrón del utiliza la herencia y se basa en la clase derivada o subclase para crear objetos

De los artículos de diseño :

Diagrama de clases de fábrica :

ingrese la descripción de la imagen aquí

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:

Patrones de diseño: Fábrica vs Método de fábrica vs Fábrica abstracta

Cuándo usarlo: el cliente solo necesita una clase y no le importa qué implementación concreta esté obteniendo.

Método de fábrica clase digaram:

ingrese la descripción de la imagen aquí

Cuándo usarlo: 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.

Diagrama de clase de Abstract Factory de dzone

ingrese la descripción de la imagen aquí

Cuándo usarlo: cuando su sistema tiene que crear múltiples 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?

Diferencias:

  1. Las clases de Abstract Factory a menudo se implementan con los Métodos de Factory, pero también se pueden implementar usando Prototype
  2. Los diseños comienzan usando el Método Factory (menos complicado, más personalizable, proliferan las subclases) y evolucionan hacia otros patrones de creación (más flexibles, más complejos) donde se necesita más flexibilidad.
  3. Los métodos de fábrica generalmente se llaman 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

Ravindra babu
fuente
21

Ejemplo / escenario para la fábrica abstracta

Vivo en un lugar donde llueve en la estación lluviosa, nieva en invierno y caluroso y soleado en verano. 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. Como conoce mis estándares, es fácil para él hacerlo. Pero cuando un hombre rico de la calle cruza con 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 mirar 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 artículos 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 ofrece un conjunto de servicios a sus numerosos clientes. Cada cliente pertenece a uno de los tres grupos. Cuando un usuario de grupo premium abre el sitio, obtiene una excelente 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, los anuncios son en su mayoría relevantes, y UI ligeramente menos egronómica. El último es mi tipo de usuario, un usuario de 'grupo libre'. Me acaban de servir lo suficiente para no ofenderme. La interfaz de usuario es un mínimo, los anuncios están tan desviados que no sé lo que viene, por último, el menú solo ha cerrado la sesión.

Si tengo la oportunidad de construir algo como este sitio web, definitivamente consideraría Abstract Factory Pattern.

Productos abstractos: panel publicitario, menú, pintor de interfaz 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.

moajiz
fuente
Escenarios agradables de AbstractFactory pero realmente no respondiste la pregunta, ¿cuáles son las diferencias entre fábrica y fábrica abstracta?
Adelin
20

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"? uno de los siguientes (todos pueden considerarse correctos, dependiendo del alcance de la referencia):

  • Algunas personas lo usan como un alias (atajo) para " Abstract Factory ".
  • Algunas personas lo usan como un 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. Por ejemplo, "Fábrica abstracta" y "Método de fábrica" ​​son fábricas.

Y, desafortunadamente , muchas personas usan "Fábrica" ​​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, creado por Factory, que implementa IFactory, 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.

-

PD : Factory for Products es AbstractFactory, y Factory for Abstract Factories también sería otro ejemplo de AbstractFactory.

Tengiz
fuente
¿Cómo podría diferenciar AbstractFactory que crea otras AbstractFactories, de AbstractFactory que crea objetos específicos? GenericAbstractFactory? O AbstractFactoryFactory?
Andrew
No existe tal cosa en los patrones de diseño. Ambos son instancias del patrón AbstractFactory. Entonces, un AbstractFactory crea objetos específicos, y otro AbstractFactory crea fábricas (que son AbstractFactory nuevamente).
Tengiz
Por supuesto. Entonces, ¿cómo nombro estas clases, que hacen cosas diferentes? Porque crear otras fábricas y crear otros objetos (simples) son dos cosas diferentes. No me importan los patrones, necesito un código legible.
Andrew
3
El código legible es la intención de revelar el código. Al nombrar clases, no debe mencionar demasiados patrones, a menos que sea muy necesario. por ejemplo, si tiene una fábrica abstracta que crea diferentes transportes, puede llamarla TransportCreator o TransportFactory, o tal vez incluso TransportMan Manufacturer. Y luego, si tiene fábrica de estas fábricas, puede llamarlo como quiera que sea: quien abra nuevos fabricantes. Tal vez eso puede ser FabricanteManagement? básicamente, nombra las cosas como las llama tu negocio, y NO en función de los patrones que implementan.
Tengiz
16
//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 las proporcionan otras respuestas. Pensé que también daría un ejemplo de ello.

Así que aquí PizzaIngredientsFactoryhay 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 Abstract es un método Factory en sí mismo. Like createDough()es en sí mismo un método de fábrica cuyas implementaciones concretas serán proporcionadas por subclases like NYPizzaIngredientsFactory. Entonces, al usar esto, cada ubicación diferente puede crear instancias de ingredientes concretos que pertenecen a su ubicación.

Método de la fábrica

Proporciona una 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:
- PizzaIngredientsFactoryes 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 de Head First

Narendra Pathai
fuente
5

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 sólo "de fábrica" es ambiguo), se produce implementaciones ( Lemon, Orange, etc.) de una interfaz en particular - por ejemplo, IFruit. Esta fábrica podría llamarse CitricFruitFactory.

Pero ahora desea crear otro tipo de fruta que CitricFruitFactory no pueda crear. Tal vez el código de CitricFruitFactoryno tenga sentido si crea un contenido Strawberry(¡la fresa no es una fruta cítrica!).

Por lo que podría crear una nueva fábrica llamada RedFruitFactoryque produce Strawberry, Raspberryetc.

Como dijo John Feminella: "Con el patrón Abstract Factory, se producen implementaciones de una interfaz de Factory en particular, por ejemplo, IFruitFactorycada uno de ellos sabe cómo crear diferentes tipos de fruta".

Que implementaciones de IFruitFactoryson CitricFruitFactoryy RedFruitFactory!

fabriciorissetto
fuente
4

Mis fuentes son: StackOverflow, tutorialspoint.com, programmers.stackexchange.comyCodeProject.com .


Factory Method(también llamado Factory) es para desacoplar el cliente de una Interfaceimplementación. Para muestra tenemos una Shapeinterfaz con dos Circlee Squareimplementaciones. Hemos definido una clase de fábrica con un método de fábrica con un parámetro determinante como una Typenueva implementación relacionada de la Shapeinterfaz.


Abstract Factorycontiene varios métodos de fábrica o una interfaz de fábrica mediante varias implementaciones de fábrica. Para el siguiente ejemplo anterior tenemos una Colorinterfaz con dos Rede Yellowimplementaciones. Hemos definido una ShapeColorFactoryinterfaz con dos RedCircleFactoryy YellowSquareFactory. El 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 FactoryMethody AbstractFactory. Factory Methodcomo simplemente devolver una clase concreta de una interfaz pero Abstract Factorydevolver factory of factory. En otras palabras, Abstract Factorydevuelve una combinación diferente de una serie de interfaces.


Espero que mi explicación sea útil.

Sam
fuente
3

La principal diferencia en esas fábricas es cuándo lo que quiere hacer con las fábricas y cuándo quiere 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 un patrón de fábrica simple .

Pero muchas veces, no desea crear objetos sólidos, vendrán más adelante en el flujo del programa. Pero la configuración le dice qué tipo de fábrica desea usar 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 y la creación del objeto.

Mahendra Vengurlekar
fuente
3

Ambos Factory Methody Abstract Factorymantienen a los clientes desacoplados de los tipos concretos. Ambos crean objetos, pero el Factorymétodo usa herencia mientras queAbstract Factory usa la composición.

El Factory Methodse hereda en subclases para crear objetos concretos (productos) mientras queAbstract Factory proporciona una interfaz para crear la familia de productos relacionados y la subclase de estas interfaces define cómo crear productos relacionados.

Luego, estas subclases cuando se instancian se pasan a clases de productos donde se usan como tipo abstracto. Los productos relacionados en un a Abstract Factorymenudo se implementan utilizando Factory Method.

Akash Aggarwal
fuente
3

Ampliando la respuesta de John Feminella:

Apple, Banana, CherryImplementos FruitFactoryy que tiene un método llamado Createque es el único responsable de la creación de manzana o un plátano o cereza. Ya terminaste, con tu Factorymétodo.

Ahora, desea Createuna ensalada especial de sus frutas y ahí viene su Fábrica abstracta . Abstract Factory sabe cómo crear tu ensalada especial a partir de manzana, plátano y cereza.

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.
    }
}
Abdul Munim
fuente
2

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 instanciar. 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 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, el patrón Factory 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();
        }
    }
Rashedul.Rubel
fuente
1

Consulte aquí: http://www.allapplabs.com/java_design_patterns/abstract_factory_pattern.htm parece que el método Factory usa una clase particular (no abstracta) como clase base, mientras que Abstract factory usa una clase abstracta para esto. Además, si usa una interfaz en lugar de una clase abstracta, el resultado será una implementación diferente del patrón Abstract Factory.

:RE

hackus
fuente
1

Abstract Factory es una plantilla para crear diferentes tipos de interfaces. Suponga que tiene un proyecto que requiere que analice diferentes tipos de archivos csv que contienen información específica de cantidad, precio y artículo, como algunos contienen datos sobre frutas y otros 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 que le devuelve la fábrica de analizador y modificador y luego esta fábrica de analizador puede devolverle el objeto analizador de Chocolate, el Objeto Analizador de Frutas, etc. y, de manera similar, la Fábrica Modificadora puede devolver el objeto modificador de Chocolate, el objeto Modificador de Frutas, etc.

Kapil
fuente
1

Creo que podemos entender la diferencia entre estos dos al ver un código de ejemplo 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 debería 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 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 un tipo diferente de algo basado en 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 brinda 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 juntas (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.

Satyendra Kumar
fuente