Java设计模式【工厂模式】

java_强哥2024-02-03 13:01

Java设计模式【工厂模式】

前言

三种工厂模式：简单工厂模式、工厂方法模式、抽象工厂模式；

  • 创建型设计模式
  • 封装对象的创建过程，将对象的创建和使用分离开，从而提高代码的可维护性和可扩展性

简单工厂模式

概述：将对象的创建过程封装在一个工厂类中，客户端通过工厂类来创建对象。

特点：

  • 一个工厂类+多个产品类
  • 添加新的产品类时，就必须修改工厂类的代码，这违反了开闭原则
java 复制代码 
package com.qiangesoft.design.creational.factory.simple;

/**
 * 简单工厂模式
 */
public class SimpleFactory {
    public static void main(String[] args) {
        // 奔驰车
        Car benz = CarFactory.buildCar("benz");
        benz.running();

        // 宝马车
        Car bmw = CarFactory.buildCar("bmw");
        bmw.running();

        // 奥迪车
        Car audi = CarFactory.buildCar("audi");
        audi.running();
    }
}

/**
 * 1.工厂类
 */
class CarFactory {
    public static Car buildCar(String type) {
        if ("benz".equals(type)) {
            return new Benz();
        } else if ("bmw".equals(type)) {
            return new BMW();
        } else if ("audi".equals(type)) {
            return new Audi();
        } else {
            throw new IllegalArgumentException("Illegal argument for type: " + type);
        }
    }
}

/**
 * 2.抽象产品接口
 */
interface Car {
    void running();
}

/**
 * 3.产品实现类
 * 奔驰、宝马、奥迪
 */
class Benz implements Car {
    @Override
    public void running() {
        System.out.println("奔驰车在路上跑！");
    }
}

class BMW implements Car {
    @Override
    public void running() {
        System.out.println("宝马车在路上跑！");
    }
}

class Audi implements Car {
    @Override
    public void running() {
        System.out.println("奥迪车在路上跑！");
    }
}

工厂方法模式

概述：定义一个工厂接口和多个具体工厂类来实现对象的创建。每个具体工厂类都实现了工厂接口，并负责创建一类产品对象。

特点：

  • 一个工厂接口+多个具体工厂类
  • 具体的产品类和工厂类都可以在运行时动态切换，符合开闭原则
java 复制代码 
package com.qiangesoft.design.creational.factory.method;

/**
 * 工厂方法模式
 */
public class FactoryMethod {
    public static void main(String[] args) {
        // 奔驰车
        CarFactory benzFactory = new BenzFactory();
        Car benzCar = benzFactory.buildCar();
        benzCar.running();

        // 宝马车
        CarFactory bmwFactory = new BMWFactory();
        Car bmwCar = bmwFactory.buildCar();
        bmwCar.running();

        // 奥迪车
        CarFactory audiFactory = new AudiFactory();
        Car audiCar = audiFactory.buildCar();
        audiCar.running();
    }
}

/**
 * 1.抽象工厂接口
 */
interface CarFactory {
    Car buildCar();
}

/**
 * 2.工厂实现类
 * 奔驰工厂、宝马工厂、奥迪工厂
 */
class BenzFactory implements CarFactory {
    @Override
    public Car buildCar() {
        return new Benz();
    }
}

class BMWFactory implements CarFactory {
    @Override
    public Car buildCar() {
        return new BMW();
    }
}

class AudiFactory implements CarFactory {
    @Override
    public Car buildCar() {
        return new BMW();
    }
}

/**
 * 3.抽象产品接口
 */
interface Car {
    void running();
}

/**
 * 4.产品实现类
 * 奔驰、宝马、奥迪
 */
class Benz implements Car {
    @Override
    public void running() {
        System.out.println("奔驰车在路上跑！");
    }
}

class BMW implements Car {
    @Override
    public void running() {
        System.out.println("宝马车在路上跑！");
    }
}

class Audi implements Car {
    @Override
    public void running() {
        System.out.println("奥迪车在路上跑！");
    }
}

抽象工厂模式

概述：工厂方法模式的升级版，它定义了多个工厂接口和多个产品族接口，每个工厂接口负责创建一类产品族对象，每个产品族接口负责定义一类产品对象。具体工厂类实现工厂接口并负责创建一类产品族对象，具体产品类实现产品族接口并负责创建一类产品对象。

特点：

  • 多个工厂接口+多个产品族接口
  • 具体的产品族和工厂类都可以在运行时动态切换，符合开闭原则
java 复制代码 
package com.qiangesoft.design.creational.factory.abstractf;

/**
 * 抽象工厂模式
 */
public class AbstractFactory {
    public static void main(String[] args) {
        // 奔驰车
        CarFactory benzFactory = new BenzFactory();
        Engine benzEngine = benzFactory.createEngine();
        Transmission benzTransmission = benzFactory.createTransmission();
        System.out.println("奔驰汽车：" + benzEngine.getName() + "+" + benzTransmission.getName());

        // 宝马车
        CarFactory bmwFactory = new BMWFactory();
        Engine bmwEngine = bmwFactory.createEngine();
        Transmission bmwTransmission = bmwFactory.createTransmission();
        System.out.println("宝马汽车：" + bmwEngine.getName() + "+" + bmwTransmission.getName());

        // 奥迪车
        CarFactory audiFactory = new AudiFactory();
        Engine audiEngine = audiFactory.createEngine();
        Transmission audiTransmission = audiFactory.createTransmission();
        System.out.println("奥迪汽车：" + audiEngine.getName() + "+" + audiTransmission.getName());
    }
}

/**
 * 1.抽象工厂接口
 */
interface CarFactory {
    Engine createEngine();

    Transmission createTransmission();
}

/**
 * 2.具体工厂类
 * 奔驰工厂、宝马工厂、奥迪工厂
 */
class BenzFactory implements CarFactory {
    @Override
    public Engine createEngine() {
        return new BenzEngine();
    }

    @Override
    public Transmission createTransmission() {
        return new BenzTransmission();
    }
}

class BMWFactory implements CarFactory {
    @Override
    public Engine createEngine() {
        return new BMWEngine();
    }

    @Override
    public Transmission createTransmission() {
        return new BmwTransmission();
    }
}

class AudiFactory implements CarFactory {
    @Override
    public Engine createEngine() {
        return new AudiEngine();
    }

    @Override
    public Transmission createTransmission() {
        return new AudiTransmission();
    }
}

/**
 * 3.产品接口1：发动机
 */
interface Engine {
    String getName();
}

/**
 * 4.产品实现类1：发动机
 */
class BenzEngine implements Engine {
    @Override
    public String getName() {
        return "奔驰发动机";
    }
}

class BMWEngine implements Engine {
    @Override
    public String getName() {
        return "宝马发动机";
    }
}

class AudiEngine implements Engine {
    @Override
    public String getName() {
        return "奥迪发动机";
    }
}

/**
 * 5.产品接口2：变速箱
 */
interface Transmission {
    String getName();
}

/**
 * 6.产品实现类2：变速箱
 */
class BenzTransmission implements Transmission {
    @Override
    public String getName() {
        return "奔驰变速箱";
    }
}

class BmwTransmission implements Transmission {
    @Override
    public String getName() {
        return "宝马变速箱";
    }
}

class AudiTransmission implements Transmission {
    @Override
    public String getName() {
        return "奥迪变速箱";
    }
}

总结

  • 简单工厂模式适用于创建单一类型的产品对象
  • 工厂方法模式适用于创建多种类型的产品对象
  • 抽象工厂模式适用于创建多个产品族的对象
相关推荐
花椒技术4 小时前
HJPusher / HJPlayer SDK 实践：我们为什么把直播推播链路拆成一套可复用能力
设计模式·harmonyos·直播
白鲸开源6 小时前
Apache SeaTunnel Zeta Engine 的 Basic Auth 是怎么工作的？
java·vue.js·github
白鲸开源6 小时前
一文读懂DolphinScheduler插件机制：如何轻松扩展任务类型与数据源
java·架构·github
用户2986985301411 小时前
Java 实现 Word 文档文本查找与高亮标注
java·后端
宇宙之一粟12 小时前
乐企版式文件生成平台
java·后端·python
plainGeekDev12 小时前
MVC 写法 → MVVM
android·java·kotlin
SL_staff12 小时前
3周搭完MES系统：JVS低代码+JVS-IoT物联网的实战记录
java·前端·低代码
MacroZheng13 小时前
斩获20w star！Claude Code最强插件，AI编程必备！
java·人工智能·后端
艺艺生辉13 小时前
迭代器模式-"我也想被增强for循环"
设计模式
唐青枫14 小时前
Java Spring WebFlux 实战指南：用 Mono、Flux 和 WebClient 写响应式接口
java·spring
热门推荐
012026年6月AI大模型全景报告：GPT-5.6、Claude Opus 4.8、Gemini 3.5，中美AI三足鼎立谁主沉浮？022026 年 AI 编程工具终极横评：Cursor vs Claude Code vs Copilot vs Windsurf032026年6月AI行业全景：从百模大战到Agent元年，这30天发生了什么？04Claude Code、Codex、Cursor三分天下：2026年AI编程Agent生态全景剖析05【AI】2026 年具身智能模型和世界模型总结06GitHub 镜像站点07【AI总结】2026年6月 主流国内外大模型总结08飞书长连接_事件订阅（接收消息，审批任务状态变更）09Trae国际版与国内版深度测评：AI原生IDE的双生花10AI科技热点日报 | 2026年6月1日