Question

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

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

有人可以解释一下，抽象工厂中对象组合/委派发生在哪里吗？

Answer 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将请求委托给相应的工厂实现，具体取决于在Type

Answer 2

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

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

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

Abstract Factory如何使用委托

2 个答案: