Fuente para esta información tomada de: http://java.dzone.com/news/intro-design-patterns-abstract

Fábrica abstracta vs. Método de Fábrica

Los métodos de una Fábrica Abstracta se implementan como Métodos de Fábrica. Tanto el Patrón de Fábrica Abstracto como el Patrón de Método de Fábrica 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 consiste en un AbstractFactory, ConcreteFactory, AbstractProduct, ConcreteProduct y Client.

Cómo implementar

El Patrón de Fábrica Abstracto se puede implementar utilizando el Patrón de Método de Fábrica, Patrón de Prototipo o el Patrón de Singleton. El objeto ConcreteFactory se puede implementar como un Singleton ya que solo se necesita una instancia del objeto ConcreteFactory.

Fábrica El patrón de método es una versión simplificada del patrón abstracto de fábrica. El patrón de método de fábrica es responsable de crear productos que pertenecen a una familia, mientras que el patrón de fábrica abstracto se ocupa de varias familias de productos.

El método Factory utiliza interfaces y clases abstractas para desacoplar el cliente de la clase generator 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 el cliente de el generador y los productos.

Cuándo usar el Patrón del Método de Fábrica

Utilice el patrón de Método de fábrica cuando hay una necesidad de desacoplar un cliente de un producto en particular que utiliza. Utilice el método Factory 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

Utilice el patrón de fábrica abstracto cuando los clientes deben desacoplarse de las clases de productos. Especialmente útil para configuración y modificación del programa. El patrón de fábrica abstracto también puede imponer restricciones sobre qué clases se deben usar con otras. Puede ser mucho trabajo hacer nuevas fábricas de concreto.

Ejemplos:

Fábrica abstracta Ejemplo 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 pasta) heredan sus propiedades del resumen Fábrica. Cada disco individual contiene la información de cómo crear la pasta, y el fabricante de pasta no lo hace.

Fábrica abstracta Ejemplo 2:

El Equipo de estampado corresponde a la Fábrica Abstracta, ya que es un interfaz para operaciones que crean objetos abstractos de productos. Las matrices 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. Piezas específicas (es decir, puerta lateral del conductor para 99 camry) corresponde a los productos concretos.

Ejemplo del Método de Fábrica:

La compañía de juguetes corresponde al Creador, ya que puede usar la fábrica para crear objetos de producto. La división de la compañía de juguetes que fabrica un tipo específico de juguete (caballo o automóvil) corresponde al creador de concreto.

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

Patrón de Fábrica abstracto: Una fábrica-fábrica produce fábricas, que a su vez produce iproductos :)

[Actualización de acuerdo con los comentarios]
Lo que escribí antes no es correcto de acuerdo a 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 OS'es, proveedores de SQL, controladores de middleware, etc..

El Patrón Abstracto de la Fábrica

• Proporcionar una interfaz para crear familias de familiares o dependientes objetos sin especificar su clases de concreto.

• El patrón abstracto de la fábrica es muy similar al Método de Fábrica patrón. Una diferencia entre el dos es que con la Fábrica Abstracta patrón, una clase delega la 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 la creación de instancias del objeto deseado.

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

Patrón de fábrica

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

• Patrones de creación abstracta el proceso de creación de instancias de objetos. Le ocultar cómo se crean los objetos y ayudar hacer que el sistema en general sea independiente de cómo se crean sus objetos y compone.

• Patrones de creación de clase se centran en el uso de la herencia para decidir objeto instanciado Método de fábrica

• Los patrones de creación de objetos se centran en la delegación de la instancia a otro objeto Abstract Factory

Referencia: Fábrica vs Fábrica Abstracta

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

Abstract factory: Tienes una fábrica que crea otras fábricas, y estas fábricas a su vez crean objetos derivados de 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. La fábrica abstracta se implementa mediante el método de fábrica.

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 a una clase diferir la instanciación a subclases

Fábrica Abstracta: Proporciona una interfaz para crear familias de objetos relacionados o dependientes sin especificando sus clases concretas.

AbstractFactory pattern usa la composición para delegar la responsabilidad de crear el objeto a otra clase, mientras que Método de fábrica pattern usa la herencia y se basa en la clase derivada o subclase para crear el objeto

De oodesign artículos:

Fábrica diagrama de clases:

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;
   }
}

Implementación de fábrica no estática FactoryMethod ejemplo está disponible en este post:

Patrones de diseño: Fábrica vs método de fábrica vs Fábrica Abstracta

Cuándo usar: El cliente solo necesita una clase y no le importa qué implementación concreta está recibiendo.

Método de fábrica clase digaram:

Cuándo usar: El cliente no sabe qué clases concretas tendrá que crear en tiempo de ejecución, pero solo quiere obtener una clase que hará el trabajo.

Abstract Factory diagrama de clases de dzone

Cuándo usar: 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 relacionada con SE con código ejemplo:

Patrón De Fábrica. Cuándo ¿usar métodos de fábrica?

Diferencias:

1. Las clases Abstractas de Fábrica a menudo se implementan con Métodos de Fábrica, pero también se pueden implementar usando Prototype
2. Los diseños comienzan usando el Método de Fábrica (menos complicado, más personalizable, proliferan subclases) y evolucionan hacia otros patrones creacionales (más flexibles, más complejos) donde se necesita más flexibilidad.
3. Los métodos de fábrica generalmente se llaman dentro de la plantilla Método.

Otros artículos útiles:

Factory_method from sourcemaking

Abstract_factory de sourcemaking

Resumen-fábrica-diseño-patrón de journaldev

Ejemplo / Escenario para Abstract Factory

Vivo en un lugar donde llueve en la estación lluviosa, nieva en invierno y hace calor y sol en los veranos. Necesito diferente tipo 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 es consciente de mis estándares son fáciles para él hacerlo. Pero cuando un tipo rico del otro lado de la calle se le ocurren 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. Lo mismo ocurre con los artículos que recibe este rico.

Así que al mirar el escenario anterior, ahora aprecio la eficiencia del encargado de la tienda. Puedo reemplazar a este tendero con un resumen Tienda. Los artículos que obtenemos con artículos abstractos y yo y los ricos como clientes de 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 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 presentan a gold usuario, pero la funcionalidad en el menú es menor, los anuncios son en su mayoría relevantes, y un poco menos egronómica interfaz de usuario. El último es mi tipo de usuario, un usuario de 'grupo libre'. Me sirven lo suficiente para no ofenderme. La interfaz de usuario es un mínimo, los anuncios están muy fuera de pista tanto que no sé lo que viene en ella, por último, el menú solo tiene cerrar sesión.

Si tengo la oportunidad de construir algo como este sitio web, definitivamente consideraría el Patrón de Fábrica Abstracto.

Resumen Productos: Panel de Publicidad, 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.

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 entender dónde está la confusión.

Comencemos por el hecho de que no hay un patrón concreto que se llame solo "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 ser se considera correcto, dependiendo del alcance de la referencia):

• Algunas personas lo usan como un alias (atajo) para "Abstract Factory ".
• Algunas personas lo usan como un alias (atajo) 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 la "Fábrica abstracta" como el "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:

Producto implementa IProduct, que es creado por la fábrica, que implementa IFactory, que es creado por AbstractFactory.

Para entender lo tonto que es esto, continuemos nuestra ecuación:

AbstractFactory implementa IAbstractFactory, que es creado por... ¿AbstractAbstractFactory???

Espero que veas el punto. No te confundas, y por favor, no inventes cosas que no existen por una razón.

-

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

//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é en dar un ejemplo de ello también.

Así que aquí el PizzaIngredientsFactory es un abstract factory 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. Así que usando esto cada diferente ubicación puede crear instancias de ingredientes concretos que pertenecen a su ubicación.

Método de fábrica

Proporciona un ejemplo de aplicación concreta

En el ejemplo:
- createDough() - proporciona implementación concreta para la masa. Así que este es un método de fábrica

Abstract Factory

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 Head First design patterns

Un método Factory es un método no estático que devuelve una clase base o tipo de interfaz y que se implementa en una jerarquía para permitir la creación polimórfica. Un método Factory 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. Una Fábrica abstracta es una interfaz para crear familias de objetos relacionados o dependientes sin especificar su concreto clase.

Las Fábricas abstractas están diseñadas para ser sustituibles en tiempo de ejecución, por lo que un sistema puede ser configurado para usar un implementador específico y concreto 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 en Fábricas Abstractas cuando surge la necesidad de apoyar la creación de varias familias de objetos relacionados o dependientes.

Tengo algunos puntos para contribuir con la respuesta de Juan como sigue: {[14]]}

Abstract factory es una fábrica de fábricas!

Con el "Método Factory" (porque solo "Factory" es ambiguo), se producen implementaciones (Lemon, Orange, etc.) de una interfaz particular say digamos, IFruit. Esta fábrica podría llamarse CitricFruitFactory.

Pero ahora quiere crear otro tipo de fruta que la CitricFruitFactory no es capaz de crear. Tal vez el código de CitricFruitFactory no tendría sentido si crear un Strawberry en él (fresa no es una fruta cítrica!).

Por lo que podría crear una nueva fábrica llamada RedFruitFactory que produce Strawberry, Raspberry, etc.

Como dijo John Feminella: "Con el patrón de Fábrica Abstracto, se producen implementaciones de una interfaz de Fábrica en particular {por ejemplo, IFruitFactory. Cada uno de ellos sabe cómo crear diferentes tipos de fruta."

Que las implementaciones de IFruitFactory son CitricFruitFactory y RedFruitFactory!

Extending John Feminella respuesta:

Apple, Banana, Cherry implementa FruitFactory y que tiene un método llamado Create que es el único responsable de crear Apple o Banana o Cherry. Has terminado, con tu método Factory.

Ahora, quieres Create una ensalada especial de tus frutas y ahí viene tu Fábrica Abstracta. Abstract Factory sabe cómo crear su ensalada especial 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.
    }
}

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 Interface. Para sample tenemos una interfaz Shape con dos implementaciones Circle y Square. Hemos definido una clase factory con un método factory con un parámetro determinante como Type y una 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 fábricas aplicación. Para la siguiente muestra anterior tenemos una interfaz Color con dos implementaciones Red y Yellow. Hemos definido una interfaz ShapeColorFactory con dos RedCircleFactory y 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í 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 diferentes combinaciones 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 fruits, si está listo para crear objetos de fruits, puede usar simple factory pattern.

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 el tipo de fábrica que desea utilizar al inicio, en lugar de crear objetos, puede pasar las fábricas que se derivan de una clase de fábrica común al constructor en IOC.

Por lo tanto, creo que también se trata de la vida y la creación del objeto.

, Por Definición, podemos arrastrar las diferencias de dos:

Factory: 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 se requiere.

Fábrica abstracta: El patrón de fábrica abstracta actúa como una súper fábrica que crea otras fábricas. En Abstract Factory pattern, una interfaz es responsable de crear un conjunto de objetos relacionados u objetos dependientes sin especificar su concreto clase.

Por lo tanto, en las definiciones anteriores podemos enfatizar en 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();
        }
    }

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 se usa una interfaz en lugar de una clase abstracta, el resultado será una implementación diferente del patrón de Fábrica Abstracto.

: D

Tanto Factory Method como Abstract Factory mantienen a los clientes desacoplados de los tipos de concreto. Ambos crean objetos, pero el método Factory usa herencia mientras que Abstract Factory usa composición.

El Factory Method se hereda en 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 instancian se pasan a las clases de producto donde se utilizado como tipo abstracto. Los productos relacionados en un Abstract Factory a menudo se implementan usando Factory Method.

Abstract Factory es una plantilla para crear diferentes tipos de interfaces. Supongamos que tiene un proyecto que requiere analizar diferentes tipos de archivos csv que contienen información específica de cantidad, precio y artículo, como algunos contienen datos sobre frutas, otros sobre chocolates y luego, después de analizar, necesita actualizar esta información en su base de datos correspondiente, por lo que ahora puede tener una fábrica abstracta que le devuelve el analizador y la fábrica de modificadores y, Objeto del analizador del chocolate, Objeto del analizador de la Fruta etc. y de manera similar, la fábrica modificadora puede devolver el objeto modificador de chocolate, el objeto modificador de fruta, etc.

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 debes usar y por qué: La primera forma (sin patrón, solo constructor simple): crear por ti mismo no es una buena idea, tienes que hacer todo el trabajo, y tu código de cliente está vinculado a la implementación en particular.

La segunda forma (usando el patrón de fábrica): le proporciona el beneficio de que puede pasar cualquier tipo de implementación, que puede proporcione un tipo diferente de algo basado en alguna condición (tal vez un parámetro pasado al método creacional).

La tercera manera (usando el patrón de Fábrica abstracto): Esto le da más flexibilidad. Puedes encontrar diferentes tipos de creadores de algo basados en alguna condición (tal vez un parámetro pasado).

Tenga en cuenta que siempre puede salirse con la suya combinando dos condiciones juntas (lo que aumenta ligeramente la complejidad del código y el acoplamiento), supongo que es por eso rara vez vemos casos de uso de la vida real de patrón de fábrica abstracto.