工厂方法模式

简介

定义：定义一个创建对象的接口，但由子类决定要实例化的类是哪一个。工厂方法模式把类实例化的过程推迟到子类。

使用场景:

• JDBC数据库连接

• 日志记录器

• 不同类型的文档创建

实现要点:

• 简单工厂：一个工厂类负责创建

• 工厂方法：每个产品有对应的工厂

UML-简单工厂

UML-工厂方法

代码示例-简单工厂

1. 产品接口

public interface Shape {
    void draw();
}

1. 具体产品

public class Circle implements Shape {
    @Override
    public void draw() {
        System.out.println("画圆形");
    }
}
public class Rectangle implements Shape {
    @Override
    public void draw() {
        System.out.println("画矩形");
    }
}

1. 产品工厂

/**
 * ========== 简单工厂模式 ==========
 * <p>
 * 特点：
 * - 一个工厂类负责创建所有产品
 * - 通过参数决定创建哪种产品
 * - 违反开闭原则（添加新产品需要修改工厂类）
 * <p>
 * 适用场景：
 * - 产品类型较少且稳定
 * - 创建逻辑简单
 * - 不需要扩展性
 */
public class SimpleFactory {
    /**
     * 简单工厂
     */
    public Shape createShape(String type) {
        switch (type.toLowerCase()) {
            case "circle":
                return new Circle();
            case "rectangle":
                return new Rectangle();
            default:
                throw new IllegalArgumentException("不支持的形状类型: " + type);
        }
    }
}

1. 使用

public class Test {
    public static void main(String[] args) {
        SimpleFactory simpleFactory = new SimpleFactory();
        Shape circle = simpleFactory.createShape("circle");
        circle.draw();
    }
}

代码示例-工厂方法

1. 产品接口，定义产品的通用行为

public interface Product {
    void start();

    void stop();

    void drive();

    String getType();
}

1. 具体的产品

public class Car implements Product {
    @Override
    public void start() {
        System.out.println("汽车启动：转动钥匙，发动机启动");
    }

    @Override
    public void stop() {
        System.out.println("汽车停止：踩刹车，发动机熄火");
    }

    @Override
    public void drive() {
        System.out.println("汽车行驶：踩油门，转动方向盘");
    }

    @Override
    public String getType() {
        return "汽车";
    }
}
public class Motorcycle implements Product {
    @Override
    public void start() {
        System.out.println("摩托车启动：踩启动杆，发动机启动");
    }

    @Override
    public void stop() {
        System.out.println("摩托车停止：踩刹车，发动机熄火");
    }

    @Override
    public void drive() {
        System.out.println("摩托车行驶：拧油门，转动车把");
    }

    @Override
    public String getType() {
        return "摩托车";
    }
}
public class Bicycle implements Product {
    @Override
    public void start() {
        System.out.println("自行车启动：踩踏板开始骑行");
    }

    @Override
    public void stop() {
        System.out.println("自行车停止：停止踩踏板，使用刹车");
    }

    @Override
    public void drive() {
        System.out.println("自行车行驶：持续踩踏板，控制方向");
    }

    @Override
    public String getType() {
        return "自行车";
    }
}

1. 创建者抽象类，定义工厂方法

/**
 * 工厂方法模式定义：
 * 定义一个创建对象的接口，但让子类决定实例化哪一个类。工厂方法让类的实例化推迟到子类。
 * <p>
 * 核心组件：
 * 1. Product（产品接口）
 * 2. ConcreteProduct（具体产品）
 * 3. Creator（创建者抽象类）
 * 4. ConcreteCreator（具体创建者）
 */
public abstract class ProductAbstractFactory {
    /**
     * 工厂方法 - 由子类实现具体的创建逻辑
     */
    public abstract Product createProduct();

    /**
     * 模板方法 - 使用工厂方法创建产品并执行操作
     */
    public void createAndUseProduct() {
        Product product = createProduct();
        product.start();
        product.drive();
        product.stop();
        System.out.println(product.getType() + "制造完成！\n");
    }
}

1. 具体创建者

public class BicycleFactory extends ProductAbstractFactory {
    @Override
    public Product createProduct() {
        return new Bicycle();
    }
}
public class CarFactory extends ProductAbstractFactory {
    @Override
    public Product createProduct() {
        return new Car();
    }
}

public class MotorcycleFactory extends ProductAbstractFactory {
    @Override
    public Product createProduct() {
        return new Motorcycle();
    }
}

1. 使用方式

public class Test {
    public static void main(String[] args) {
        CarFactory carFactory = new CarFactory();
        carFactory.createAndUseProduct();
        BicycleFactory bicycleFactory = new BicycleFactory();
        bicycleFactory.createAndUseProduct();
    }
}