当前位置： 首页 > news >正文

03-JAVA设计模式-工厂模式详解

news 来源：原创 2024/5/22 10:44:06

工厂模式

工厂设计模式是一种创建型设计模式，它提供了一种封装对象创建过程的机制，将对象的创建与使用分离。
这种设计模式允许我们在不修改客户端代码的情况下引入新的对象类型。
在Java中，工厂设计模式主要有三种形式：简单工厂模式、工厂方法模式和抽象工厂模式。

简单工厂模式

用来生成同一等级结构中的任意产品。

注：对增加新的产品需要修改已有的代码，这违背了面向对象设计原则中的开闭原则（对扩展开放，对修改关闭）

UML

在这里插入图片描述

实现代码

Animal.java

// 定义一个动物的接口
public interface Animal {// 接口中定义一个抽象的方法：叫声void makeSound();
}

Cat.java

// 定义一个实现类实现Animal接口
public class Cat implements Animal{// 猫属于动物：实现发出叫声的接口@Overridepublic void makeSound() {System.out.println("喵喵喵");}
}

Dog.java

// 定义一个实现类实现Animal接口
public class Dog implements Animal{// 狗属于动物：实现发出叫声的接口@Overridepublic void makeSound() {System.out.println("汪汪汪");}
}

SimpleAnimalFactory.java

// 定义一个简单工厂类用于创建动物
public class SimpleAnimalFactory {// 定义一个创建动物的方法用于生产不同的动物的静态方法public static Animal createAnimal(String type) {if ("Cat".equalsIgnoreCase(type)) {return new Cat();}else if ("Dog".equalsIgnoreCase(type)) {return new Dog();}else  {return null;}}
}

TestClient.java

public class TestClient {public static void main(String[] args) {// 根据简单工厂创建不同的动物，执行动作// 生产一个CatAnimal cat = SimpleAnimalFactory.createAnimal("cat");cat.makeSound();// 生产一个DogAnimal dog = SimpleAnimalFactory.createAnimal("Dog");dog.makeSound();}
}

执行结果：

在这里插入图片描述

结论：

简单工厂好处在于，对于客户端调用时，我们不需要关心具体实现，只需要调用工厂方法，传入参数获取我们需要返回的结果即可。

但是对于同一个产品（动物），如果我们进行新增（猪），则必须要修改Factory中createAnimal(String type)方法。因此违背了开闭原则

工厂方法模式

用来生产同一等级结构中的固定产品。

支持增加任意产品，满足开闭原则，但设计相对于简单工厂复杂一些

UML

在这里插入图片描述

实现代码

Product.java

// 定义一个产品接口
public interface Product {//定义一个抽象的使用的方法void use();
}

ProductA.java

// ProductA实现Product接口
public class ProductA implements Product{@Overridepublic void use() {System.out.println("ProductA 使用了");}
}

ProductB.java

// ProductB实现Product接口
public class ProductB implements Product{@Overridepublic void use() {System.out.println("ProductB 使用了");}
}

ProductFactory.java

// 定义一个ProductFactory工厂接口
public interface ProductFactory {// 接口中定义一个创建Product的方法Product createProduct();
}

ProductAFactory.java

// 创建一个ProductA的工厂，实现ProductFactory接口，用于生产ProductA
public class ProductAFactory implements ProductFactory{@Overridepublic Product createProduct() {return new ProductA();}
}

ProductBFactory.java

// 创建一个ProductB的工厂，实现ProductFactory接口，用于生产ProductB
public class ProductBFactory implements ProductFactory{@Overridepublic Product createProduct() {return new ProductB();}
}

TestClient.java

public class TestClient {public static void main(String[] args) {// 创建ProductAProduct product1 = new ProductAFactory().createProduct();product1.use();// 创建ProductBProduct product2 = new ProductBFactory().createProduct();product2.use();}
}

执行结果：

在这里插入图片描述

从工厂方式模式，我们可以看出，我们可以任意增加同一产品，而不会影响到原来已有产品
（创建一个产品C继承Product接口，创建一个产品C的Factory类生产C,使用是通过相应Factory调用生产C即可）。
如果产品中新增一个方法，则所有实现了Product接口的方法都必须修改相应方法。

抽象工厂模式

用来生产不同产品族的全部产品。

对增加新的产品无能为力，支持增加产品族

UML

在这里插入图片描述

实现代码

Engine.java

// 定义发动机接口
public interface Engine {// 定义发动机 发动方法void run();// 定义发动机 停止方法void stop();
}

HighEndEngine.java

// 创建一个高端发动机实现发动机
public class HighEndEngine implements Engine{@Overridepublic void run() {System.out.println("高端发动机-跑的快");}@Overridepublic void stop() {System.out.println("高端发动机-刹车性能强");}
}

LowEndEngine.java

// 创建一个低端发动机实现发动机
public class LowEndEngine implements Engine{@Overridepublic void run() {System.out.println("低端发动机-跑的慢");}@Overridepublic void stop() {System.out.println("低端发动机-刹车性能弱");}
}

CarBody.java

// 定义一个车身接口
public interface CarBody {// 定义一个乘坐的方法void ride();
}

HighEndCarBody.java

// 创建一个高端车身实现车身
public class HighEndCarBody implements CarBody{@Overridepublic void ride() {System.out.println("高端车身-奢华-安全");}
}

LowEndCarBody.java

// 创建一个低端车身实现车身
public class LowEndCarBody implements CarBody{@Overridepublic void ride() {System.out.println("低端车身-朴素-看起来安全");}
}

Tyre.java

// 定义一个轮胎接口
public interface Tyre {// 定义轮胎转动的方法void run();
}

HighEndTyre.java

// 创建一个高端轮胎实现轮胎
public class HighEndTyre implements Tyre{@Overridepublic void run() {System.out.println("高端轮胎-太空材料-安全-耐磨");}
}

LowEndTyre.java

// 创建一个低端轮胎实现轮胎
public class LowEndTyre implements Tyre{@Overridepublic void run() {System.out.println("低端轮胎-普通材料-易磨损");}
}

CarFactory.java

// 定义Car的接口
public interface CarFactory {// 创建发动机Engine engine();// 创建车身CarBody carBody();// 创建轮胎Tyre tyre();
}

HighEndCarBody.java

// 高端汽车工厂实现汽车工厂
public class HighEndCarFactory implements CarFactory{@Overridepublic Engine engine() {return new HighEndEngine();}@Overridepublic CarBody carBody() {return new HighEndCarBody();}@Overridepublic Tyre tyre() {return new HighEndTyre();}
}

LowEndCarFactory.java

// 低端汽车工厂实现汽车工厂
public class LowEndCarFactory implements CarFactory{@Overridepublic Engine engine() {return new LowEndEngine();}@Overridepublic CarBody carBody() {return new LowEndCarBody();}@Overridepublic Tyre tyre() {return new LowEndTyre();}
}

TestClient.java

public class TestClient {public static void main(String[] args) {// 使用高端汽车工厂类 创建高端汽车HighEndCarFactory highEndCar = new HighEndCarFactory();highEndCar.engine().stop();highEndCar.carBody().ride();highEndCar.tyre().run();System.out.println("==========================");// 使用低端汽车工厂类 创建低端汽车LowEndCarFactory lowEndCar = new LowEndCarFactory();lowEndCar.engine().stop();lowEndCar.carBody().ride();lowEndCar.tyre().run();}
}

执行结果：

在这里插入图片描述

抽象工厂，不可以增加产品（比如：CarFactory一旦定下了，如果我们要新增新的部件则所有实现CarFactory的类都需实现该方法）。
但是抽象工厂，可以根据已有的接口，创建更多的产品族（比如：定义一个中端汽车工厂，调用高端发动机，低端轮胎，低端车身，等任意组合成新的Factory）

对比及应用场景

简单工厂模式

  • 优点：
    • 实现了对象的创建和使用的责任分割，客户端只需要传入正确的参数，就可以获取需要的对象，无需知道创建细节。
    • 工厂类中有必要的判断逻辑，可以决定根据当前的参数创建对应的产品实例，客户端可以免除直接创建产品对象的责任。
  • 缺点：
    • 工厂类职责过重，如果产品种类增加，工厂类的代码会变得庞大且复杂，不利于维护。
    • 简单工厂模式违背了开放封闭原则，因为每次增加新产品时，都需要修改工厂类的代码。
  • 适用场景：
    • 创建对象较少，且对象的创建逻辑不复杂时。
    • 客户端不关心对象的创建过程，只关心使用对象时。

工厂方法模式

  • 优点：
    • 将对象的创建推迟到子类中进行，使得类的实例化更加灵活和可扩展。
    • 降低了客户端与具体产品类之间的耦合度，客户端只需要知道对应的工厂，无需知道具体的产品类。
  • 缺点：
    • 增加了系统的抽象性和理解难度，需要引入额外的工厂接口和工厂类。
    • 如果产品类较少，使用工厂方法模式可能会增加不必要的复杂性。
  • 适用场景：
    • 需要创建大量相似对象时，可以使用工厂方法模式来简化对象的创建过程。
    • 当一个类需要由其子类来指定创建哪个对象时，可以使用工厂方法模式。
    • 但实际开发中，简单工厂比工厂方法使用的更多

抽象工厂模式

  • 优点：
    • 提供了创建一系列相关或相互依赖对象的接口，无需指定它们具体的类。
    • 增加了系统的灵活性和可扩展性，可以通过更换不同的工厂来实现不同的产品族。
  • 缺点：
    • 规定了所有可能被创建的产品集合，产品族中扩展新的产品困难。
    • 如果产品族中的产品较少，使用抽象工厂模式可能会导致代码冗余和复杂性增加。
  • 适用场景：
    • 当需要创建一组相互关联或相互依赖的对象时，可以使用抽象工厂模式。
    • 当一个系统需要独立地变化其创建的对象时，抽象工厂模式是一个很好的选择。

gitee源码

git clone https://gitee.com/dchh/JavaStudyWorkSpaces.git

相关文章：

  • 站群服务器好不好 多ip流量大
  • 20240327-PCL-1.41.0安装说明-VS2022-CMAKE篇
  • 在 MySQL 某数据表中针对 username 字段建立唯一索引后，基于万级数据量和百万级数据量分别进行查询某用户 A，请问两次查询的性能耗时对比如何？
  • 网址打包微信小程序源码 wap转微信小程序 网站转小程序源码 网址转小程序开发
  • adobe stock会员开通付费付款订阅充值教程/adobe stock免费白嫖一个月
  • 使用混沌加密图像（MATLAB）
  • Halcon TCP 服务端接收命令
  • vue3从精通到入门12：vue3的生命周期和组件
  • 蓝桥杯备考随手记: Scanner 类中常用方法
  • 竞赛常考的知识点大总结(五)动态规划
  • 【电源专题】电池均衡算法和均衡方式
  • 关于C#操作SQLite数据库的一些函数封装
  • keycloak - 鉴权VUE
  • 【Linux实践室】Linux高级用户管理实战指南：创建与删除用户组操作详解
  • JavaWeb前端基础（HTML CSS JavaScript）
  • AWS实战 - 利用IAM对S3做访问控制
  • Java教程_软件开发基础
  • MySQL的数据类型
  • Redash本地开发环境搭建
  • SQLServer插入数据
  • 二维平面内的碰撞检测【一】
  • 技术攻略】php设计模式(一)：简介及创建型模式
  • 简单易用的leetcode开发测试工具（npm）
  • ​2021半年盘点，不想你错过的重磅新书
  • ​人工智能书单（数学基础篇）
  • ​油烟净化器电源安全，保障健康餐饮生活
  • # MySQL server 层和存储引擎层是怎么交互数据的？
  • (1) caustics\
  • (delphi11最新学习资料) Object Pascal 学习笔记---第7章第3节（封装和窗体）
  • （附源码）spring boot校园健康监测管理系统 毕业设计 151047
  • （附源码）springboot社区居家养老互助服务管理平台 毕业设计 062027
  • （力扣）循环队列的实现与详解（C语言）
  • （五）网络优化与超参数选择--九五小庞
  • （转）Sublime Text3配置Lua运行环境
  • (转)视频码率,帧率和分辨率的联系与区别
  • **Java有哪些悲观锁的实现_乐观锁、悲观锁、Redis分布式锁和Zookeeper分布式锁的实现以及流程原理...
  • .net core 6 集成和使用 mongodb
  • .net core webapi 部署iis_一键部署VS插件：让.NET开发者更幸福
  • .net core 微服务_.NET Core 3.0中用 Code-First 方式创建 gRPC 服务与客户端
  • .NET Framework杂记
  • .NET Remoting学习笔记（三）信道
  • .net反混淆脱壳工具de4dot的使用
  • .NET下的多线程编程—1-线程机制概述
  • [2544]最短路 （两种算法）（HDU）
  • [ABC294Ex] K-Coloring
  • [android] 请求码和结果码的作用
  • [c#基础]DataTable的Select方法
  • [emacs] CUA的矩形块操作很给力啊
  • [HEOI2013]ALO
  • [Java][Liferay] File system in liferay
  • [javaSE] GUI（事件监听机制）
  • [javaSE] 看知乎学习工厂模式
  • [LeetCode]—Implement strStr() 寻找子串匹配第一个位置 （KMP）
  • [LOJ 6213]「美团 CodeM 决赛」radar
  • [loj6039]「雅礼集训 2017 Day5」珠宝 dp+决策单调性+分治