В чем принципиальная разница между фабричным и абстрактным шаблонами?

В чем основное отличие шаблонов Factory и Abstract Factory?

+464
источник поделиться
20 ответов

Используя шаблон Factory, вы создаете экземпляры реализаций (Apple, Banana, Cherry и т.д.) IFruit интерфейса, например IFruit.

С помощью шаблона "Абстрактная фабрика" вы предоставляете возможность каждому создать собственную фабрику. Это позволяет вашему складу быть либо IFruitFactory либо IJuiceFactory, при этом ваш склад не должен ничего знать о фруктах или соках.

+396
источник

Источник для этой информации, взятый из: http://java.dzone.com/news/intro-design-patterns-abstract

Аннотация Factory vs. Factory Метод

Методы абстрактного Factory реализованы как методы Factory. Как шаблон Abstract Factory, так и шаблон метода Factory отделяют клиентскую систему от фактических классов реализации через абстрактные типы и фабрики. Метод Factory создает объекты через наследование, где Abstract Factory создает объекты через композицию.

Абстрактный шаблон Factory состоит из AbstractFactory, ConcreteFactory, AbstractProduct, ConcreteProduct и Client.

Как реализовать

Абстрактный шаблон Factory может быть реализован с использованием шаблона метода Factory, шаблона прототипа или шаблона Singleton. Объект ConcreteFactory может быть реализован как Singleton, так как требуется только один экземпляр объекта ConcreteFactory.

Factory Шаблон метода представляет собой упрощенную версию абстрактного шаблона Factory. Factory Шаблон метода отвечает за создание продуктов, принадлежащих одному семейству, в то время как абстрактный шаблон Factory имеет дело с несколькими семействами продуктов.

Factory Метод использует интерфейсы и абстрактные классы, чтобы отделить клиента от класса генератора и результирующих продуктов. Аннотация Factory имеет генератор, который является контейнером для нескольких методов Factory, а также интерфейсы развязывают клиент от генератора и продуктов.

Когда использовать шаблон метода Factory

Используйте шаблон метода Factory, когда необходимо отделить клиента от определенного продукта, который он использует. Используйте метод Factory, чтобы освободить клиента от ответственности за создание и настройку экземпляров продукта.

Когда использовать абстрактный шаблон Factory

Используйте шаблон Abstract Factory, когда клиенты должны быть отделены от классов продуктов. Особенно полезен для настройки и модификации программы. Абстрактный шаблон Factory также может содержать ограничения, по которым классы должны использоваться с другими. Это может быть большая работа по созданию новых бетонных заводов.

Примеры:

Аннотация Factory Пример 1

Эта спецификация для дисков для подготовки различных видов макарон в изготовителе макаронных изделий представлен абстрактный Factory, и каждый конкретный диск является Factory. все фабрики (производители макаронных изделий) наследуют свои свойства от абстрактного Factory. Каждый отдельный диск содержит информацию о том, как создавать макароны, а производитель макарон не делает.

Аннотация Factory Пример 2:

Оборудование для штамповки соответствует абстрактному Factory, так как это интерфейс для операций, которые создают абстрактные объекты продукта. Матрицы соответствуют бетону Factory, поскольку они создают конкретный продукт. Каждая часть категории (капот, дверь и т.д.) Соответствует абстрактному произведению. Конкретные части (то есть дверь с боковой дверью для 99 camry) соответствуют бетонных изделий.

Factory Пример метода:

Игрушечная компания соответствует Создателю, так как она может использовать Factory для создания объектов продукта. Разделение игрушечной компании, производящей определенный тип игрушек (лошадь или автомобиль), соответствует ConcreteCreator.

+140
источник
другие ответы

Связанные вопросы


Похожие вопросы

Factory pattern: factory создает IProduct-реализации

Аннотация factory Выкройка: A factory -factory производит IFactories, который, в свою очередь, производит IProducts:)

[Обновить согласно комментариям]
То, что я написал ранее, не соответствует, по крайней мере, Wikipedia. Абстрактный factory - это просто интерфейс factory. С его помощью вы можете переключать свои фабрики во время выполнения, чтобы позволить различным фабрикам в разных контекстах. Примерами могут быть разные фабрики для разных OS'ов, поставщиков SQL, промежуточных драйверов и т.д.

+97
источник

Абстрактный шаблон Factory

  • Предоставить интерфейс для создания семей связанных или зависимых объектов без указания их конкретные классы.

  • Абстрактный шаблон Factory очень аналогично методу Factory шаблон. Одно отличие между два - это то, что с помощью Abstract Factory шаблон, класс делегирует ответственность объекта создание экземпляра другого объекта через тогда как Factory В шаблоне метода используется наследование и опирается на подкласс для обработки требуемый объект.

  • Собственно, делегированный объект часто использует методы Factory для выполните экземпляр!

Factory шаблон

  • Factory шаблоны являются примерами шаблоны создания

  • Шаблоны творчества аннотация объект. Oни скрыть, как создаются объекты и помогать сделать общую систему независимой о том, как создаются его объекты и состоит.

  • Шаблоны творчества класса сосредоточены на использование наследования для объект, подлежащий созданию Factory Метод

  • Образцы шаблонов объектов сосредоточены на делегирование экземпляра к другому объекту Аннотация Factory

Ссылка: Factory vs Аннотация Factory

+42
источник

Factory метод: У вас есть factory, который создает объекты, которые происходят из определенного базового класса

Аннотация factory: У вас есть factory, который создает другие фабрики, и эти фабрики, в свою очередь, создают объекты, полученные из базовых классов. Вы делаете это, потому что часто не просто хотите создать один объект (как с помощью метода factory) - скорее, вы хотите создать коллекцию связанных объектов.

+38
источник

Аннотация factory - это интерфейс для создания связанных объектов, но метод factory - это метод. Аннотация factory реализуется методом factory.

enter image description here

+37
источник

Основное отличие:

Фабрика: создает объекты без предоставления клиенту логики создания экземпляров.

Фабричный метод: определите интерфейс для создания объекта, но пусть подклассы решают, какой класс создать. Метод Factory позволяет классу откладывать создание экземпляров для подклассов

Абстрактная фабрика: предоставляет интерфейс для создания семейств связанных или зависимых объектов без указания их конкретных классов.

Шаблон AbstractFactory использует композицию, чтобы делегировать ответственность за создание объекта другому классу, в то время как шаблон метода Factory использует наследование и опирается на производный класс или подкласс для создания объекта.

Из статей о дизайне:

Заводская диаграмма классов:

enter image description here

Пример: 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;
   }
}

Нестатическая фабрика, реализующая пример FactoryMethod, доступна в этом посте:

Шаблоны проектирования: метод фабрики против фабрики против абстрактной фабрики

Когда использовать: Клиенту просто нужен класс, и ему все равно, какую конкретную реализацию он получает.

Заводской метод класса дигарам:

enter image description here

Когда использовать: Клиент не знает, какие конкретные классы необходимо будет создать во время выполнения, но просто хочет получить класс, который будет выполнять эту работу.

Абстрактная фабричная диаграмма классов от dzone

enter image description here

Когда использовать: когда вашей системе необходимо создать несколько семейств продуктов или вы хотите предоставить библиотеку продуктов без раскрытия деталей реализации.

Примеры исходного кода в вышеприведенных статьях очень хороши для четкого понимания концепций.

Связанный вопрос SE с примером кода:

Заводская модель. Когда использовать фабричные методы?

Отличия:

  1. Абстрактные фабричные классы часто реализуются с помощью фабричных методов, но они также могут быть реализованы с использованием Prototype
  2. Проекты начинаются с использования Factory Method (менее сложный, более настраиваемый, подклассы разрастаются) и переходят к другим шаблонам творчества (более гибким, более сложным), где требуется большая гибкость.
  3. Заводские методы обычно вызываются в шаблонных методах.

Другие полезные статьи:

factory_method от создания источника

abstract_factory от создания источника

абстрактный-фабричный-дизайн-шаблон из журнала

+34
источник

Пример/сценарий для абстрактного Factory

Я живу в месте, где идет дождь в сезон дождей, зимой снег и жаркий и солнечный летом. Мне нужна одежда другого типа, чтобы защитить себя от элементов. Для этого я иду в магазин возле моего дома и прошу одежду/предметы, чтобы защитить себя. Хранитель магазина дает мне соответствующий предмет в зависимости от окружающей среды и глубины моего кармана. Предметы, которые он мне дает, имеют одинаковый уровень качества и ценовой диапазон. Поскольку он знает о моих стандартах, это легко для него сделать. Но когда богатый парень со всех сторон сталкивается с такими же требованиями, он получает дорогой, фирменный предмет. Одна заметная вещь - все предметы, которые он мне дает, дополняют друг друга по качеству, стандарту и стоимости. Можно сказать, что они идут друг с другом. То же самое происходит с предметами, которые получает этот богатый парень.

Итак, посмотрев выше сценарий, я теперь ценю эффективность магазина. Я могу заменить этого лавочника абстрактным магазином. Элементы, которые мы получаем с абстрактными элементами, и я, и богатые как перспективные клиенты. Все, что нам нужно, это продукт/элемент, который соответствует нашим потребностям.

Теперь я с легкостью вижу, что я рассматриваю интернет-магазин, который предоставляет множество услуг своим многочисленным клиентам. Каждый клиент принадлежит к одной из трех групп. Когда пользователь группы премиум-класса открывает сайт, он получает отличный пользовательский интерфейс, настраиваемую рекламную панель, больше параметров в меню и т.д. Этот же набор функций представлен золотому пользователю, но функциональность в меню меньше, реклама в основном актуальна, и чуть менее эгономичный пользовательский интерфейс. Последний - мой тип пользователя, "свободный пользователь группы". Мне просто достаточно, чтобы я не обижался. Пользовательский интерфейс является минимальным, рекламные объявления настолько удачны, что я не знаю, что в нем происходит, наконец, меню выходит из системы.

Если у меня появится возможность построить что-то вроде этого веб-сайта, я бы определенно рассмотрел Abstract Factory Pattern.

Абстрактные продукты: панель объявлений, меню, художник пользовательского интерфейса.
Аннотация Factory: Пользовательский интерфейс веб-магазина
Concreate Factory: Превосходный пользовательский опыт, золотой опыт пользователя, общий пользовательский опыт.

+21
источник

Многие люди будут удивлены, возможно, но этот вопрос неверен. Если вы слышите этот вопрос во время собеседования, вам нужно помочь интервьюеру понять, где находится путаница.

Давайте начнем с того, что нет конкретного шаблона, который называется просто "Factory" . Существует шаблон, который называется "Аннотация Factory", и существует шаблон, который называется "Factory Method".

Итак, что означает "Factory" ? одно из следующего (все можно считать правильным, в зависимости от объема ссылки):

  • Некоторые люди используют его как псевдоним (ярлык) для Аннотация Factory".
  • Некоторые люди используют его как псевдоним (ярлык) для " Factory Method".
  • Некоторые используют его как более общее имя для всех шаблонов factory/creatation. Например. оба "Абстрактные Factory" и "Factory Метод" - это Заводы.

И, к сожалению, многие используют "Factory" для обозначения другого типа factory, который создает factory или фабрики (или их интерфейсы). Основываясь на их теории:

Продукт реализует IProduct, созданный factory, который реализует IFactory, который создается AbstractFactory.

Чтобы понять, насколько это глупо, продолжаем наше уравнение:

AbstractFactory реализует IAbstractFactory, созданный... AbstractAbstractFactory???

Надеюсь, вы поняли суть. Не путайте и, пожалуйста, не придумывайте вещи, которые не существуют по причине.

-

P.S.: factory для продуктов - AbstractFactory, а factory для абстрактных фабрик - еще один пример AbstractFactory.

+19
источник
//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
} 

Определения в текстовых книгах уже предоставлены другими ответами. Я думал, что приведу пример этого.

Итак, PizzaIngredientsFactory является абстрактным factory, поскольку он предоставляет методы для создания семейства связанных продуктов.

Обратите внимание, что каждый метод в абстрактном factory является методом Factory. Подобно createDough(), сам по себе является factory, чьи конкретные реализации будут предоставляться подклассами типа NYPizzaIngredientsFactory. Поэтому, используя это, каждое другое место может создавать экземпляры конкретных ингредиентов, которые принадлежат их местоположению.

Factory Метод

Предоставляет экземпляр конкретной реализации

В примере:
 - createDough() - обеспечивает конкретную реализацию теста. Таким образом, это метод factory

Аннотация factory

Предоставляет интерфейс для создания семейства связанных объектов

В примере:
 - PizzaIngredientsFactory является абстрактным factory, поскольку он позволяет создать связанный набор объектов, таких как Dough, Clams, Sauce. Для создания каждого семейства объектов он предоставляет метод factory.

Пример из Начать первые шаблоны проектирования

+16
источник

У меня есть несколько моментов, чтобы помочь Джону ответить следующим образом:

Аннотация factory является factory заводов!

С помощью метода Factory (потому что только "Factory" неоднозначно) вы создаете реализации (Lemon, Orange и т.д.) определенного интерфейса - скажем, IFruit. Этот factory можно назвать CitricFruitFactory.

Но теперь вы хотите создать другие виды фруктов, которые CitricFruitFactory не может создать. Возможно, код CitricFruitFactory не имеет смысла, если вы создадите в нем Strawberry (земляника не является лимонным фруктом!).

Итак, вы можете создать новый factory под названием RedFruitFactory, который создает Strawberry, Raspberry и т.д.

Как сказал Джон Фэминелла: "С шаблоном Abstract factory вы создаете реализации конкретного интерфейса factory - например, IFruitFactory. Каждый из них знает, как создавать различные виды фруктов.

Это реализация IFruitFactory - это CitricFruitFactory и RedFruitFactory!

+5
источник

A Factory Метод - это нестатический метод, который возвращает базовый класс или тип интерфейса и реализуется в иерархии, чтобы обеспечить создание полиморфных объектов. Метод Factory должен быть определен/реализован классом и одним или несколькими подклассами класса. Класс и подклассы действуют как фабрики. Однако мы не говорим, что метод Factory является Factory. Абстрактный Factory - это интерфейс для создания семейств связанных или зависимых объектов без указания их конкретных классов.

Абстрактные заводы предназначены для замены во время выполнения, поэтому система может быть настроена на использование конкретного конкретного разработчика абстрактного Factory. Каждый абстрактный Factory является Factory, хотя не каждый Factory является абстрактным Factory. Классы, которые являются фабриками, а не абстрактными фабриками, иногда развиваются в абстрактные фабрики, когда возникает необходимость поддерживать создание нескольких семей связанных или зависимых объектов.

+4
источник

Мои источники: StackOverflow, tutorialspoint.com, programmers.stackexchange.com и CodeProject.com.


Factory Method (также называемый Factory) предназначен для разъединения клиента реализации Interface. Для примера у нас есть интерфейс Shape с двумя реализациями Circle и Square. Мы определили фабричный класс с фабричным методом с параметром определителя, таким как Type и новой связанной реализацией интерфейса Shape.


Abstract Factory содержит несколько фабричных методов или фабричный интерфейс нескольких фабричных реализаций. Для следующего примера выше у нас есть интерфейс Color с двумя реализациями Red и Yellow. Мы определили интерфейс ShapeColorFactory с двумя RedCircleFactory и YellowSquareFactory. Следующий код для объяснения этой концепции:

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

Здесь разница между FactoryMethod и AbstractFactory. Factory Method так же просто возвращает конкретный класс интерфейса, а Abstract Factory возвращает factory of factory. Другими словами, Abstract Factory возвращают разные сочетания из серии интерфейсов.


Я надеюсь, что мое объяснение полезно.

+3
источник

Основное различие в этих фабриках - это то, что вы хотите делать с заводами и когда хотите его использовать.

Иногда, когда вы выполняете IOC (инверсия управления, например, инъекция конструктора), вы знаете, что можете создавать твердые объекты. Как уже упоминалось выше в примере с фруктами, если вы готовы создавать объекты фруктов, вы можете использовать простой factory шаблон.

Но много раз вы не хотите создавать твердые объекты, они появятся позже в потоке программы. Но конфигурация сообщает вам, какой тип factory вы хотите использовать при запуске, вместо создания объектов, вы можете передать на фабрики, которые производятся из общего класса factory для конструктора в IOC.

Итак, я думаю, что это также касается времени жизни и создания объекта.

+3
источник

Расширение ответа Джона Фэминеллы:

Apple, Banana, Cherry реализует FruitFactory и имеет метод под названием Create, который несет полную ответственность за создание Apple или Banana или Cherry. Вы закончили с помощью метода Factory.

Теперь вы хотите Create добавить специальный салат из своих фруктов, и наступает Аннотация Factory. Аннотация Factory знает, как создать свой специальный салат из Apple, Banana и 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.
    }
}
+3
источник

Оба Factory Method и Abstract Factory сохраняют клиентов развязанными с конкретными типами. Оба создают объекты, но метод Factory использует наследование, тогда как Abstract Factory использует композицию.

Factory Method наследуется в подклассах для создания конкретных объектов (продуктов), тогда как Abstract Factory предоставляет интерфейс для создания семейства связанных продуктов, а подкласс этого интерфейса определяет, как создавать связанные продукты.

Затем эти подклассы при создании экземпляра передаются в классы продуктов, где он используется как абстрактный тип. Связанные продукты в Abstract Factory часто реализуются с использованием Factory Method.

+2
источник

По определению мы можем вытащить различия двух:

Factory: для создания объекта используется интерфейс, но подкласс решает, какой класс необходимо создать. Создание объекта выполняется, когда это необходимо.

Аннотация Factory: Абстрактный Factory шаблон действует как супер-factory, который создает другие заводы. В абстрактном шаблоне Factory интерфейс отвечает за создание набора связанных объектов или зависимых объектов без указания их конкретных классов.

Итак, в приведенных выше определениях мы можем подчеркнуть конкретное различие. то есть шаблон Factory отвечает за создание объектов, а Abstract Factory отвечает за создание набора связанных объектов; очевидно, как через интерфейс.

Factory pattern:

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

Аннотация Factory Выкройка:

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();
        }
    }
+2
источник

Отметьте здесь: http://www.allapplabs.com/java_design_patterns/abstract_factory_pattern.htm кажется, что метод Factory использует конкретный класс (а не абстрактный) как базовый класс, в то время как Abstract Factory использует для этого абстрактный класс. Также, если использовать интерфейс вместо абстрактного класса, результатом будет другая реализация абстрактного шаблона Factory.

: D

+1
источник

Аннотация Factory является шаблоном для создания различных типов интерфейсов. Предположим, у вас есть проект, который требует от вас разбора различных типов файлов csv, содержащих информацию о количестве, цене и деталях, например, некоторые содержат данные о плодах, других о конфетах, а затем после разбора вам необходимо обновить эту информацию в соответствующей базе данных, чтобы теперь вы могли один абстрактный Factory возвращает вам парсер и модификатор Factory, а затем этот анализатор Factory может вернуть вам объект парсера Шоколада, объект Fruit Parser и т.д., а также модификатор Factory может вернуть объект модификатора Шоколада, объект модификатора фруктов и т.д.

+1
источник

Я думаю, мы можем понять разницу между этими двумя, увидев пример кода Java8:

  interface Something{}

  interface OneWhoCanProvideSomething {
     Something getSomething();
  }

  interface OneWhoCanProvideCreatorsOfSomething{
     OneWhoCanProvideSomething getCreator();
  }


public class AbstractFactoryExample {

    public static void main(String[] args) {
        //I need something
        //Let 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;
    }

}

Теперь вопрос заключается в том, какой способ творения следует использовать и почему: Первый способ (без шаблона, просто простой конструктор): создание самостоятельно - это не очень хорошая идея, вам нужно выполнить всю работу, а ваш клиентский код привязан к конкретной реализации.

Второй способ (с использованием шаблона Factory): дает вам преимущество, которое вы можете передать любому типу реализации, который может обеспечить различный тип чего-либо, основанный на каком-то определенном состоянии (возможно, параметр передан методу создания).

Третий способ (с использованием абстрактного шаблона Factory): это дает вам большую гибкость. Вы можете найти различные типы создателей чего-то, основанного на каком-то определенном состоянии (возможно, передан параметр).

Обратите внимание, что вы всегда можете уйти с шаблоном Factory, объединив два условия вместе (что немного увеличивает сложность кода и связь), я думаю, что мы редко видим случаи использования в реальном времени Abstract Factory шаблон.

+1
источник

Посмотрите другие вопросы по меткам или Задайте вопрос