Java 简单工厂 工厂方法 抽象工厂模式

最新推荐文章于 2024-07-28 19:41:52 发布
最新推荐文章于 2024-07-28 19:41:52 发布
阅读量386 收藏
点赞数 1
分类专栏： 设计模式 文章标签： java 抽象工厂模式 开发语言
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/weixin_43554422/article/details/122319845
版权

参考程杰《大话设计模式》

工厂模式：为创建对象提供过度接口，以便将创建对象的具体过程隐藏起来。

（1）简单工厂模式Simple Factory：不利于产生系列产品；
（2）工厂方法模式Factory Method：又称为多形性工厂；
（3）抽象工厂模式Abstract Factory：又称为工具箱，产生产品族，但不利于产生新的产品；

三种工厂模式逐步抽象。GoF中工厂模式只分为两类，工厂方法和抽象工厂，认为简单工厂是工厂方法的一种特例而已。

简单工厂模式

使用工厂创建不同的对象

在这里插入图片描述

当需要增加一个Operation时，需要先增加一个继承自Operation的子类，然后在工厂的switch里增加新的分支。

实例

定义枚举类型，作为工厂里switch的类型

public enum OperationTypeEnum {
    ADD(0),
    SUB(1),
    MUL(2),
    DIV(3)
    ;
    private Integer code;

    OperationTypeEnum(Integer code) {
        this.code = code;
    }
}

创建操作的基类，和其子类，子类实现自己的相关逻辑

public abstract class Operation {
    protected double numA;
    protected double numB;
    public abstract double getResult() throws Exception;

    public Operation(double numA, double numB) {
        this.numA = numA;
        this.numB = numB;
    }

    public void setNumA(double numA) {
        this.numA = numA;
    }

    public void setNumB(double numB) {
        this.numB = numB;
    }

    public Operation() {
    }
}

public class OperationAdd extends Operation{
    @Override
    public double getResult() {
        return numA + numB;
    }
}

public class OperationSub extends Operation{
    @Override
    public double getResult() {
        return numA - numB;
    }
}

public class OperationMul extends Operation {
    @Override
    public double getResult() {
        return numA * numB;
    }
}

public class OperationDiv extends Operation {
    final double exp = 0.00001d;
    @Override
    public double getResult() throws Exception {
        if(Math.abs(numB - 0d) < exp){
            throw new Exception("除数不能为0");
        }
        return numA / numB;
    }
}

工厂类，根据不同枚举，生产不同子类

public class SimpleFactory {

    public static Operation creatOperation(OperationTypeEnum type){
        switch (type){
            case ADD:
                return new OperationAdd();
            case SUB:
                return new OperationSub();
            case MUL:
                return new OperationMul();
            case DIV:
                return new OperationDiv();
            default:
                return null;
        }
    }
}

使用

public class TestdemoApplication {
    public static void main(String[] args) {
        double numA = 100.954d;
        double numB = 21.2d;
        Operation operation = SimpleFactory.creatOperation(OperationTypeEnum.ADD);
        operation.setNumA(numA);
        operation.setNumB(numB);
        System.out.println(operation.getResult());

        operation = SimpleFactory.creatOperation(OperationTypeEnum.SUB);
        operation.setNumA(numA);
        operation.setNumB(numB);
        System.out.println(operation.getResult());

        operation = SimpleFactory.creatOperation(OperationTypeEnum.MUL);
        operation.setNumA(numA);
        operation.setNumB(numB);
        System.out.println(operation.getResult());

        operation = SimpleFactory.creatOperation(OperationTypeEnum.DIV);
        operation.setNumA(numA);
        operation.setNumB(numB);
        System.out.println(operation.getResult());
    }
}

输出结果

在这里插入图片描述

工厂方法模式

定义一个用于创建对象的接口，让子类决定实例化哪一个类。工厂方法使一个类的实例化延迟到其子类。

在这里插入图片描述

当需要增加一个Operation时，不需要修改已有代码，只需要先增加一个继承自Operation的子类，再新增一个工厂子类，用来生产新的Operation子类。

实例

工厂接口和其子类，即具体生成不同产品的子工厂

public interface Factory {
    Operation createOperation();
}

public class AddFactory implements Factory {
    @Override
    public Operation createOperation() {
        return new OperationAdd();
    }
}

public class SubFactory implements Factory {
    @Override
    public Operation createOperation() {
        return new OperationSub();
    }
}

public class MulFactory implements Factory {
    @Override
    public Operation createOperation() {
        return new OperationMul();
    }
}

public class DivFactory implements Factory {
    @Override
    public Operation createOperation() {
        return new OperationDiv();
    }
}

创建操作的基类，和其子类，子类实现自己的相关逻辑

public abstract class Operation {
    protected double numA;
    protected double numB;
    public abstract double getResult() throws Exception;

    public Operation(double numA, double numB) {
        this.numA = numA;
        this.numB = numB;
    }

    public void setNumA(double numA) {
        this.numA = numA;
    }

    public void setNumB(double numB) {
        this.numB = numB;
    }

    public Operation() {
    }
}

public class OperationAdd extends Operation{
    @Override
    public double getResult() {
        return numA + numB;
    }
}

public class OperationSub extends Operation{
    @Override
    public double getResult() {
        return numA - numB;
    }
}

public class OperationMul extends Operation {
    @Override
    public double getResult() {
        return numA * numB;
    }
}

public class OperationDiv extends Operation {
    final double exp = 0.00001d;
    @Override
    public double getResult() throws Exception {
        if(Math.abs(numB - 0d) < exp){
            throw new Exception("除数不能为0");
        }
        return numA / numB;
    }
}


使用

```java
public class TestdemoApplication {
    public static void main(String[] args) {
        double numA = 100.954d;
        double numB = 21.2d;
        //先创建工厂
        Factory factory = new AddFactory();
        Operation operation = factory.createOperation();
        operation.setNumA(numA);
        operation.setNumB(numB);
        System.out.println(operation.getResult());

        factory = new SubFactory();
        operation = factory.createOperation();
        operation.setNumA(numA);
        operation.setNumB(numB);
        System.out.println(operation.getResult());

        factory = new MulFactory();
        operation = factory.createOperation();
        operation.setNumA(numA);
        operation.setNumB(numB);
        System.out.println(operation.getResult());

        factory = new DivFactory();
        operation = factory.createOperation();
        operation.setNumA(numA);
        operation.setNumB(numB);
        System.out.println(operation.getResult());
    }
}

输出结果

在这里插入图片描述

抽象工厂模式

提供一个创建一系列相关或相互依赖对象的接口，而无需指定它们具体的类。

在这里插入图片描述

如果要新增一个产品，需要新增的类很多，如下实例中，需要新增产品的抽象类（ProductComputer），新增其实现类（AppleProductComputer，MiProductComputer），修改工厂类（Factory，AppleFactory，MiFactory新增createPadComputer()方法）

实例

工厂相关接口和实现类

public interface Factory {
    ProductPhone createPhone();

    ProductPad createPad();
}

//生成苹果产品的工厂
public class AppleFactory implements Factory{
    @Override
    public ProductPhone createPhone() {
        return new AppleProductPhone();
    }

    @Override
    public ProductPad createPad() {
        return new AppleProductPad();
    }
}

//生成小米产品的工厂
public class MiFactory implements Factory{
    @Override
    public ProductPhone createPhone() {
        return new MiProductPhone();
    }

    @Override
    public ProductPad createPad() {
        return new MiProductPad();
    }
}

产品相关接口和实现类

//产品--手机
public interface ProductPhone {
    void installScreen();

    void installkeyboard();
}

public class AppleProductPhone implements ProductPhone{
    @Override
    public void installScreen() {
        System.out.println("安装苹果手机屏幕");
    }

    @Override
    public void installkeyboard() {
        System.out.println("安装苹果手机键盘");
    }
}

public class MiProductPhone implements ProductPhone{
    @Override
    public void installScreen() {
        System.out.println("安装小米手机屏幕");
    }

    @Override
    public void installkeyboard() {
        System.out.println("安装小米手机键盘");
    }
}


//产品--平板
public interface ProductPad {
    void installScreen();

    void installkeyboard();
}

public class AppleProductPad implements ProductPad{
    @Override
    public void installScreen() {
        System.out.println("安装苹果平板屏幕");
    }

    @Override
    public void installkeyboard() {
        System.out.println("安装苹果平板键盘");
    }
}

public class MiProductPad implements ProductPad{
    @Override
    public void installScreen() {
        System.out.println("安装小米平板屏幕");
    }

    @Override
    public void installkeyboard() {
        System.out.println("安装小米平板键盘");
    }
}

使用

public class TestdemoApplication {
    public static void main(String[] args) {
        Factory factory = new MiFactory();
        ProductPhone phone = factory.createPhone();
        ProductPad pad = factory.createPad();
        phone.installkeyboard();
        phone.installScreen();
        pad.installkeyboard();
        pad.installScreen();
    }
}

输出结果

在这里插入图片描述

总结

  • 简单工厂模式最大优点在于工厂类中包含了必要的逻辑判断，根据客户的选择条件动态实例化相关类，对于客户端来说，去除了与具体产品的依赖
  • 工厂方法模式，客户端需要决定实例化哪一个工厂来实现运算类，选择判断的问题还存在，但是判断是在客户端做的。
  • 抽象工厂模式最大好处是便于交换产品系列，具体的工厂在初始化时改变，即可改变不同的产品配置。并且具体的创建实例过程与客户端分离，客户端只是通过它们的抽象接口操纵实例，产品的具体类名也被具体工厂的实现分离，不会出现在客户代码中。
  • 所有在用简单工厂的地方，都可以考虑用反射+配置文件方式去除switch或if分支，解除分支判断带来的耦合。
Willow
关注
  • 1
    点赞
  • 踩
  • 0
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
专栏目录
java三大工厂模式（简单工厂模式，工厂方法模式，抽象工厂模式）
QyangR1123的博客
10-13 757
工厂模式主要是通过把创建对象的代码包装起来，做到创建对象的代码与具体的业务逻辑代码相隔离的目的。工厂模式可以细分为：简单工厂模式，工厂方法模式，抽象工厂模式。通过我们上面的各种例子，我们可以发现不管我们怎么修改设计方式，都不能够同时满足灵活性高和不违反开闭原则。如果要同时满足的话，就需要引入反射的思想，通过反射+抽象工厂的方式实现。
Java基础：简单工厂模式、工厂方法模式和抽象工厂模式综合概述
zhouwenxiamg的博客
04-23 664
抽象工厂模式则适用于需要创建一族相关或相互依赖的对象（产品族）的情况。假设图形应用程序除了形状之外，还引入了颜色概念，每种形状可以有不同的颜色（如红色圆形、蓝色圆形）。简单工厂模式、工厂方法模式和抽象工厂模式是面向对象设计中用来实现对象创建灵活性的三种不同形式的工厂模式。这个方法通常存在于一个单独的“工厂”类中，负责处理对象的创建细节。抽象工厂模式提供一个创建一系列相关或相互依赖对象的接口，而无需指定它们具体的类。假设有一个图形绘制应用程序，需要创建不同类型的图形（如圆形、矩形、三角形）。
Java设计模式之创建型：工厂模式详解（简单工厂+工厂方法+抽象工厂）
热门推荐
张维鹏的博客
09-13 8万+
工厂模式将目的将创建对象的具体过程屏蔽隔离起来，从而达到更高的灵活性，工厂模式可以分为三类：简单工厂模式、工厂方法模式、抽象工厂模式；简单工厂模式的核心是定义一个创建对象的接口，将对象的创建和本身的业务逻辑分离。工厂方法模式将工厂抽象化，并定义一个创建对象的接口。每增加新产品，只需增加该产品以及对应的具体实现工厂类，由具体工厂类决定要实例化的产品是哪个，将对象的创建与实例化延迟到子类。抽象工厂模式用于创建相关对象的家族。当一个产品族中需要被设计在一起工作时，通过抽象工厂模式，保证客户端始终只使用同一个产品族
Java设计模式 | 抽象工厂模式
但行好事，莫问前程
03-20 1094
抽象工厂模式是工厂方法模式的升级版本，工厂方法模式只生产一个等级的产品，而抽象工厂模式可生产多个等级（种类）的产品。要点+demo！
Java设计模式之四：抽象工厂模式详细解析
Simon学Java
02-16 1625
抽象工厂模式是一种创建类模式，它提供了一种封装一组具有共同主题的单个工厂的方法。在抽象工厂模式中，客户端不需要知道实例是如何创建的，只需知道工厂的名字即可。这种模式可用于将一组具有共同主题的工厂对象的创建过程与他们的实际使用过程分离。抽象工厂模式（Abstract Factory Pattern）定义：提供一个创建一系列相关或相互依赖对象的接口，而无需指定它们具体的类。抽象工厂模式是工厂方法模式的升级，它提供了一种接口，用于创建一系列相关的或相互依赖的对象，而不需要指定它们的具体类。
Java设计模式之工厂方法模式和抽象工厂模式
cssweb_sh的博客
07-05 428
Java设计模式之工厂方法模式与抽象工厂模式学习分享
探索Java设计模式：抽象工厂模式
放码过来
04-21 953
*抽象工厂模式（Abstract Factory Pattern）**是一种创建型设计模式，它提供了一种创建相关或依赖对象家族的接口，而无需指定具体的类。抽象工厂模式的核心在于创建一系列相关的产品族，每个产品族中的产品具有一定的关联性或一致性，且各产品族之间可能互斥或不兼容。这种模式能够保证客户端代码使用的一组相关对象来自同一个“家族”。封装复杂性：隐藏了具体产品的创建细节，客户端只需与抽象工厂交互，简化了对象的创建过程。隔离变化。
java设计模式学习之【抽象工厂模式】
qq_33129875的博客
11-27 1388
这篇教程不仅提供了抽象工厂模式的理论基础，还通过具体的Java代码示例展示了如何实现和应用这种模式。简单理解，通俗易懂
工厂方法模式、抽象工厂模式
时光里的博客
06-22 2870
工厂系列 定义: 工厂模式主要是为创建对象提供过渡接口，以便将创建对象的具体过程屏蔽隔离起来，达到提高灵活性的目的。 分类: 工厂模式在《Java 与模式》中分为三类：这三种模式从上到下逐步抽象，并且更具一般性 简单工厂模式（Simple Factory） 工厂方法模式（Factory Method） 抽象工厂模式（Abstract Factory） GOF 在《设计模式》一书中将工厂模式分为两类：工厂方法模式（Factory Method）与抽象工厂模式（Abstract Factory）。将简
Java设计模式：工厂模式之简单工厂、工厂方法、抽象工厂（三）
码到三十五
02-28 5499
在软件设计中，工厂模式是一种常见的设计模式，它提供了一种创建对象的最佳方式。通过工厂模式，我们可以将对象的创建逻辑与使用逻辑分离，降低代码的耦合度，提高系统的可扩展性和可维护性。Java作为一种面向对象的编程语言，自然也支持工厂模式的实现。接下来，我们将详细介绍Java中工厂模式的多种实现方式。
golang 接口
m0_70982551的博客
07-24 899
接口定义了一组方法，这些方法没有具体的实现。接口类型的变量可以存储任何实现了这些方法的类型的值。// 更多方法...在Go语言中，接口值是指存储了实现某个接口的具体类型值的变量。接口值由两部分组成：1.动态类型：这是接口值当前存储的实际类型。2.动态值：这是实际存储的值，该值必须实现了接口中定义的所有方法。
Swagger使用Map接受参数时，页面如何显示具体参数及说
a1058926697的博客
07-26 479
后端使用Map接受参数，要求在swagger页面上显示具体的参数名称、类型及说明。当Map接受参数数量少时，可以使用Swagger自带的注解。自定义注解 @ApiGlobalModel。编写处理注解对应的插件。
springboot之自动装配
weixin_50153914的博客
07-23 593
Spring Boot 通过一系列注解和条件配置实现了自动装配机制，使得开发者无需手动配置大量的 XML 文件或 Java 配置类。自动配置机制利用文件中的自动配置类，并结合条件注解和组件扫描，实现了灵活且强大的自动装配功能。这样，开发者可以专注于业务逻辑的实现，而无需处理繁琐的配置细节。
Java的@DateTimeFormat注解与@JsonFormat注解的使用对比
訾博（ZiBo）的博客
07-27 564
在Spring和Jackson框架中，日期和时间格式化是一个常见需求。注解主要用于Spring的表单绑定，而注解则用于Jackson的JSON序列化和反序列化。了解这两个注解的使用场景和方法，可以帮助开发者更高效地处理日期和时间。和是处理日期和时间格式化的两个重要注解。主要用于Spring MVC的请求参数绑定，而主要用于Jackson的JSON序列化和反序列化。了解它们的使用场景和功能，可以帮助开发者更高效地处理日期和时间格式化需求。通过本文的介绍，希望读者能够更清晰地理解和。
Java修炼 2024.7.26 0:24
2301_80011650的博客
07-26 408
问题：编写一个方法，找出一个数组中的众数（出现次数超过数组长度一半的元素）。例如，输入 [2, 2, 1, 1, 2]，输出 2。编写一个方法，找出一个整数数组中的第二大元素。例如，输入 [3, 5, 1, 8, 7]，输出 7。例如，输入 5，输出 5。问题：编写一个方法，将给定的字符串逆转。问题：使用数组实现栈，并提供基本操作（push、pop、peek、isEmpty）。问题：实现一个单向链表，并提供基本的操作（添加、删除、查找元素）。问题：编写一个方法来查找一个给定字符串的所有子串。
Java代码基础算法练习-数的特性-2024.07.25
Sakurapaid的博客
07-25 351
小A喜欢两种性质都成立的数字，小B喜欢至少符合一种性质的数字，小C喜欢不符合这两种性质的 数字。给出一个数字，请输出三个人是否喜欢这个数字。如果喜欢输出1，否则输出0，用空格分隔。输入数字 num，先定义三个整型代表三个人的喜欢与否，先默认设为 0。之后判断num对于性质1、2的条件，分别用 boolen 类型标识。对于每个整型进行判断，是否改为 1 代表喜欢。性质2：大于4且不大于12;
新建springboot项目找不到java版本8?
最新发布
weixin_74009895的博客
07-28 86
新建springboot项目找不到java版本8?
SSM框架整合——常用方式整合SSM框架（三）Spring和MyBatis整合
PAP
07-26 172
SSM框架整合——常用方式整合SSM框架（三）Spring和MyBatis整合
19.jdk源码阅读之FutureTask
前端、移动端、后端源码级底层原理分享
07-25 862
FutureTask 是 Java 并发包中的一个重要类，它实现了 RunnableFuture 接口，结合了 Future 和 Runnable 的特性。FutureTask 通常用于异步任务的执行和结果的获取。
JAVA工厂模式详解：简单工厂、工厂方法、抽象工厂
工厂模式可以分为三种形态：简单工厂模式、工厂方法模式和抽象工厂模式。通过使用工厂模式，我们可以将实例化的具体过程封装起来，使得客户端在使用时无需关心具体的实现类，只需通过工厂获取对象。文档提供了简单的...
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

1.余额是钱包充值的虚拟货币，按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载，可以购买VIP、付费专栏及课程。

余额充值