关于java：Abstract Factory如何使用委托


How does Abstract Factory uses delegation

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

下面是一个抽象工厂的典型例子(http://www.oodesign.com/abstract-factory-pattern.html)，有人能解释一下抽象工厂在哪里使用对象组合吗？

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
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将对象返回给客户。它通常作为一个包含多个产品的工厂类工作。

客户代码可能在哪里

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

号

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

相关讨论

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

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

号

抽象工厂可以称为"工厂模式工厂"。这里还有一个类，我们称之为FactoryOfFactory，它根据请求类型创建/保存多个工厂，并返回最终产品。

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
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 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将请求委托给各自的工厂实现。

相关讨论

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

在您的例子中，ConcreteFactory1分别封装了ProductA1和ProductB1之间的关系，ProductA2和ProductB2之间的关系。

我相信这就是重点。混凝土工厂合成了几种目标对象类型(子类型)。通过调用适当的构造函数，委托有点不寻常。