Как абстрактная фабрика использует делегирование

Question

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

Ниже приведен типичный пример абстрактной фабрики (http://www.oodesign.com/abstract-factory-pattern.html). Может кто-нибудь объяснить мне, где абстрактная фабрика использует композицию объекта?

abstract class AbstractProductA{ 
public abstract void operationA1(); 
public abstract void operationA2(); 
} 

class ProductA1 extends AbstractProductA{ 
    ProductA1(String arg){ 
     System.out.println("Hello "+arg); 
    } // Implement the code here 
    public void operationA1() { }; 
    public void operationA2() { }; 
} 

class ProductA2 extends AbstractProductA{ 
    ProductA2(String arg){ 
     System.out.println("Hello "+arg); 
    } // Implement the code here 
    public void operationA1() { }; 
    public void operationA2() { }; 
} 

abstract class AbstractProductB{ 
    //public abstract void operationB1(); 
    //public abstract void operationB2(); 
} 

class ProductB1 extends AbstractProductB{ 
    ProductB1(String arg){ 
     System.out.println("Hello "+arg); 
    } // Implement the code here 
} 

class ProductB2 extends AbstractProductB{ 
    ProductB2(String arg){ 
     System.out.println("Hello "+arg); 
    } // Implement the code here 
} 

abstract class AbstractFactory{ 
    abstract AbstractProductA createProductA(); 
    abstract AbstractProductB createProductB(); 
} 

class ConcreteFactory1 extends AbstractFactory{ 
    AbstractProductA createProductA(){ 
     return new ProductA1("ProductA1"); 
    } 
    AbstractProductB createProductB(){ 
     return new ProductB1("ProductB1"); 
    } 
} 

class ConcreteFactory2 extends AbstractFactory{ 
    AbstractProductA createProductA(){ 
     return new ProductA2("ProductA2"); 
    } 
    AbstractProductB createProductB(){ 
     return new ProductB2("ProductB2"); 
    } 
} 

Что касается, как я понял, подкласс ConcreteFactory1 и ConcreteFactory1 возвращаются объект к клиенту. И он обычно работает как класс Factory с более чем одним продуктом.

Где, как клиентский код может быть

AbstractFactory factory = new ConcreteFactory2(); 
AbstractProductA prodA = factory.createProductA(); 

Может кто-то пожалуйста, объясните мне, где же состав объекта/делегации произойдет в Abstract Factory?

Answer 1

Давайте рассмотрим это предложение и выясним, что это такое.

AbstractFactory модель использует состав делегировать ответственность создание объекта к другому классу

Abstract Factory можно назвать как "Фабрика фабрично рисунка". Здесь будет еще один класс, давайте позвоним ему FactoryOfFactory, который создает/удерживает несколько заводов в зависимости от типа запроса и возвращает конечный продукт.

class FactoryOfFactory { 

    enum Type { P1, P2} 

    public AbstractProductA createProductA(Type t) { 
     switch(t) { 
      case P1: 
       return new ConcreteFactory1().createProductA(); 
      case P2: 
       return new ConcreteFactory2().createProductA(); 
      .... 
     } 
    } 

    public AbstractProductB createProductB(Type t) { 
     switch(t) { 
      case P1: 
       return new ConcreteFactory1().createProductB(); 
      case P2: 
       return new ConcreteFactory2().createProductB(); 
      .... 
     } 
    } 

} 

Определение Состав является

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

Здесь контейнер FactoryOfFactory и содержащиеся в нем объекты разные реализации классов Factory, такие как ConcreteFactory1, ConcreteFactory2 и т.д. FactoryOfFactory делегирует запрос к соответствующему реализации фабрики в зависимости от Type

Answer 2

AbstractFactory обычно имеет несколько методов для создания связанных объектов разных типов.

В вашем случае ConcreteFactory1 инкапсулирует связь между ProductA1 и ProductB1 и ConcreteFactory2 между ProductA2 и ProductB2 соответственно.

Я считаю, что это точка. Concrete Factory объединяет несколько типов целевых объектов (подтипов). Делегирование немного необычно, вызывая соответствующие конструкторы.