java - 抽象工厂如何使用委托(delegate)

Question

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

下面是一个抽象工厂的典型例子(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();

谁能解释一下对象组合/委托(delegate)在抽象工厂中的什么地方发生？

Answer 1

让我们看看这句话并弄清楚它是什么。

AbstractFactory pattern uses composition to delegate responsibility of creating object to another class

抽象工厂可以称为“工厂模式的工厂”。这里还有一个类，我们称之为 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();
            ....
        }
   }

}

Composition的定义是

Composition is a special case of aggregation. In a more specific manner, a restricted aggregation is called composition. When an object contains the other object, if the contained object cannot exist without the existence of container object, then it is called composition.

这里的容器是FactoryOfFactory，包含的对象是工厂类的不同实现，例如ConcreteFactory1、ConcreteFactory2等。FactoryOfFactory 根据 Type

将请求委托(delegate)给相应的工厂实现