工厂模式概述

想象一下你走进一家4S店准备买车。作为顾客，你不需要知道汽车是如何被制造出来的，你只需要告诉销售顾问：“我想要一辆轿车"或"我想要一辆SUV”，他们就会为你安排相应的车型。这就是工厂模式的核心思想 —— 将对象的创建过程封装起来，让客户端与具体产品的创建逻辑解耦。
在软件开发中，工厂模式就像一个虚拟的4S店。当你的程序需要一个对象时，不需要直接使用new关键字来创建，而是通过工厂类来获取。这样做的好处是，如果将来需要更换对象的创建方式，或者增加新的对象类型，只需要修改工厂类的代码，而不会影响到使用这些对象的代码。
工厂模式通过将对象的创建和使用分离，实现了面向对象设计的一个重要原则：开闭原则（对扩展开放，对修改关闭）。就像4S店可以不断引入新的车型，而不会影响到已有客户的使用体验一样。

工厂模式分类

简单工厂模式

简单工厂就像一家小型的4S店，店里只有一个销售顾问，他根据顾客的需求直接安排相应的车型。在代码实现中，我们会创建一个工厂类，它提供一个创建对象的方法，根据传入的参数来决定创建哪种具体的产品对象。
如：

// 汽车接口
public interface Car {
    void drive();
}

// 具体汽车类
public class SedanCar implements Car {
    @Override
    public void drive() {
        System.out.println("驾驶轿车");
    }
}

public class SUVCar implements Car {
    @Override
    public void drive() {
        System.out.println("驾驶SUV");
    }
}

// 简单工厂类
public class CarFactory {
    public static Car createCar(String type) {
        if ("sedan".equals(type)) {
            return new SedanCar();
        } else if ("suv".equals(type)) {
            return new SUVCar();
        }
        throw new IllegalArgumentException("不支持的车型类型");
    }
}

这种模式的使用非常简单：

Car sedanCar = CarFactory.createCar("sedan");
sedanCar.drive();

Car suvCar = CarFactory.createCar("suv");
suvCar.drive();

执行结果：

如上示例，在简单工厂模式中，CarFactory类负责创建所有类型的汽车。这种方式适用于产品种类相对固定，创建逻辑不会经常变化的场景。就像一家小型4S店，经营的车型比较固定，不会经常变动。

工厂方法模式

工厂方法模式就像一个汽车制造集团，下设多个专门的工厂，每个工厂专注于生产一种类型的汽车。比如轿车工厂专门生产轿车，SUV工厂专门生产SUV。这样每个工厂都可以根据自己的特点来优化生产流程。
在代码中，我们会定义一个抽象的工厂接口，然后针对不同的产品创建专门的工厂类：

// 抽象工厂
public abstract class CarFactory {
    abstract Car createCar();
}

// 具体工厂
public class SedanFactory extends CarFactory {
    @Override
    public Car createCar() {
        return new SedanCar();
    }
}

public class SUVFactory extends CarFactory {
    @Override
    public Car createCar() {
        return new SUVCar();
    }
}

使用时，我们先选择对应的工厂，然后创建产品：

CarFactory sedanFactory = new SedanFactory();
Car sedan = sedanFactory.createCar();
sedan.drive();

CarFactory suvFactory = new SUVFactory();
Car suv = suvFactory.createCar();
suv.drive();

运行结果：

与简单工厂相比，工厂方法模式将不同产品的创建过程分散到不同的工厂类中，每个工厂类都专注于创建自己的产品。这样在需要增加新产品时，只需要添加新的工厂类，而不需要修改现有的工厂类，更好地符合开闭原则。就像汽车集团可以轻松增加新的生产线，而不会影响现有工厂的运作。

抽象工厂模式

抽象工厂模式就像一个汽车制造集团不仅生产整车，还要生产发动机、车身等配套零部件。每个工厂都能生产一整套相关的产品，这些产品之间相互配套，形成一个产品族。比如轿车工厂生产轿车发动机和轿车车身，SUV工厂生产SUV发动机和SUV车身。如：

// 抽象产品
public interface Engine {
    void start();
}

public interface Body {
    void assemble();
}

// 具体产品
public class SedanEngine implements Engine {
    @Override
    public void start() {
        System.out.println("轿车发动机启动");
    }
}

public class SUVEngine implements Engine {
    @Override
    public void start() {
        System.out.println("SUV发动机启动");
    }
}

public class SedanBody implements Body {
    @Override
    public void assemble() {
        System.out.println("组装轿车车身");
    }
}

public class SUVBody implements Body {
    @Override
    public void assemble() {
        System.out.println("组装SUV车身");
    }
}

// 抽象工厂
public interface CarFactory {
    Engine createEngine();
    Body createBody();
}

// 具体工厂
public class SedanFactory implements CarFactory {
    @Override
    public Engine createEngine() {
        return new SedanEngine();
    }
    
    @Override
    public Body createBody() {
        return new SedanBody();
    }
}

public class SUVFactory implements CarFactory {
    @Override
    public Engine createEngine() {
        return new SUVEngine();
    }
    
    @Override
    public Body createBody() {
        return new SUVBody();
    }
}

测试代码如下：

// 生产轿车系列产品
System.out.println("=== 生产轿车系列 ===");
CarFactory sedanFactory = new SedanFactory();
Engine sedanEngine = sedanFactory.createEngine();
Body sedanBody = sedanFactory.createBody();

// 组装轿车
sedanEngine.start();  // 输出：轿车发动机启动
sedanBody.assemble(); // 输出：组装轿车车身

System.out.println("\n=== 生产SUV系列 ===");
// 生产SUV系列产品
CarFactory suvFactory = new SUVFactory();
Engine suvEngine = suvFactory.createEngine();
Body suvBody = suvFactory.createBody();

// 组装SUV
suvEngine.start();    // 输出：SUV发动机启动
suvBody.assemble();   // 输出：组装SUV车身

运行结果：

工厂模式优缺点

• 简单工厂模式就像一个小型4S店，结构简单，使用方便。它的优点是实现简单，客户端只需要知道产品的参数就可以了；缺点是工厂类的职责相对过重，增加新产品时需要修改工厂类的代码，违反了开闭原则。
• 工厂方法模式像一个汽车制造集团下的多个专业工厂，每个工厂专注于一种产品。它的优点是符合开闭原则，扩展性好，增加新产品只需要增加相应的工厂类；缺点是类的数量会随着产品的增加而增加，增加了系统的复杂度。
• 抽象工厂模式则像一个全产业链的汽车制造集团，可以生产多个产品族。它的优点是能够保证一系列相关产品的配套性，支持产品族的扩展；缺点是抽象层次较高，增加新的产品部件时麻烦，需要修改所有的工厂类。

如何选择工厂模式的实现方式

• 如果你的应用场景简单，产品种类较少且相对稳定，可以选择简单工厂模式。就像开一家小型4S店，只经营几种固定车型。
• 如果产品种类会经常变动，建议使用工厂方法模式。这就像汽车制造集团可以根据市场需求灵活增加新的生产线。
• 如果你需要创建一系列相互关联的产品，那么抽象工厂模式是最好的选择。这适合于像汽车制造这样需要协调多个配套零部件生产的场景。

总结

工厂模式是一种创建型设计模式，它通过将对象的创建与使用分离，提供了一种灵活的对象创建方式。简单工厂适合简单场景，工厂方法适合单个产品的变化，抽象工厂适合产品族的扩展。理解这三种模式的特点和使用场景，可以帮助我们在实际开发中选择最适合的实现方式。