设计模式之工厂模式(简单工厂/工厂方法/抽象工厂)

最新推荐文章于 2024-11-03 11:01:20 发布
最新推荐文章于 2024-11-03 11:01:20 发布
阅读量184 收藏
点赞数
分类专栏： 设计模式 java 文章标签： java 设计模式
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/weixin_42310146/article/details/103082328
版权

文章目录

什么是工厂模式

工厂模式（Factory Pattern）是 Java 中最常用的设计模式之一。简单的说就是使用一个共同的接口来指向新创建的对象。
本文章主要阐述工厂模式的三种实现方法,即简单工厂/工厂方法/抽象工厂,下面一一举例.

简单工厂模式

首先我要说的是简单工厂不属于23种设计模式之一, 简单工厂模式在创建一个对象时不向客户暴露内部细节，并提供一个创建对象的通用接口。
通过专门定义一个工厂类来负责创建其它类的实例，被创建的实例通常都具有共同的父类.

简单工厂模式包含三种角色:

  • 工厂角色
    用来创建所有实例的内部逻辑,可以被外界直接调用.
  • 抽象角色
    所有对象的父类，它负责描述所有实例所共有的公共接口。
  • 具体产品角色
    创建的具体的实例对象。
    在这里插入图片描述
    举一个简单工厂的实例:
    在这里插入图片描述

Operator为一个抽象角色,包含numberA和numberB和一个getResult的方法,用于获取结果

/**
* 计算器抽象类
*/
public abstract class Operator{
    private double numberA;
    private double numberB;
    
    //获取结果的抽象方法
    protected abstract double getResult() throws Exception;
    
    // getter和setter方法省略
    ...
}

具体的产品角色,包含加减乘除四个类都继承Operator.

/*
*  加法计算类
*/
public class AddOperator extends Operator{
    //实现父类的抽象方法
    @Override
    protected double getResult(){
        return getNumberA() + getNumberB();
    }
}

/*
*  减法计算类
*/
public class SubOperator extends Operator{
    @Override
    protected double getResult(){
        return getNumberA() - getNumberB();
    }
}

/*
*  乘法计算类
*/
public class MulOperator extends Operator{
    @Override
    protected double getResult(){
        return getNumberA() * getNumberB();
    }
}

/*
*  除法计算类
*/
public class MulOperator extends Operator{
    @Override
    protected double getResult() throws Exception{
        if(getNmberB() == 0.0){
            throw new Exception("除数不能为0");
        }else{
            return getNumberA() / getNumberB();
        }
    }
}

简单工程类,创建一个createOperator方法,返回Operator 对象:

/**
 * 简单工厂类
 */
public class OperatorFactory {
    public static Operator createOperator(String operation){
        Operator operator = null;
        switch (operation){
            case "+":
                operator = new AddOperator();
                break;
            case "-":
                operator = new SubOperator();
                break;
            case "*":
                operator = new MulOperator();
                break;
            case "/":
                operator = new DivOperator();
                break;
        }
        return operator;
    }
}

简单测试下:

 		Operator operator = OperatorFactory.createOperator("+");
        operator.setNumberA(10);
        operator.setNumberB(5);
        try {
            System.out.println(operator.getResult());
        } catch (Exception e) {
            e.printStackTrace();
        }

打印结果: 15

但是,当我们新添功能的时候,无疑需要在工程类中添加逻辑,还要去添加一个新的类,无疑代码的耦合性很高,所以就出现了工厂模式.

工厂模式

核心的工厂类不再负责所有产品的创建，而是将具体创建的工作交给子类去做。
在简单工厂中，创建对象的是工厂类，而在工厂方法中，是由子类来创建对象。
在这里插入图片描述
如下图,我们写出代码:
在这里插入图片描述
工程类接口:

public class OperatorFactory {

    public static Operator createAddOperator(){
        return new AddOperator();
    }

    public static Operator createSubOperator(){
        return new SubOperator();
    }

    public static Operator createMulOperator(){
        return new MulOperator();
    }

    public static Operator createDivOperator(){
        return new DivOperator();
    }
}

测试下:

	    Operator operator = OperatorFactory.createAddOperator();
        operator.setNumberA(10);
        operator.setNumberB(5);
        try {
            System.out.println(operator.getResult());
        } catch (Exception e) {
            e.printStackTrace();
        }

打印结果: 15

工厂方法模式避免了因为传入字符串错误而导致无法正常创建对象的问题,但是增加一个产品时必须增加一个产品类和实现工厂.在一定程度上增加了系统的复杂度.

抽象工厂模式

抽象工厂模式是提供一个接口，用于创建相关的对象家族 。
抽象工厂模式中包含的角色及职责：

  • 抽象工厂角色（Creator）
    这是抽象工厂模式的核心，任何工厂类必须实现这个接口。
  • 具体工厂角色（Concrete Creator）
    它是抽象工厂的一个实现.
  • 抽象角色（Product）
    抽象工厂模式所创建的所有对象的父类，它负责描述所有实例所共有的公共接口。
  • 具体产品角色（Concrete Product）
    抽象工厂模式所创建的具体的实例对象。
    创建一个抽象角色的接口:
public interface Shape{
    void draw();
}

创建实现类:

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

public class Square implements Shape{
    @Override
    public void draw(){
        System.out.println("方形形状");
    }
}

public class Circle implements Shape{
    @Override
    public void draw(){
        System.out.println("园形形状");
    }
}

创建一个颜色接口（抽象角色）

public interface Color{
    void fill();
}

写实现类:

public class Red implements Color{
    @Override
    public void fill(){
        System.out.println("红色");
    }
}

public class Blue implements Color{
    @Override
    public void fill(){
        System.out.println("蓝色");
    }
}

public class Green implements Color{
    @Override
    public void fill(){
        System.out.println("绿色");
    }
}

创建抽象工厂:

public abstract class AbstractFactory{
    public abstract Color getColor(String color);
    public abstract Shape getShape(String shape);
}

创建扩展了AbstractFactory的工厂类（具体工厂类）:

public class ShapeFactory extends AbstractFactory{
    @Override
    public Shape getShape(String shapeType){
        if(shapeType == null){
            return null;
        }
        if(shapeType.equalsIgnoreCase("circle")){
            return new Circle();
        }esle if(shapeType.equalsIgnoreCase("rectangle")){
            return new Rectangle();
        }else if(shapeType.equalsIgnoreCase("square")){
            return new Square();
        }
        return null;
    }
    
    @Override
    public Color getColor(String color){
        return null;
    }
}

public class ColorFactory extends AbstractFactory {
    
   @Override
   public Shape getShape(String shapeType){
      return null;
   }
   
   @Override
   public Color getColor(String color) {
      if(color == null){
         return null;
      }        
      if(color.equalsIgnoreCase("red")){
         return new Red();
      } else if(color.equalsIgnoreCase("green")){
         return new Green();
      } else if(color.equalsIgnoreCase("blue")){
         return new Blue();
      }
      return null;
   }
}

创建工厂生成器

public class FactoryProducer {
   public static AbstractFactory getFactory(String choice){
      if(choice.equalsIgnoreCase("shape")){
         return new ShapeFactory();
      } else if(choice.equalsIgnoreCase("color")){
         return new ColorFactory();
      }
      return null;
   }
}

测试下:

public class AbstractFactoryPatternDemo {
   public static void main(String[] args) {
 
      //获取形状工厂
      AbstractFactory shapeFactory = FactoryProducer.getFactory("SHAPE");
 
      //获取形状为 Circle 的对象
      Shape shape1 = shapeFactory.getShape("CIRCLE");
 
      //调用 Circle 的 draw 方法
      shape1.draw();
 
      //获取形状为 Rectangle 的对象
      Shape shape2 = shapeFactory.getShape("RECTANGLE");
 
      //调用 Rectangle 的 draw 方法
      shape2.draw();
      
      //获取形状为 Square 的对象
      Shape shape3 = shapeFactory.getShape("SQUARE");
 
      //调用 Square 的 draw 方法
      shape3.draw();
 
      //获取颜色工厂
      AbstractFactory colorFactory = FactoryProducer.getFactory("COLOR");
 
      //获取颜色为 Red 的对象
      Color color1 = colorFactory.getColor("RED");
 
      //调用 Red 的 fill 方法
      color1.fill();
 
      //获取颜色为 Green 的对象
      Color color2 = colorFactory.getColor("Green");
 
      //调用 Green 的 fill 方法
      color2.fill();
 
      //获取颜色为 Blue 的对象
      Color color3 = colorFactory.getColor("BLUE");
 
      //调用 Blue 的 fill 方法
      color3.fill();
   }
}

总结: 抽象工厂模式由Producer去创建实现抽象工厂的子类,再由这些子类去调用具体的方法.可以创建多个抽象产品类.

超人很能飞
关注
专栏目录
Java的setter方法和getter方法的使用
前端学习之地
12-07 3万+
java有三大特性：封装，继承还有多态。                   而今天，我来讲一下其中最重要的特性之一：封装。           首先，属性可用来描述同一类事物的特征，方法可描述一类事物可做的操作。封装就是把属于同一类事物的共性（包括属性与方法）归到一个类中，以方便使用。           1.概念：封装也称为信息隐藏，是指利用抽象数据类型将数据和基于数据的操作封装在一起，
Flink1.15源码解析之OperatorChain
qq_24186017的博客
09-24 686
本文首先总结在什么情况下算子能组成一个operate chain,并根据wordcount代码一步步进入真正判断isChainable进行源码解析(Flink 1.15.2版本)
用VS2005实现一个计算器功能（利用抽象工厂模式编写）
09-23
用VS2005实现一个简单的计算器功能（利用抽象工厂模式编写）
抽象工厂模式实现计算器
10-06
抽象工厂模式实现计算器源码，学习C#设计模式。
设计模式-简单工厂模式-计算器
咸鱼塘
06-27 1557
简单工厂模式及就是为了降低其内部的耦合，使得业务代码更加注重于业务，而且易于后期的维和。此处用一个简单的计算器实例来进行举例说明， Operation类 package One; /** * 抽象类,主要有一些所有运算共有的属性 * @author 焦焱 * */ public abstract class Operation { public double number...
设计模式：简单工厂模式、工厂方法模式、抽象工厂模式
李白
01-02 1300
简单工厂模式适用于创建对象较少且变化不频繁的情况，工厂方法模式适用于创建对象较多且需要灵活扩展的情况，而抽象工厂模式适用于创建一组相关对象的情况。 所有的工厂模式都强调一点：两个类A和B之间的关系应该仅仅是A创建B或是A使用B，而不能两种关系都有。将对象的创建和使用分离，也使得系统更加符合单一职责原则，有利于对功能的复用和系统的维护。此外，将对象的创建和使用分离还有一个好处：防止用来实例化一个类的数据和代码在多个类中到处都是，可以将有关创建的知识搬移到一个工厂类中。
Java设计模式之创建型：工厂模式详解（简单工厂+工厂方法+抽象工厂）
热门推荐
张维鹏的博客
09-13 8万+
工厂模式将目的将创建对象的具体过程屏蔽隔离起来，从而达到更高的灵活性，工厂模式可以分为三类：简单工厂模式、工厂方法模式、抽象工厂模式；简单工厂模式的核心是定义一个创建对象的接口，将对象的创建和本身的业务逻辑分离。工厂方法模式将工厂抽象化，并定义一个创建对象的接口。每增加新产品，只需增加该产品以及对应的具体实现工厂类，由具体工厂类决定要实例化的产品是哪个，将对象的创建与实例化延迟到子类。抽象工厂模式用于创建相关对象的家族。当一个产品族中需要被设计在一起工作时，通过抽象工厂模式，保证客户端始终只使用同一个产品族
设计模式深度解析：工厂方法模式与抽象工厂模式的深度对比
制定明确可量化的目标，坚持默默的做事。
03-11 8844
本文旨在深入对比软件设计模式中的工厂方法模式和抽象工厂模式。工厂方法模式侧重于定义一个用于创建对象的接口，让子类决定实例化哪一个类。它提供了一种封装机制，将对象的创建与使用分离，降低了耦合度。而抽象工厂模式则提供了一个接口，用于创建相关或依赖对象的家族，而不需要明确指定具体类。这种模式具有更强的扩展性，能够适应更为复杂的产品结构。通过对比分析，我们发现，两种模式各有优势，工厂方法模式更适用于单一产品的创建，而抽象工厂模式在处理产品族问题时更为得力。在选择使用哪种模式时，需根据具体的应用场景和需求进行综合考量
设计模式1---简单工厂模式、工厂方法模式、抽象工厂模式
csdn_csuers的博客
08-01 1081
其中，创建型模式，共五种：工厂方法模式、抽象工厂模式、单例模式、建造者模式、原型模式。本文将介绍2 种，其中，工厂方法模式一般可以分为简单工厂模式及工厂模式。
23种设计模式之抽象工厂模式（Abstract Factory Pattern）
小威的博客
05-10 2万+
本篇文章将23种设计模式中的抽象工厂模式，此篇文章为一天学习一个设计模式系列文章，后面会分享其他模式知识。
Java工厂模式：简单工厂、工厂方法模式、抽象工厂模式代码示例
08-12
工厂模式是Java设计模式中的一种创建型模式，旨在提供一种将对象创建与其实现分离的机制，增加软件的灵活性和可维护性。在Java中，工厂模式分为三种：简单工厂、工厂方法模式和抽象工厂模式。 **简单工厂模式** 是...
C# 设计模式系列教程-抽象工厂模式
12-26
 2.1 抽象工厂（AbstractFactory）：担任这个角色的是工厂方法模式的核心，它是与应用系统商业逻辑无关的。  2.2 具体工厂（ConcreteFactory）：这个角色直接在客户端的调用下创建产品的实例。这个角色含有选择...
设计模式之抽象工厂模式-c++
09-18
抽象工厂模式（Abstract Factory Pattern）是一种创建型设计模式，提供一个接口用于创建一系列相关或相互依赖的对象，而无需指定它们的具体类。这种模式常用于需要跨多个产品系列进行实例化的场景。 抽象工厂模式的...
C++设计模式之抽象工厂模式
01-21
之前讲到了C++设计模式——工厂方法模式，我们可能会想到，后期产品会越来越多了，建立的工厂也会越来越多，工厂进行了增长，工厂变的凌乱而难于管理；由于工厂方法模式创建的对象都是继承于Product的，所以工厂方法...
C# 设计模式之抽象工厂模式
鲤籽鲲的博客
08-01 1266
C# 设计模式之抽象工厂模式
【设计模式】简单工厂模式——以一个简单的计算器为例
jiange_zh的博客
12-04 6933
本文内容参考自《大话设计模式》（程杰 著） 1.拙劣的代码class Program{ static void Main(string[] args) { Console.Write("请输入数字A："); string A = Console.ReadLine(); Console.Write("请选择运算符号(+、-、*、/)：");
HashMap为什么线程不安全？
最新发布
rnnf_yyds的博客
11-03 328
HashMap底层是基于数组 + 链表（在 Java 8 以后，当链表长度超过一定阈值时会转换为红黑树）的数据结构。在多线程环境下，当多个线程同时对HashMap进行put操作时，可下面这种情况：假设两个线程 A 和 B 同时执行put操作，它们计算出的插入位置相同（假设为index线程 A 先获取到了当前index位置的节点，在它还没来得及将新节点插入链表（或树）时，线程 B 也获取到了这个位置的节点。
[自用，更新自day5]瑞吉外卖代码及笔记
lapiii的博客
11-01 851
当使用ThreadLocal维护变量时，ThreadLocal为每个使用该变量的线程提供独立的变量副本，所以每一个线程都可以独立地改变自己的副本，而不会影响其它线程所对应的副本。Mybatis Plus公共字段自动填充，也就是在插入或者更新的时候为指定字段赋予指定的值，使用它的好处就是可以统一对这些字段进行处理，避免了重复代码。因为在分页查询的Dish的records(菜品记录中)，只有这个菜品所属的categoryId，但是我们需要分页的时候展示的是菜品名字。
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值