【设计模式】-工厂模式

工厂模式是一种创建型设计模式，它提供了一种在不指定具体类的情况下创建对象的方法。工厂模式的核心思想是将对象的创建与使用分离，降低系统的耦合度，使系统更加灵活、可扩展。

工厂模式主要分为三种类型：简单工厂模式、工厂方法模式和抽象工厂模式。下面我将分别介绍这三种工厂模式，并给出相应的Java实例代码。

三种模式介绍

1. 简单工厂模式

简单工厂模式又称为静态工厂方法模式，它由一个工厂类根据传入的参数决定创建哪一种产品类的实例。

Java实例代码：

// 产品接口
public interface Car {
    void drive();
}

// 具体产品类1
public class BMW implements Car {
    @Override
    public void drive() {
        System.out.println("Driving BMW");
    }
}

// 具体产品类2
public class Benz implements Car {
    @Override
    public void drive() {
        System.out.println("Driving Benz");
    }
}

// 工厂类
public class CarFactory {
    public static Car createCar(String type) {
        if ("BMW".equalsIgnoreCase(type)) {
            return new BMW();
        } else if ("Benz".equalsIgnoreCase(type)) {
            return new Benz();
        } else {
            throw new IllegalArgumentException("Invalid car type: " + type);
        }
    }
}

// 客户端代码
public class Client {
    public static void main(String[] args) {
        Car bmw = CarFactory.createCar("BMW");
        bmw.drive();
        
        Car benz = CarFactory.createCar("Benz");
        benz.drive();
    }
}

2. 工厂方法模式

工厂方法模式将对象的创建延迟到子类中进行，工厂类不再负责具体产品的创建，而是提供一个创建产品的抽象方法，由子类实现具体的创建逻辑。

Java实例代码：

// 产品接口
public interface Car {
    void drive();
}

// 具体产品类1
public class BMW implements Car {
    @Override
    public void drive() {
        System.out.println("Driving BMW");
    }
}

// 具体产品类2
public class Benz implements Car {
    @Override
    public void drive() {
        System.out.println("Driving Benz");
    }
}

// 工厂接口
public interface CarFactory {
    Car createCar();
}

// 具体工厂类1
public class BMWFactory implements CarFactory {
    @Override
    public Car createCar() {
        return new BMW();
    }
}

// 具体工厂类2
public class BenzFactory implements CarFactory {
    @Override
    public Car createCar() {
        return new Benz();
    }
}

// 客户端代码
public class Client {
    public static void main(String[] args) {
        CarFactory bmwFactory = new BMWFactory();
        Car bmw = bmwFactory.createCar();
        bmw.drive();
        
        CarFactory benzFactory = new BenzFactory();
        Car benz = benzFactory.createCar();
        benz.drive();
    }
}

3. 抽象工厂模式

抽象工厂模式（Abstract Factory Pattern）提供了一种方式来封装一组具有共同主题的单个工厂，而不需要指定它们的具体类。客户端使用抽象工厂来创建一系列的相关或相互依赖的对象，而不需要指定它们具体的类。这样可以将客户端与具体产品的创建分离，使得系统更易于扩展和维护。

下面是一个简单的Java代码实例，展示了抽象工厂模式的应用：

// 抽象产品A
public interface Gui {
    void draw();
}

// 具体产品A1
public class WinGui implements Gui {
    @Override
    public void draw() {
        System.out.println("Drawing Windows GUI");
    }
}

// 具体产品A2
public class MacGui implements Gui {
    @Override
    public void draw() {
        System.out.println("Drawing MacOS GUI");
    }
}

// 抽象产品B
public interface Button {
    void click();
}

// 具体产品B1
public class WinButton implements Button {
    @Override
    public void click() {
        System.out.println("Clicking Windows Button");
    }
}

// 具体产品B2
public class MacButton implements Button {
    @Override
    public void click() {
        System.out.println("Clicking MacOS Button");
    }
}

// 抽象工厂
public interface UiFactory {
    Gui createGui();
    Button createButton();
}

// 具体工厂1
public class WinUiFactory implements UiFactory {
    @Override
    public Gui createGui() {
        return new WinGui();
    }

    @Override
    public Button createButton() {
        return new WinButton();
    }
}

// 具体工厂2
public class MacUiFactory implements UiFactory {
    @Override
    public Gui createGui() {
        return new MacGui();
    }

    @Override
    public Button createButton() {
        return new MacButton();
    }
}

// 客户端代码
public class Client {
    public static void main(String[] args) {
        // 使用Windows风格的UI组件
        UiFactory winFactory = new WinUiFactory();
        Gui winGui = winFactory.createGui();
        Button winButton = winFactory.createButton();
        winGui.draw();
        winButton.click();
        
        // 使用MacOS风格的UI组件
        UiFactory macFactory = new MacUiFactory();
        Gui macGui = macFactory.createGui();
        Button macButton = macFactory.createButton();
        macGui.draw();
        macButton.click();
    }
}

在这个例子中，我们定义了两个抽象产品：Gui 和 Button，分别代表图形用户界面和按钮。然后，我们为每种操作系统（Windows和MacOS）创建了具体的产品实现。WinGui 和 MacGui 是 Gui 的具体实现，而 WinButton 和 MacButton 是 Button 的具体实现。

我们定义了一个抽象工厂接口 UiFactory，它包含了创建 Gui 和 Button 的方法。然后，我们为每种操作系统创建了一个具体的工厂实现：WinUiFactory 和 MacUiFactory。这些工厂负责创建对应操作系统的具体产品实例。

在客户端代码中，我们可以根据需要选择使用哪种风格的UI组件。通过创建不同风格的工厂实例，并调用其创建方法，我们可以得到对应风格的 Gui 和 Button 对象，并调用它们的方法。这样，客户端代码与具体产品的创建逻辑被完全分离，提高了系统的灵活性和可维护性。

对比

是不是还有点晕，好像“工厂方法模式”和“抽象工厂模式”傻傻分不清楚啊。那我们来张表对比一下，就清晰了：

特性/模式	简单工厂模式	工厂方法模式	抽象工厂模式
结构	一个工厂类负责创建所有产品	抽象工厂类定义接口，具体工厂类负责创建对应产品	抽象工厂类定义创建产品族的接口，具体工厂类负责创建多个具体产品
扩展性	不符合“开闭原则”，新增产品需修改工厂类	符合“开闭原则”，新增产品只需添加新类和工厂子类	新增产品族符合“开闭原则”，单独新增产品不符合
使用场景	产品种类少且不常变动	产品种类多且经常变动	需要创建一系列相互关联或依赖的产品
责任划分	工厂类负责创建所有产品实例	具体工厂子类负责创建对应产品实例	具体工厂子类负责创建多个相互关联的产品实例
客户端与产品创建	客户端直接调用工厂类创建产品	客户端通过工厂子类接口创建产品	客户端通过工厂子类接口创建多个相关产品
灵活性	较低，工厂类集中了所有产品创建逻辑	较高，产品创建逻辑分散在工厂子类中	较高，可以灵活创建多个相关产品
代码复杂性	较低，结构简单	中等，需要定义抽象工厂和具体工厂类	较高，涉及多个抽象产品类和具体产品类

了解下“产品族”是个啥：

在抽象工厂模式中，产品族是指由同一个工厂生产的，位于不同产品等级结构中的一组产品。这些产品虽然在类型上有所差异，但它们在功能上是相互关联或依赖的。

为了更好地理解这个概念，我们可以以一个实际的例子来说明。假设有一个电器制造工厂，它生产了电视机和电冰箱两种产品。这两种产品分别属于不同的产品等级结构：电视机有其自己的产品等级结构，包括不同品牌、型号的电视机；电冰箱也有其独立的产品等级结构，涵盖了各种类型、规格的电冰箱。然而，在这个例子中，由于它们都是由同一个电器制造工厂生产的，因此电视机和电冰箱构成了一个产品族。

这个产品族中的每个成员（即电视机和电冰箱）都有其特定的功能和用途，但它们都是电器制造工厂的产品，共享了相同的生产标准和质量控制体系。因此，它们在功能上是相互关联或依赖的，构成了一个有机的整体。

抽象工厂模式通过提供一个接口，使得客户端可以创建一系列相关或相互依赖的对象，而无需指定它们具体的类。在上面的例子中，客户端可以通过调用电器制造工厂的接口，一次性地获取到电视机和电冰箱这两种产品，而无需关心它们具体的实现细节。

这下是不是就清晰了。OVER。