java设计模式之-工厂模式

1. 什么是工厂模式？

工厂模式（Factory Pattern） 是一种创建型设计模式，它提供了一种封装对象创建过程的方式，让客户端代码无需关心具体对象的实例化细节，而是通过工厂类来创建对象。

简单来说，工厂模式就像一个“生产车间”：

• 你告诉工厂**“我要什么”**（比如“汽车”或“自行车”）
• 工厂负责创建对应的产品并返回给你
• 你不需要知道对象是怎么创建的，只需要使用它

2. 主要解决什么问题？

工厂模式主要解决以下问题：

1. 对象创建逻辑复杂：如果对象的创建涉及多个步骤或依赖外部配置，直接 new 会让代码臃肿。
2. 依赖耦合问题：客户端代码直接依赖具体类（如 new Car()），违反依赖倒置原则（DIP）。
3. 扩展性问题：新增产品类时，需要修改多处 new 代码，违反开闭原则（OCP）。

3. 什么时候使用工厂模式？

✅ 适用场景：

• 对象的创建逻辑较复杂（如依赖配置文件、数据库等）
• 需要统一管理对象的创建（如缓存、单例控制）
• 系统需要支持多种相似产品（如不同数据库连接、不同日志记录器）
• 希望客户端代码与具体实现解耦

❌ 不适用场景：

• 对象的创建非常简单，直接 new 即可
• 产品种类很少，且不会扩展

---

4. 工厂模式的优点 & 缺点

✅ 优点

1. 解耦：客户端代码不依赖具体类，只依赖抽象（接口/抽象类）。
2. 可扩展：新增产品时，只需扩展工厂，无需修改客户端代码。
3. 封装创建逻辑：复杂对象的创建过程被封装，代码更清晰。
4. 统一管理：可以结合单例、缓存等优化对象创建。

❌ 缺点

1. 增加复杂度：需要额外编写工厂类，小型项目可能显得冗余。
2. 违反开闭原则（简单工厂）：新增产品时可能需要修改工厂类（但抽象工厂可以解决）。

---

5. 代码示例

（1）简单工厂模式（静态工厂）

适用场景：产品种类较少，且不经常扩展。

// 1. 定义产品接口
interface Vehicle {
    void drive();
}

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

// 3. 具体产品：Bike
class Bike implements Vehicle {
    @Override
    public void drive() {
        System.out.println("Riding a bike...");
    }
}

// 4. 简单工厂（静态方法）
class VehicleFactory {
    public static Vehicle createVehicle(String type) {
        if ("car".equalsIgnoreCase(type)) {
            return new Car();
        } else if ("bike".equalsIgnoreCase(type)) {
            return new Bike();
        }
        throw new IllegalArgumentException("Unknown vehicle type: " + type);
    }
}

// 5. 客户端调用
public class SimpleFactoryDemo {
    public static void main(String[] args) {
        Vehicle car = VehicleFactory.createVehicle("car");
        car.drive(); // Driving a car...

        Vehicle bike = VehicleFactory.createVehicle("bike");
        bike.drive(); // Riding a bike...
    }
}

缺点：新增产品（如 Truck）需要修改 VehicleFactory，违反开闭原则。

---

（2）工厂方法模式（Factory Method）

适用场景：产品种类较多，且可能扩展。

// 1. 抽象工厂接口
interface VehicleFactory {
    Vehicle createVehicle();
}

// 2. 具体工厂：CarFactory
class CarFactory implements VehicleFactory {
    @Override
    public Vehicle createVehicle() {
        return new Car();
    }
}

// 3. 具体工厂：BikeFactory
class BikeFactory implements VehicleFactory {
    @Override
    public Vehicle createVehicle() {
        return new Bike();
    }
}

// 4. 客户端调用
public class FactoryMethodDemo {
    public static void main(String[] args) {
        VehicleFactory carFactory = new CarFactory();
        Vehicle car = carFactory.createVehicle();
        car.drive(); // Driving a car...

        VehicleFactory bikeFactory = new BikeFactory();
        Vehicle bike = bikeFactory.createVehicle();
        bike.drive(); // Riding a bike...
    }
}

优点：新增产品（如 TruckFactory）时，只需新增工厂类，无需修改现有代码，符合开闭原则。

---

（3）抽象工厂模式（Abstract Factory）

适用场景：需要创建产品族（如不同品牌的汽车+引擎）。

// 1. 抽象产品：Car
interface Car {
    void drive();
}

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

// 3. 抽象产品：Engine
interface Engine {
    void start();
}

// 4. 具体产品：ToyotaEngine
class ToyotaEngine implements Engine {
    @Override
    public void start() {
        System.out.println("Toyota engine started!");
    }
}

// 5. 抽象工厂
interface VehicleFactory {
    Car createCar();
    Engine createEngine();
}

// 6. 具体工厂：ToyotaFactory
class ToyotaFactory implements VehicleFactory {
    @Override
    public Car createCar() {
        return new ToyotaCar();
    }

    @Override
    public Engine createEngine() {
        return new ToyotaEngine();
    }
}

// 7. 客户端调用
public class AbstractFactoryDemo {
    public static void main(String[] args) {
        VehicleFactory toyotaFactory = new ToyotaFactory();
        Car car = toyotaFactory.createCar();
        Engine engine = toyotaFactory.createEngine();

        car.drive();    // Driving a Toyota...
        engine.start(); // Toyota engine started!
    }
}

优点：可以创建一组相关对象（如丰田汽车+丰田引擎），适合复杂产品组合。

---

6. 总结

模式	适用场景	特点
简单工厂	产品种类固定，不常扩展	一个工厂类创建所有产品，违反开闭原则
工厂方法	产品种类可能扩展	每个产品对应一个工厂，符合开闭原则
抽象工厂	需要创建产品族（多个关联对象）	适合复杂对象组合（如汽车+引擎）

推荐使用场景：

• 如果对象创建简单 → 直接 new
• 如果对象创建复杂，但种类少 → 简单工厂
• 如果对象可能扩展 → 工厂方法
• 如果需要创建关联对象 → 抽象工厂

工厂模式的核心思想是：“不要自己 new，让工厂帮你创建！” 🏭🚗🚲