2

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

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

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

4

2 回答 2

3

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

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

于 2013-07-11T06:26:24.990 回答
1

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

在您的情况下，封装了andConcreteFactory1之间的关系，并且ProductA1ProductB1ConcreteFactory2between ProductA2and之间的关系ProductB2。

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

于 2013-07-11T06:35:14.037 回答