抽象工厂如何使用委托答案

【问题标题】：How does Abstract Factory uses delegation抽象工厂如何使用委托
【发布时间】：2013-07-09 07:17:42
【问题描述】：

抽象工厂和工厂设计模式的区别在于抽象工厂模式使用组合将创建对象的责任委托给另一个类，而工厂设计模式使用继承并依赖派生类或子类来创建对象。

下面是一个典型的抽象工厂例子(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 正在将对象返回给客户端。它通常作为具有多个产品的工厂类工作。

客户端代码可能在哪里

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

谁能解释一下抽象工厂中对象组合/委托发生在哪里？

【问题讨论】：

Design Patterns: Abstract Factory vs Factory Method的可能重复
以上链接很好地解释了意图的差异。抽象工厂只是具体工厂创建产品系列的接口。它把它留给混凝土工厂来制造产品。这就是代表团的发生方式。但 IMO 委托是不正确的词。
Head First Design 模式中提供了一个很好的比萨工厂示例。
请注意：组合是根据对其他对象的引用组合一个类的行为。它被称为“有”关系。所以在你的问题的背景下考虑一下......

标签： java oop design-patterns factory abstract-factory

【解决方案1】：

让我们看看这句话是什么。

AbstractFactory 模式使用组合来委托为另一个类创建对象

抽象工厂可以称为“工厂模式的工厂”。这里还有一个类，我们称之为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，包含的对象是工厂类的不同实现，例如ConcreteFactory1、ConcreteFactory2等。FactoryOfFactory根据@987654327@将请求委托给相应的工厂实现

【讨论】：

谢谢 Sanbhat。我错过了实际委托发生的 FactoryOfFactory 类，这个解释对我帮助很大。
@sanbhat 那么用户的问题是用组合还是聚合来说明的？也就是说，AbstractProductA 和 AbstractProductB 是否可以独立于 ConcreteFactory1 和 ConcreteFactory2 存在？

【解决方案2】：

AbstractFactory 通常有多种方法来创建不同类型的相关对象。

在您的情况下，ConcreteFactory1 封装了ProductA1 和ProductB1 之间的关系，以及ConcreteFactory2 分别在ProductA2 和ProductB2 之间的关系。

我相信这就是重点。 Concrete Factory 组合了几种目标对象类型（子类型）。通过调用适当的构造函数，委托有点不寻常。

【讨论】：