抽象工厂设计模式的使用

Question

我正在努力学习创造性设计模式，我想我现在理解了工厂方法模式。但在转向抽象工厂模式时，我找不到它的用途。我知道我错过了一些东西，但不知道在哪里。

在抽象工厂模式中，我们将有一个抽象工厂，混凝土工厂将返回实例。假设我们正在处理汽车的创建。我们将有一个像这样的抽象工厂

public interface CarFactory{
    public Car getCar();
}

我们的混凝土工厂将是

public class AudiFactory{
    public Car getCar(){
        return new Audi();
    }
}

public class VolvoFactory{
    public Car getCar(){
        return new Volvo();
    }
}

在用户类中，我们将像

CarFactory factory = new AudiFactory();
Car carAudi = factory.getCar();
factory = new VolvoFactory();
Car carVolvo = factory.getCar();

我认为我们也可以使用工厂模式构建相同的功能

public class CarFactory{

    public Car getCar(String make){
    if("Audi".equals(make))
        return new Audi();
    else if("Volvo".equals(make))
        return new Volvo();
    }
}

在用户类中，我们可以

CarFactory factory = new CarFactory();
Car carAudi = factory.getCar("Audi");
Car carVolvo = factory.getCar("Volvo");

如果我的理解是正确的（如果它是错误的，请纠正我），为什么我们需要另一种设计模式呢？

Answer 1

您已经很好地理解了工厂模式的使用：工厂允许tou创建在编译时类型未知的对象（只是corse接口的一个子类）。现在，让我们走出一步：

现在您有一个CarFactory来创建Car对象。但是，当您的程序中同时需要多个工厂时，您将如何管理？

这就是抽象工厂的由来：抽象工厂是工厂的工厂，允许您创建在编译时类型未知的工厂：因此，您将

public interface AbstractCarFactory
{
    public CarFactory getCarFactory(String area);
}

...并且您将能够实施欧洲汽车工厂、美国汽车工厂等。

抽象工厂何时有用的另一个例子是当您在其构造函数中拥有一些带有参数的工厂类时：

public CarFactory
{
    public CarFactory(boolean cheatingMotor) {...}
}

很难通过动态实例化（Class.forName（"CarFactory"）. newInstance（））创建一个CarFactory对象，因此向上一个层次的分解是有用的：一个决定如何实例化CarFactory的抽象工厂：

public interface AbstractCarFactory
{
    public CarFactory(boolean cheatingMotor);
}

public class MyAbstractCarFactory implements AbstractFactory
{
    public CarFactory(boolean cheatingMotor)
    {
        return new CarFactory(true);
    }
}

注意：在常见的应用程序中，抽象工厂模式足以正确地参数化所有应用程序的行为。我从来不知道需要工厂的工厂的实例。

Answer 2

在你的例子中：

>

工厂方法模式是创建汽车的模式（隐藏汽车创建的实现）

摘要工厂模式是创建汽车工厂的模式（汽车工厂创建，而不是汽车创建，专注于工厂创建）

所以你可以认为：抽象工厂模式是创建工厂的模式

这两种模式的用途不同。

抽象工厂模式（使用接口/抽象实现）IoC模式-

Answer 3

举个例子，你是对的，工厂模式可以取代抽象工厂模式。

当您需要在不实际了解家族（沃尔沃或奥迪）的情况下创建同一家族的不同产品时，抽象工厂是有意义的。

interface Car {}
interface Engine {}
interface Gear {}

interface ICarFactory {
    Car createCar();
    Engine createEngine();
    Gear createGear();
}

class AudiCar implements Car {}
class AudiEngine implements Engine {}
class AudiGear implements Gear {}

class AudiFactory implements ICarFactory {
    public Car createCar() { return new AudiCar(); }
    public Engine createEngine() { return new AudiEngine(); }
    public Gear createGear() { return new AudiGear(); }
}

我相信你也可以想象沃尔沃的情况。

现在假设我们有一个构建Car的类，这并不关心它是奥迪还是沃尔沃。

class CarBuilder {
    public static Car buildCar(ICarFactory factory) {
        Car car = factory.createCar();

        car.setEngine(factory.createEngine());
        car.setGear(factory.createGear());

        return car;
    }
}

现在我们的builder类可以在不知道实际品牌的情况下工作，这使得builder类符合开放/封闭原则。如果将来有第三个品牌出现，我们的builder类仍将能够在不需要更改单行代码的情况下生产这辆车。由于抽象工厂的存在，它可以扩展，但不能更改。。