首页 > 其他分享 >设计模式之工厂模式

设计模式之工厂模式

时间：2023-06-20 21:55:06浏览次数：29  
标签：draw return 对象 模式 工厂 Shape 设计模式 public

工厂模式是一种对象创建型模式，它提供了一种创建对象的最佳实践。在工厂模式中，我们在创建对象时不使用 new 关键字，而是通过调用工厂方法来创建对象。工厂方法是一种在子类中定义的方法，该方法负责实例化对象。工厂方法可以返回不同的对象类型，因此工厂模式可以创建一组相关或不相关的对象。这样就可以将对象的创建和使用解耦。

简介

工厂模式有三种类型：简单工厂模式、工厂方法模式和抽象工厂模式。

  • 简单工厂模式是最基本的工厂模式，它通过一个工厂类来创建所有需要的对象。简单工厂模式将对象的创建逻辑封装在一个工厂类中，客户端通过调用工厂类的静态方法来创建对象。
  • 工厂方法模式是对简单工厂模式的改进，它定义了一个用于创建对象的接口或抽象类，让子类决定实例化哪一个类。工厂方法模式将对象的创建过程延迟到子类中进行，从而实现了开闭原则。

工厂方法模式

  • 抽象工厂模式是对工厂方法模式的扩展，它提供了一个创建一系列相关或相互依赖对象的接口或抽象类，而无需指定它们具体的类。抽象工厂模式可以创建多个产品族，每个产品族由多个具体产品组成。

抽象工厂模式

好处和坏处

工厂模式的好处有：

  • 可以将对象的创建和使用解耦，从而提高系统的灵活性和可维护性。
  • 工厂模式可以隐藏对象的创建细节，使客户端只关心对象的使用，从而降低系统的复杂度。
  • 工厂模式可以实现开闭原则，当需要增加新的产品时，只需要增加相应的工厂类即可，无需修改原有代码。

工厂模式的坏处有：

  • 工厂模式会增加系统中类的数量，当产品类型较多时，会导致系统过于庞大和复杂。
  • 工厂模式需要引入抽象层，这会增加系统的抽象性和理解难度。
  • 工厂模式可能会导致类层次过多，增加系统设计难度。

应用场景

工厂模式适用于以下场景：

  • 当需要创建的对象类型较多时，可以使用工厂模式来避免大量的new操作。
  • 当需要根据不同的条件或参数来创建不同类型的对象时，可以使用工厂模式来实现条件分支的替代。
  • 当需要将对象的创建和使用解耦时，可以使用工厂模式来实现依赖倒置原则。

Java代码示例

以下是使用Java实现的三种工厂模式的代码示例。

简单工厂模式

假设我们有一个 Shape 接口和三个实现类 Circle、Rectangle 和 Square，我们想要根据给定的形状类型来创建相应的对象。

首先，我们定义一个 Shape 接口和三个实现类：

// Shape接口
public interface Shape {
    void draw();
}

// Circle类
public class Circle implements Shape {
    @Override
    public void draw() {
        System.out.println("Draw a circle");
    }
}

// Rectangle类
public class Rectangle implements Shape {
    @Override
    public void draw() {
        System.out.println("Draw a rectangle");
    }
}

// Square类
public class Square implements Shape {
    @Override
    public void draw() {
        System.out.println("Draw a square");
    }
}

然后，我们定义一个 ShapeFactory 类，它有一个静态方法 createShape，根据给定的形状类型来返回相应的对象：

// ShapeFactory类
public class ShapeFactory {
    // 静态方法createShape
    public static Shape createShape(String shapeType) {
        if (shapeType == null) {
            return null;
        }
        if (shapeType.equalsIgnoreCase("circle")) {
            return new Circle();
        } else if (shapeType.equalsIgnoreCase("rectangle")) {
            return new Rectangle();
        } else if (shapeType.equalsIgnoreCase("square")) {
            return new Square();
        }
        return null;
    }
}

最后，我们可以在客户端使用 ShapeFactory 来创建不同类型的形状对象：

// 客户端
public class Client {
    public static void main(String[] args) {
        // 创建一个圆形对象
        Shape circle = ShapeFactory.createShape("circle");
        // 调用圆形对象的draw方法
        circle.draw();
        // 创建一个矩形对象
        Shape rectangle = ShapeFactory.createShape("rectangle");
        // 调用矩形对象的draw方法
        rectangle.draw();
        // 创建一个正方形对象
        Shape square = ShapeFactory.createShape("square");
        // 调用正方形对象的draw方法
        square.draw();
    }
}

输出结果如下：

Draw a circle
Draw a rectangle
Draw a square

工厂方法模式

假设我们还是有一个Shape接口和三个实现类Circle、Rectangle和Square，我们想要根据给定的形状类型来创建相应的对象，但是我们不想使用一个工厂类来创建所有类型的对象，而是让每个形状类自己定义一个工厂类来创建自己的对象。

首先，我们定义一个Shape接口和三个实现类，这里和简单工厂模式一样：

// Shape接口
public interface Shape {
    void draw();
}

// Circle类
public class Circle implements Shape {
    @Override
    public void draw() {
        System.out.println("Draw a circle");
    }
}

// Rectangle类
public class Rectangle implements Shape {
    @Override
    public void draw() {
        System.out.println("Draw a rectangle");
    }
}

// Square类
public class Square implements Shape {
    @Override
    public void draw() {
        System.out.println("Draw a square");
    }
}

然后，我们定义一个抽象工厂类ShapeFactory，它有一个抽象方法createShape，返回一个Shape对象：

// 抽象工厂类ShapeFactory
public abstract class ShapeFactory {
    // 抽象方法createShape
    public abstract Shape createShape();
}

接着，我们让每个形状类都定义一个工厂类，继承自ShapeFactory，并实现createShape方法，返回自己的对象：

// CircleFactory类
public class CircleFactory extends ShapeFactory {
    @Override
    public Shape createShape() {
        return new Circle();
    }
}

// RectangleFactory类
public class RectangleFactory extends ShapeFactory {
    @Override
    public Shape createShape() {
        return new Rectangle();
    }
}

// SquareFactory类
public class SquareFactory extends ShapeFactory {
    @Override
    public Shape createShape() {
        return new Square();
    }
}

最后，我们可以在客户端使用不同的工厂类来创建不同类型的形状对象：

// 客户端
public class Client {
    public static void main(String[] args) {
        // 创建一个圆形工厂对象
        ShapeFactory circleFactory = new CircleFactory();
        // 通过圆形工厂对象创建一个圆形对象
        Shape circle = circleFactory.createShape();
        // 调用圆形对象的draw方法
        circle.draw();
        // 创建一个矩形工厂对象
        ShapeFactory rectangleFactory = new RectangleFactory();
        // 通过矩形工厂对象创建一个矩形对象
        Shape rectangle = rectangleFactory.createShape();
        // 调用矩形对象的draw方法
        rectangle.draw();
        // 创建一个正方形工厂对象
        ShapeFactory squareFactory = new SquareFactory();
        // 通过正方形工厂对象创建一个正方形对象
        Shape square = squareFactory.createShape();
        // 调用正方形对象的draw方法
        square.draw();
    }
}

输出结果如下：

Draw a circle
Draw a rectangle
Draw a square

抽象工厂模式

假设我们不仅有一个Shape接口和三个实现类Circle、Rectangle和Square，还有一个Color接口和三个实现类Red、Green和Blue，我们想要根据给定的类型来创建相应的形状或颜色对象。

首先，我们定义一个Shape接口和三个实现类，这里和前面两种模式一样：

// Shape接口
public interface Shape {
    void draw();
}

// Circle类
public class Circle implements Shape {
    @Override
    public void draw() {
        System.out.println("Draw a circle");
    }
}

// Rectangle类
public class Rectangle implements Shape {
    @Override
    public void draw() {
        System.out.println("Draw a rectangle");
    }
}

// Square类
public class Square implements Shape {
    @Override
    public void draw() {
        System.out.println("Draw a square");
    }
}

然后，我们定义一个Color接口和三个实现类：

// Color接口
public interface Color {
    void fill();
}

// Red类
public class Red implements Color {
    @Override
    public void fill() {
        System.out.println("Fill with red");
    }
}

// Green类
public class Green implements Color {
    @Override
    public void fill() {
        System.out.println("Fill with green");
    }
}

// Blue类
public class Blue implements Color {
    @Override
    public void fill() {
        System.out.println("Fill with blue");
    }
}

接着，我们定义一个抽象工厂类AbstractFactory，它有两个抽象方法createShape和createColor，分别返回一个Shape对象和一个Color对象：

// 抽象工厂类AbstractFactory
public abstract class AbstractFactory {
    // 抽象方法createShape
    public abstract Shape createShape(String shapeType);
    // 抽象方法createColor
    public abstract Color createColor(String colorType);
}

然后，我们定义三个具体工厂类，分别是ShapeFactory、ColorFactory和MixedFactory，它们都继承自AbstractFactory，并实现其抽象方法。其中，ShapeFactory只负责创建形状对象，ColorFactory只负责创建颜色对象，MixedFactory既可以创建形状对象又可以创建颜色对象：

// ShapeFactory类
public class ShapeFactory extends AbstractFactory {
    @Override
    public Shape createShape(String shapeType) {
        if (shapeType == null) {
            return null;
        }
        if (shapeType.equalsIgnoreCase("circle")) {
            return new Circle();
        } else if (shapeType.equalsIgnoreCase("rectangle")) {
            return new Rectangle();
        } else if (shapeType.equalsIgnoreCase("square")) {
            return new Square();
        }
        return null;
    }

    @Override
    public Color createColor(String colorType) {
        // 不支持创建颜色对象，返回null
        return null;
    }
}

// ColorFactory类
public class ColorFactory extends AbstractFactory {
    @Override
    public Shape createShape(String shapeType) {
        // 不支持创建形状对象，返回null
        return null;
    }

    @Override
    public Color createColor(String colorType) {
        if (colorType == null) {
            return null;
        }
        if (colorType.equalsIgnoreCase("red")) {
            return new Red();
        } else if (colorType.equalsIgnoreCase("green")) {
            return new Green();
        } else if (colorType.equalsIgnoreCase("blue")) {
            return new Blue();
        }
        return null;
    }
}

// MixedFactory类
public class MixedFactory extends AbstractFactory {
    @Override
    public Shape createShape(String shapeType) {
        // 可以创建形状对象，逻辑同ShapeFactory类
        if (shapeType == null) {
            return null;
        }
        if (shapeType.equalsIgnoreCase("circle")) {
            return new Circle();
        } else if (shapeType.equalsIgnoreCase("rectangle")) {
            return new Rectangle();
        } else if (shapeType.equalsIgnoreCase("square")) {
            return new Square();
        }
        return null;
    }

    @Override
    public Color createColor(String colorType) {
        // 可以创建颜色对象，逻辑同ColorFactory类
        if (colorType == null) {
            return null;
        }
        if (colorType.equalsIgnoreCase("red")) {
            return new Red();
        } else if (colorType.equalsIgnoreCase("green")) {
            return new Green();
        } else if (colorType.equalsIgnoreCase("blue")) {
            return new Blue();
        }
        return null;
    }
}

最后，我们可以在客户端使用不同的工厂类来创建不同类型的形状或颜色对象：

// 客户端
public class Client {
    public static void main(String[] args) {
        // 创建一个形状工厂对象
        AbstractFactory shapeFactory = new ShapeFactory();
        // 通过形状工厂对象创建一个圆形对象
        Shape circle = shapeFactory.createShape("circle");
        // 调用圆形对象的draw方法
        circle.draw();
        // 通过形状工厂对象创建一个矩形对象
        Shape rectangle = shapeFactory.createShape("rectangle");
        // 调用矩形对象的draw方法
        rectangle.draw();
        // 通过形状工厂对象创建一个正方形对象
        Shape square = shapeFactory.createShape("square");
        // 调用正方形对象的draw方法
        square.draw();

        // 创建一个颜色工厂对象
        AbstractFactory colorFactory = new ColorFactory();
        // 通过颜色工厂对象创建一个红色对象
        Color red = colorFactory.createColor("red");
        // 调用红色对象的fill方法
        red.fill();
        // 通过颜色工厂对象创建一个绿色对象
        Color green = colorFactory.createColor("green");
        // 调用绿色对象的fill方法
        green.fill();
        // 通过颜色工厂对象创建一个蓝色对象
        Color blue = colorFactory.createColor("blue");
        // 调用蓝色对象的fill方法
        blue.fill();

        // 创建一个混合工厂对象
        AbstractFactory mixedFactory = new MixedFactory();
        // 通过混合工厂对象创建一个圆形和红色的组合对象
        Shape circleRed = mixedFactory.createShape("circle");
        Color redRed = mixedFactory.createColor("red");
        // 调用组合对象的draw和fill方法
        circleRed.draw();
        redRed.fill();
    }
}

输出结果如下：

Draw a circle
Draw a rectangle
Draw a square
Fill with red
Fill with green
Fill with blue
Draw a circle
Fill with red

Spring 代码示例

这里对上述的抽象工厂代码示例进行 Spring 框架下的改造。

先改造 Shape 接口的实现类加上 @Component 注解

// Shape接口
public interface Shape {
    void draw();
}

// Circle类
@Component
public class Circle implements Shape {
    @Override
    public void draw() {
        System.out.println("Draw a circle");
    }
}

// Rectangle类
@Component
public class Rectangle implements Shape {
    @Override
    public void draw() {
        System.out.println("Draw a rectangle");
    }
}

// Square类
@Component
public class Square implements Shape {
    @Override
    public void draw() {
        System.out.println("Draw a square");
    }
}

然后在改造 Color 接口的三个实现类加上 @Component 注解

// Color接口
public interface Color {
    void fill();
}

// Red类
@Component
public class Red implements Color {
    @Override
    public void fill() {
        System.out.println("Fill with red");
    }
}

// Green类
@Component
public class Green implements Color {
    @Override
    public void fill() {
        System.out.println("Fill with green");
    }
}

// Blue类
@Component
public class Blue implements Color {
    @Override
    public void fill() {
        System.out.println("Fill with blue");
    }
}

抽象工厂类 AbstractFactory 的具体工厂 MixedFactory 类加上 @Component 注解

// 抽象工厂类AbstractFactory
public abstract class AbstractFactory {
    // 抽象方法createShape
    public abstract Shape createShape(String shapeType);
    // 抽象方法createColor
    public abstract Color createColor(String colorType);
}

// MixedFactory类
@Component
public class MixedFactory extends AbstractFactory {
    @Autowired
    private Map<String, Shape> shapeMap;
    @Autowired
    private Map<String, Color> colorMap;

    @Override
    public Shape createShape(String shapeType) {
        // 可以创建形状对象，逻辑同ShapeFactory类
        if (shapeType == null) {
            return null;
        }
        return shapeMap.getOrDefault(shapeType, null);
    }

    @Override
    public Color createColor(String colorType) {
        // 可以创建颜色对象，逻辑同ColorFactory类
        if (colorType == null) {
            return null;
        }
        return colorMap.getOrDefault(colorType, null);
    }
}

最后我们可以在客户端使用不同的工厂类来创建不同类型的形状或颜色对象：

// 客户端
// 测试类
@SpringBootTest
@RunWith(SpringRunner.class)
public class FactoryTest {

    // 从Spring容器中获取Context对象
    @Autowired
    private MixedFactory mixedFactory;

    @Test
    public void test() {
        Shape circle = mixedFactory.createShape("circle");
        circle.draw();
        Shape rectangle = mixedFactory.createShape("rectangle");
        rectangle.draw();
        Shape square = mixedFactory.createShape("square");
        square.draw();

        Color red = mixedFactory.createColor("red");
        red.fill();
        Color green = mixedFactory.createColor("green");
        green.fill();
        Color blue = mixedFactory.createColor("blue");
        blue.fill();
    }
}

输出结果如下：

Draw a circle
Draw a rectangle
Draw a square
Fill with red
Fill with green
Fill with blue

总结

总之工厂模式通过引入一个工厂类来负责实例化其他类，可以实现解耦、扩展性好和提高代码可读性。它是 Java 开发中最常用和最基础的设计模式之一。熟练使用工厂模式可以大大提高我们的代码质量和开发效率。

关注公众号【waynblog】每周分享技术干货、开源项目、实战经验、高效开发工具等，您的关注将是我的更新动力！

标签：draw,return,对象,模式,工厂,Shape,设计模式,public
From： https://www.cnblogs.com/waynaqua/p/17494937.html

相关文章

  • 解决Excel 互操作错误"检索COML类工厂中 CLSID为 {00024500-0000-0000-C000-000000000
    解决Excel互操作错误"检索COML类工厂中CLSID为{00024500-0000-0000-C000-000000000046}的组件时失败，原因是出现以下错误:80070005"\comexp.msc-32......
  • 电销机器人，颠覆传统的电销模式
    电销机器人是帮你搭建一个电销后台，对接属于你的专属线路，录制属于你的真人语音话术，帮你代替真人自动拨打电话，把打出来的意向客户自动推送到你的微信上面。电销机器人是非常有用的，它和传统的人工电销不一样。第一、减低人力成本：一个电话销售员从工资、培训、补贴、奖金一个月做少要40......
  • 浅谈项目核算的“全程利润”实现模式
    “怎样评估各事业群/项目群的业绩？如何引导决策？”“今年的利润怎么分配？没有细化的分配依据，怎么办？”“开了这么多类型的项目，是不是有些盲目？资源这么紧张，明年要怎么做？”这一系列的问题，几乎所有的企业都会面临，怎么破？怎么解？用友针对以上困惑推出了一项新的解决方案“项目财务管理PFM”，将......
  • API模式HTTP使用代码模板
    以下是一个使用Python的HTTPAPI请求的代码模板：importrequests#设置请求的URL和参数url='http://example.com/api'params={'param1':'value1','param2':'value2'}#发送HTTPGET请求response=requests.get(url,params=params)#......
  • 桥接模式-09
    概述桥接模式(BridgePattern)又称柄体(HandleandBody)模式、接口模式。它将可能有着继承关系的对象的抽象和实现分离，使得两者可以独立地变化。优点：分离了抽象部分和实现部分，提高了灵活性和可扩展性，隐藏了实现的细节。缺点：降低了系统可理解性，提高了设计难度，有一定的局限......
  • 【OpenGL修行】点线面模式设置
    文章目录点点的大小切换线线的宽窄设置虚线绘制多边形多边形正反绘制&反转多边形表面剔除多边形表面镂空通过初始化数组设置镂空样式通过读取bmp文件设置镂空样式点点的大小切换通过glPointSize()函数即可实现点的大小控制，我画了两个大小不同的点，还是挺明显的。voiddisplay1(){......
  • Java设计模式之代理模式--经纪人的工作
    前言本文主要讲述代理模式，文中使用通俗易懂的案例，使你更好的学习本章知识点并理解原理，做到有道无术。一.什么是代理模式代理模式是23种设计模式中结构型模式的一种，它的核心是通过代理类来完成其他对象的访问，降低访问者和被访问者的耦合度，也对功能进行了增强。二.生活中的代理......
  • 万字详解常用设计模式
    本文是博主在工作中对常用设计模式的使用经验总结归纳而来分享给大家。设计模式一共有23种，本文讲解涉及如下：责任链模式模板方法模式发布订阅模式策略模式三大分类业界一般将设计模式分为三大类：创建型模式：对类的实例化过程进行了抽象，能够将软件模块中对象的创建和对象......
  • Go 设计模式｜组合，一个对数据结构算法和职场都有提升的设计模式
    Go设计模式｜组合，一个对数据结构算法和职场都有提升的设计模式原创 KevinYan11 网管叨bi叨 2023-01-1608:45 发表于北京收录于合集#用Go学设计模式24个大家好，我是每周在这里陪你进步的网管～，这次我们继续设计模式的学习之旅。本次要学习的是组合模式，这个模式呢，平时要做......
  • SAP Commerce Cloud的SmartEdit 不同模式的介绍
    SAPCommerceCloud的SmartEdit提供了不同的模式（Mode），包括PreviewMode（预览模式）、BasicEditMode（基本编辑模式）和AdvancedEditMode（高级编辑模式）。这些模式为用户提供了不同的功能和工作环境，以满足其编辑和管理网站内容的需求。PreviewMode（预览模式）：PreviewMode是SmartEdit的......

赞助商

阅读排行

网站主页关于我们联系我们网站地图

本网站内容转载自其他媒体，侵权联系[admin##ips99.com]。

Copyright © 2020-2023 IPS99 版权所有 IPS99