夜雨聆风
点击上方蓝字关注我们
定义：定义一个用于创建对象的接口，但让子类决定实例化哪一个类。工厂方法将对象的实例化延迟到子类中完成。
生活化案例：一家水果店需要提供苹果和香蕉。店主定义了“水果工厂”的规范，但不亲自生产具体水果，而是交给“苹果工厂”和“香蕉工厂”分别负责。客户只需告诉工厂要哪种水果，工厂就会返回对应的产品。
模式结构（按模板）：
角色 | 英文名 | 说明 | 生活化案例映射 |
抽象产品 | Product | 定义所有产品的统一接口 | 水果（Fruit） |
具体产品 | ConcreteProduct | 实现抽象产品接口，是真实产出的对象 | 苹果（Apple）、香蕉（Banana） |
抽象工厂 | Creator | 声明工厂方法，规定生产规范，返回产品对象 | 抽象水果工厂（FruitFactory） |
具体工厂 | ConcreteCreator | 实现工厂方法，由客户调用，返回对应产品实例 | 苹果工厂（AppleFactory）、香蕉工厂（BananaFactory） |
代码示例：
// 1. 抽象产品：水果public interface Fruit {voideat();}// 2. 具体产品：苹果public class Apple implements Fruit {publicvoideat() {System.out.println("吃苹果");}}// 3. 具体产品：香蕉public class Banana implements Fruit {publicvoideat() {System.out.println("吃香蕉");}}// 4. 抽象工厂：水果工厂public interface FruitFactory {Fruit createFruit();}// 5. 具体工厂：苹果工厂public class AppleFactory implements FruitFactory {public Fruit createFruit() {return new Apple();}}// 6. 具体工厂：香蕉工厂public class BananaFactory implements FruitFactory {public Fruit createFruit() {return new Banana();}}// 7. 客户端调用public class Client {publicstaticvoidmain(String[] args) {FruitFactory factory = new AppleFactory();Fruit fruit = factory.createFruit();fruit.eat(); // 输出：吃苹果}}
核心特点：
抽象工厂角色定义了工厂方法的规范，但不负责具体实现
每个具体工厂对应一个具体产品，职责单一
客户端只需与抽象工厂和抽象产品交互，无需知道具体产品类名
符合“开闭原则”：新增产品只需新增对应的具体产品类和具体工厂类
适用场景：
客户端不知道需要创建的具体产品类型
类本身需要将对象的创建职责委托给子类
需要提供一种扩展机制，允许未来增加新的产品类型
定义：提供一个接口，可以创建一系列相关或相互依赖的对象（产品族），而无需指定它们具体的类。
生活化案例：小米工厂、华为工厂（具体工厂），每个工厂统一生产手机、耳机、充电器（整套产品族）。只需切换工厂，就能切换整套产品体系。
模式结构（按模板）：
角色 | 英文名 | 说明 | 生活化案例映射 |
抽象产品A | AbstractProductA | 定义某类产品的统一接口 | 手机（Phone） |
抽象产品B | AbstractProductB | 定义另一类产品的统一接口 | 耳机（Earphone） |
具体产品A1/A2 | ConcreteProductA1/A2 | 实现抽象产品A接口的具体产品 | 小米手机、华为手机 |
具体产品B1/B2 | ConcreteProductB1/B2 | 实现抽象产品B接口的具体产品 | 小米耳、华为耳机 |
抽象工厂 | AbstractFactory | 声明创建一系列相关产品的方法 | 抽象电子工厂（ElectronicsFactory） |
具体工厂 | ConcreteFactory | 实现抽象工厂，创建整套产品族 | 小米工厂（XiaomiFactory）、 华为工厂（HuaweiFactory） |
代码示例：
// 1. 抽象产品A：手机public interface Phone {voidcall();}// 2. 抽象产品B：耳机public interface Earphone {voidlisten();}// 3. 具体产品A1：小米手机public class XiaomiPhone implements Phone {publicvoidcall() {System.out.println("使用小米手机打电话");}}// 4. 具体产品A2：华为手机public class HuaweiPhone implements Phone {publicvoidcall() {System.out.println("使用华为手机打电话");}}// 5. 具体产品B1：小米耳机public class XiaomiEarphone implements Earphone {publicvoidlisten() {System.out.println("使用小米耳机听音乐");}}// 6. 具体产品B2：华为耳机public class HuaweiEarphone implements Earphone {publicvoidlisten() {System.out.println("使用华为耳机听音乐");}}// 7. 抽象工厂：电子工厂public interface ElectronicsFactory {Phone createPhone();Earphone createEarphone();}// 8. 具体工厂：小米工厂public class XiaomiFactory implements ElectronicsFactory {public Phone createPhone() {return new XiaomiPhone();}public Earphone createEarphone() {return new XiaomiEarphone();}}// 9. 具体工厂：华为工厂public class HuaweiFactory implements ElectronicsFactory {public Phone createPhone() {return new HuaweiPhone();}public Earphone createEarphone() {return new HuaweiEarphone();}}// 10. 客户端调用public class Client {publicstaticvoidmain(String[] args) {// 切换到小米整套产品ElectronicsFactory factory = new XiaomiFactory();Phone phone = factory.createPhone();Earphone earphone = factory.createEarphone();phone.call(); // 输出：使用小米手机打电话earphone.listen(); // 输出：使用小米耳机听音乐// 切换到华为整套产品（只需换工厂）factory = new HuaweiFactory();phone = factory.createPhone();earphone = factory.createEarphone();phone.call(); // 输出：使用华为手机打电话earphone.listen(); // 输出：使用华为耳机听音乐}}
核心特点：
抽象工厂定义了创建一系列相关产品的规范，不负责具体实现
每个具体工厂对应一个产品族（如小米整套产品），职责统一
客户端只需与抽象工厂和抽象产品交互，无需知道具体产品类名
方便切换产品族：只需更换具体工厂，整套产品体系一键切换
新增产品族方便：增加一个新品牌（如苹果），只需新增对应的具体工厂和具体产品类
新增产品等级麻烦：如果要给每个工厂增加一个新品类（如平板电脑），需要修改所有抽象工厂和具体工厂
适用场景：
产品固定配套、多品牌、多系列成套生产场景（如手机+耳机+充电器）
需要独立于产品的创建、组装和表示方式
系统需要配置多个产品族之一
强调一系列相关产品对象的设计，进行联合约束
工厂方法 vs 抽象工厂对比：
对比项 | 工厂方法模式 | 抽象工厂模式 |
针对维度 | 一个产品等级结构 | 多个产品等级结构（产品族） |
工厂数量 | 每个具体产品对应一个工厂 | 每个产品族对应一个工厂 |
扩展方向 | 方便新增具体产品 | 方便新增产品族 |
结构复杂度 | 简单 | 复杂 |
生活化案例 | 苹果工厂只产苹果 | 小米工厂产手机+耳机+充电器 |
定义：通过拷贝已有原型对象创建新对象，替代new 创建。用原型实例指定创建对象的类型。
生活化案例：游戏怪物模板、PPT复制粘贴、批量生成相似用户数据。创建复杂对象成本高，直接克隆最快。
模式结构（按模板）：
角色 | 英文名 | 说明 | 生活化案例映射 |
抽象原型 | Prototype | 声明克隆方法（clone）的接口 | 怪物模板接口（Monster） |
具体原型 | ConcretePrototype | 实现克隆方法，返回自身的拷贝 | 骷髅兵、巨魔等具体怪物 |
客户端 | Client | 调用克隆方法创建新对象，无需使用 new | 游戏引擎批量生成怪物 |
代码示例：
// 1. 抽象原型：怪物模板public interface Monster extends Cloneable {Monster clone();}// 2. 具体原型：骷髅兵public class Skeleton implements Monster {private String name;private int health;private int attack;public Skeleton(String name, int health, int attack) {this.name = name;this.health = health;this.attack = attack;}public Monster clone() {try {return (Skeleton) super.clone();} catch (CloneNotSupportedException e) {return null;}}public void show() {System.out.println("骷髅兵：" + name + "，血量：" + health + "，攻击：" + attack);}}// 3. 客户端调用public class Client {public static void main(String[] args) {Skeleton prototype = new Skeleton("骷髅战士", 100, 20);Skeleton monster1 = (Skeleton) prototype.clone();Skeleton monster2 = (Skeleton) prototype.clone();monster1.show();monster2.show();}}
核心特点：
通过克隆方式创建对象，替代new 关键字
支持浅拷贝（默认）和深拷贝（需手动实现）
高效创建相似对象，降低复杂对象创建的资源消耗
适用场景：
对象创建耗时耗资源
批量生成大量相似对象
模板复用场景
定义：提供一个静态方法，让外部可以获取并使用它的唯一实例；内部实现确保只生成一个实例，保证一个类全局只有一个实例，并提供统一的全局访问点。
生活化案例：电脑回收站、系统配置文件、数据库连接池、系统任务管理器。这类对象全局唯一，所有操作都作用于同一个实例。
模式结构（按模板）：
角色 | 英文名 | 说明 | 生活化案例映射 |
单例类 | Singleton | 持有自己的唯一实例，构造方法私有，对外提供静态访问方法 | 回收站（RecycleBin） |
客户端 | Client | 实现抽象产品接口，是真实产出的对象 | 用户打开回收站 |
备注：单例模式与工厂方法模式结构不同，没有抽象产品/具体产品/抽象工厂等角色，而是采用“自持有实例 + 私有构造 + 静态访问方法”的结构。
代码示例：
// 1. 单例类：回收站public class RecycleBin {// 2. 静态私有实例（使用 volatile 保证线程可见性）private static volatile RecycleBin instance;// 3. 构造方法私有化，禁止外部通过 new 创建对象privateRecycleBin() {System.out.println("回收站已初始化");}// 4. 对外暴露静态全局访问点（线程安全-双重检查锁）publicstatic RecycleBin getInstance() {if (instance == null) {synchronized (RecycleBin.class) {if (instance == null) {instance = new RecycleBin();}}}return instance;}// 5. 业务方法示例publicvoidclean() {System.out.println("清空回收站");}}// 6. 客户端调用public class Client {publicstaticvoidmain(String[] args) {RecycleBin bin1 = RecycleBin.getInstance();RecycleBin bin2 = RecycleBin.getInstance();System.out.println(bin1 == bin2); // 输出：true，同一个实例bin1.clean(); // 输出：清空回收站}}
核心特点：
构造方法私有化，禁止外部通过new创建对象
类内部持有静态的唯一实例
对外暴露静态方法，作为全局访问点
线程安全是该模式高频考察点
适用场景：
全局配置类（如系统配置文件读取器）
资源共享类（如数据库连接池、线程池）
计数器（如网站访问计数器）
日志工具类（如全局日志记录器）
定义：将一个复杂对象的构建与它的表示分离，使得同样的构建过程可以创建不同的表示。
生活化案例：组装电脑。固定流程（装CPU → 装主板 → 装显卡 → 装内存），更换不同配件就能组装出高配/低配/办公/游戏等不同电脑。
模式结构（按模板）：
角色 | 英文名 | 说明 | 生活化案例映射 |
产品 | Product | 被构建的复杂对象 | 电脑（Computer） |
抽象建造者 | Builder | 声明构建产品各部分的抽象方法 | 电脑组装规范（ComputerBuilder） |
具体建造者 | ConcreteBuilder | 实现抽象建造者，定义具体的组装过程 | 高配电脑组装员、低配电脑组装员 |
指挥者 | Director | 控制构建流程，按顺序调用建造者方法 | 电脑组装工头 |
代码示例：
// 1. 产品：电脑public class Computer {private String cpu;private String motherboard;private String graphicsCard;private String memory;public void setCpu(String cpu) { this.cpu = cpu; }public void setMotherboard(String motherboard) { this.motherboard = motherboard; }public void setGraphicsCard(String graphicsCard) { this.graphicsCard = graphicsCard; }public void setMemory(String memory) { this.memory = memory; }public void show() {System.out.println("电脑配置：CPU=" + cpu + "，主板=" + motherboard +"，显卡=" + graphicsCard + "，内存=" + memory);}}// 2. 抽象建造者：电脑组装规范public interface ComputerBuilder {void buildCpu();void buildMotherboard();void buildGraphicsCard();void buildMemory();Computer getResult();}// 3. 具体建造者：高配电脑public class HighConfigBuilder implements ComputerBuilder {private Computer computer = new Computer();public void buildCpu() { computer.setCpu("i9-13900K"); }public void buildMotherboard() { computer.setMotherboard("Z790"); }public void buildGraphicsCard() { computer.setGraphicsCard("RTX 4090"); }public void buildMemory() { computer.setMemory("32GB DDR5"); }public Computer getResult() { return computer; }}// 4. 具体建造者：低配电脑public class LowConfigBuilder implements ComputerBuilder {private Computer computer = new Computer();public void buildCpu() { computer.setCpu("i5-12400"); }public void buildMotherboard() { computer.setMotherboard("B660"); }public void buildGraphicsCard() { computer.setGraphicsCard("GTX 1660"); }public void buildMemory() { computer.setMemory("16GB DDR4"); }public Computer getResult() { return computer; }}// 5. 指挥者：组装工头（控制固定流程）public class Director {private ComputerBuilder builder;public Director(ComputerBuilder builder) {this.builder = builder;}// 固定的组装流程public Computer construct() {builder.buildCpu();builder.buildMotherboard();builder.buildGraphicsCard();builder.buildMemory();return builder.getResult();}}// 6. 客户端调用public class Client {public static void main(String[] args) {// 组装高配电脑ComputerBuilder highBuilder = new HighConfigBuilder();Director director = new Director(highBuilder);Computer highComputer = director.construct();highComputer.show(); // 输出：CPU=i9-13900K，主板=Z790，显卡=RTX 4090，内存=32GB DDR5// 组装低配电脑（同样的流程，不同的结果）ComputerBuilder lowBuilder = new LowConfigBuilder();director = new Director(lowBuilder);Computer lowComputer = director.construct();lowComputer.show(); // 输出：CPU=i5-12400，主板=B660，显卡=GTX 1660，内存=16GB DDR4}}
核心特点：
分步构建复杂对象，可以控制每一步的执行
构建流程固定（由指挥者控制），更换建造者即可生成不同表示
适合参数多、构造复杂的对象
将对象的构建过程和表示分离
适用场景：
参数多、构造复杂、存在多种组合的对象（订单、配置、实体类）
相同构建过程需要生成不同表示（如高配/低配电脑）
需要屏蔽复杂对象创建的内部细节
对象属性之间有一定的依赖关系或校验规则
建造者 vs 工厂方法：
对比项 | 工厂方法模式 | 抽象工厂模式 |
复杂度 | 简单对象 | 复杂对象，需要多步构建 |
返回结果 | 一步返回完整对象 | 分步构建，最后返回 |
控制粒度 | 粗粒度（整体创建） | 细粒度（控制每一步） |
适用场景 | 单一产品类型 | 多种组合的复杂对象 |
模式 | 一句话总结 |
单例模式 | 全局唯一，禁止 new |
工厂方法 | 每个具体产品对应一个工厂 |
抽象工厂 | 一个工厂生产一套产品族 |
原型模式 | 克隆拷贝，替代 new |
建造者模式 | 分步构建，流程固定，结果多样 |
多年前端开发实战经验，坚持原创技术分享。擅长前端与 UI 设计融合，熟练运用 AI 提升开发效率，为不同阶段开发者提供可落地的思路与技巧。
