design patterns - qué - ¿Cuál es la diferencia básica entre los patrones de fábrica y de fábrica abstracta?
patron simple factory (20)
¿Cuál es la diferencia básica entre los patrones de fábrica y de fábrica abstracta?
Fuente para esta información tomada de: http://java.dzone.com/news/intro-design-patterns-abstract
Resumen de 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 Abstract Factory Pattern como 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 de fábrica crea objetos a través de la herencia donde Abstract Factory crea objetos a través de la composición.
El patrón Abstract Factory consta de un AbstractFactory, ConcreteFactory, AbstractProduct, ConcreteProduct y Client.
Como implementar
El Abstract Factory Pattern puede implementarse utilizando el Factory Method Pattern, Prototype Pattern o el Singleton Pattern. El objeto ConcreteFactory se puede implementar como Singleton ya que solo se necesita una instancia del objeto ConcreteFactory.
El patrón Método de fábrica es una versión simplificada del patrón de Fábrica abstracta. El patrón Factory Method es responsable de crear productos que pertenecen a una familia, mientras que el patrón Abstract Factory se ocupa de varias familias de productos.
Factory Method 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 las interfaces que desacoplan al cliente del generador y los productos.
Cuándo utilizar el patrón de método de fábrica
Utilice el patrón de Método de fábrica cuando sea necesario desacoplar un cliente de un producto en particular que utiliza. Utilice 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 de Abstract Factory cuando los clientes deben ser desacoplados de las clases de productos. Especialmente útil para la configuración y modificación de programas. 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:
Resumen de Fábrica Ejemplo 1
Esta especificación para los discos para preparar diferentes tipos de pasta en un fabricante de pasta es la Abstract Factory, y cada disco específico es una Factory. 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.
Resumen de ejemplo de fábrica 2:
El Equipo de estampado corresponde a Abstract Factory, ya que es una interfaz para operaciones que crean objetos de productos 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 piezas específicas (es decir, la puerta lateral 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 a ConcreteCreator.
El patrón abstracto de la fábrica
Proporcionar 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 Factory Method. 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 objetos 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 instancias 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 creacionales.
Los patrones creacionales abstraen el proceso de creación de instancias del objeto. Ocultan cómo se crean los objetos y ayudan a que el sistema en 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 va a instanciar. Método de fábrica
Los patrones de creación de objetos se centran en la delegación de la creación de instancias a otro objeto Abstract Factory
Referencia: Fábrica vs Fábrica abstracta
Abstract factory es una interfaz para crear objetos relacionados, pero el método de fábrica es un método. Resumen de fábrica se implementa por el método de fábrica.
Con el patrón Factory, produce instancias de implementaciones ( Apple , Banana , Cherry , etc.) de una interfaz en particular, por ejemplo, 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 ya sea un IFruitFactory o un IJuiceFactory , sin requerir que su almacén sepa nada sobre frutas o jugos.
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. Como él es consciente de mis estándares, es fácil para él hacerlo. Pero cuando a un hombre rico de la calle se le ocurren los mismos requisitos, recibe 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 recibe este chico rico.
Entonces, al observar el escenario anterior, ahora aprecio la eficiencia del encargado de la tienda. Puedo reemplazar a este comerciante 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 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 un poco menos UI egronomic. El último es mi tipo de usuario, un usuario de ''grupo libre''. Solo me han servido lo suficiente para no ofenderme. La interfaz de usuario es un mínimo, las publicidades están muy alejadas tanto que no sé lo que entra, por último, el menú solo tiene que cerrar sesión.
Si tuviera 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 en la tienda web
Concreate Factory: Experiencia de usuario Premium, Experiencia de usuario Gold, Experiencia de usuario general.
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 un 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 y creación del objeto.
Marque 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 utiliza una interfaz en lugar de una clase abstracta, el resultado será una implementación diferente del patrón de Abstract Factory.
:RE
Mis fuentes son: , tutorialspoint.com , programmers.stackexchange.com y CodeProject.com .
Factory Method (también llamado Factory ) es para desacoplar al cliente de una implementación de Interface . Para 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 el Type y la nueva implementación relacionada de la interfaz 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 de Color con dos implementaciones 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 devolver una clase concreta de una interfaz, pero Abstract Factory devolución de factory of factory Abstract Factory . En otras palabras, Abstract Factory devuelve una combinación diferente de una serie de interfaces.
Espero que mi explicación sea útil.
Muchas personas se sentirán sorprendidas tal vez, pero esta pregunta es incorrecta . Si escucha esta pregunta durante una entrevista, debe ayudar al entrevistador a comprender dónde está la confusión.
Empecemos por el hecho de que no hay un patrón concreto que se llame simplemente "Fábrica". Hay un patrón que se llama "Resumen de Fábrica", y hay un patrón que se llama "Método de Fábrica".
Entonces, ¿qué significa "fábrica" entonces? Una de las siguientes (todo puede considerarse correcto, según el alcance de la referencia):
- Algunas personas lo usan como un alias (acceso directo) 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, tanto "Fábrica abstracta" como "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ábricas 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 la razón.
-
PS : Factory for Products es AbstractFactory, y Factory for Abstract Factories también sería un ejemplo más de AbstractFactory.
Patrón de fábrica: La fábrica produce implementaciones de productos IP.
Patrón de fábrica abstracto: Una fábrica-fábrica produce IFactories, que a su vez produce IProducts :)
[Actualización según los comentarios]
Lo que escribí anteriormente no es correcto de acuerdo con 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, middleware-drivers, etc.
Por definición podemos arrastrar las diferencias de dos:
Fábrica: se utiliza 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.
Fábrica abstracta: El patrón Fábrica abstracta 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();
}
}
Tanto Factory Method como Abstract Factory mantienen a los clientes desconectados de los tipos concretos. Ambos crean objetos, pero el método Factory utiliza la herencia, mientras que Abstract Factory utiliza la composición.
Se Factory Methodhereda en las subclases para crear los objetos concretos (productos) mientras que la Abstract Factoryinterfaz 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 a Abstract Factorymenudo se implementan utilizando Factory Method.
Tengo algunos puntos para contribuir con la respuesta de John de la siguiente manera:
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 llamarse CitricFruitFactory .
Pero ahora desea crear otro tipo de fruta que CitricFruitFactory no puede crear. Tal vez el código de CitricFruitFactory no tendría sentido si creas una Strawberry (¡la fresa no es una fruta cítrica!).
Así que puedes crear una nueva fábrica llamada RedFruitFactory que produce Strawberry , Raspberry , etc.
Como dijo John Feminella: "Con el patrón de Abstract Factory, produce implementaciones de una interfaz de Factory en particular, por ejemplo, IFruitFactory . Cada uno de ellos sabe cómo crear diferentes tipos de fruta".
¡Las implementaciones de IFruitFactory son CitricFruitFactory y RedFruitFactory !
Un método de fábrica es un método no estático que devuelve una clase base o tipo de interfaz y se implementa en una jerarquía para permitir la creación polimórfica. Un método de fábrica debe ser definido / implementado por una clase y una o más subclases de la clase. La clase y las subclases actúan como Fábricas. Sin embargo, no decimos que un método de fábrica es una fábrica. Un Abstract Factory es una interfaz para crear familias de objetos relacionados o dependientes sin especificar sus clases concretas.
Las fábricas abstractas están diseñadas para ser sustituibles en tiempo de ejecución, por lo que un sistema puede configurarse para usar un implementador concreto y específico de una fábrica abstracta. Cada fábrica abstracta es una fábrica, aunque no todas las fábricas son una fábrica abstracta. Las clases que son fábricas, no fábricas abstractas, a veces evolucionan a fábricas abstractas cuando surge la necesidad de apoyar la creación de varias familias de objetos relacionados o dependientes.
Diferencia basica
Fábrica: 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 una instancia. El método Factory permite que una clase difiera la creación de instancias a las subclases.
Abstract Factory : proporciona una interfaz para crear familias de objetos relacionados o dependientes sin especificar sus clases concretas.
El patrón AbstractFactory usa la composición para delegar la responsabilidad de crear un objeto a otra clase, mientras que el patrón del método Factory utiliza la herencia y se basa en la clase derivada o la subclase para crear el objeto.
De los artículos de oodesign :
Diagrama de clase de Factory :
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 de implementación no estática de Factory está disponible en esta publicación:
Patrones de diseño: método de fábrica vs 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 de la 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.
Resumen diagrama de clase de fábrica de dzone
Cuándo usarlo: cuando su sistema tiene que crear varias familias de productos o desea proporcionar una biblioteca de productos sin exponer los detalles de la implementación.
Los ejemplos de código fuente en los artículos anteriores son muy buenos para entender los conceptos claramente.
Pregunta de SE relacionada con código de ejemplo:
Patrón de fábrica. ¿Cuándo usar los métodos de fábrica?
Diferencias:
- Las clases abstractas de fábrica a menudo se implementan con métodos de fábrica, pero también se pueden implementar utilizando prototipos
- Los diseños comienzan utilizando Factory Method (menos complicados, más personalizables, las subclases proliferan) y evolucionan hacia otros patrones creativos (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:
método_de fábrica de la fuente
abstract_factory desde sourcemaking
abstract-factory-design-pattern de journaldev
Extendiendo la respuesta de John Feminella:
Apple , Banana , Cherry implementa FruitFactory y tiene un método llamado Create que es el único responsable de crear Apple o Banana o Cherry. Has terminado, con tu método de Factory .
Ahora, quieres Create una ensalada especial con tus frutas y ahí viene tu Abstract Factory . 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.
}
}
Método de fábrica: tiene una fábrica que crea objetos que derivan de una clase base particular
Fábrica abstracta: Usted tiene una fábrica que crea otras fábricas , y estas fábricas a su vez crean objetos derivados de clases básicas. 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.
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 un simple constructor): 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 aplicación particular.
La segunda forma (usando el patrón Factory): le brinda el beneficio de que puede pasar cualquier tipo de implementación, lo que puede proporcionar un tipo diferente de algo en función de alguna condición (tal vez un parámetro pasado al método creativo).
La tercera forma (usando el patrón de 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 del 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.
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 que 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.
//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.
Así que aquí la 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. Like 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
Brinda instancia de implementación concreta.
En el ejemplo:
- createDough() - proporciona una implementación concreta para la masa. Así que este es un método de fábrica.
Fábrica abstracta
Proporciona 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 de Head First