设计模式-03工厂模式

已于 2023-07-30 15:51:00 修改
阅读量31 收藏
点赞数
分类专栏： 设计模式 文章标签： 设计模式 java 开发语言
于 2023-07-23 16:23:22 首次发布
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/GeekerJava/article/details/131880720
版权

工厂模式

简单工厂

实例化对象的时候不再使用new Object()的方式，可以根据用户的选择条件来实例化相关的类，对于客户端来说，去除了具体类的依赖。只需要给出具体实例的描述给工厂，工厂就会自动返回具体的实例对象
在这里插入图片描述

public interface Operation {
    Double getResult(Double a, Double b);
}

新增操作实例类

public class AddClass implements Operation {
    @Override
    public Double getResult(Double a, Double b) {
        return a + b;
    }
}

减法操作实例类

public class SubClass implements Operation {
    @Override
    public Double getResult(Double a, Double b) {
        return a - b;
    }
}

乘法操作实例类

public class MultiplicationClass implements Operation {
    @Override
    public Double getResult(Double a, Double b) {
        return a * b;
    }
}

除法操作实例类

public class DivisionClass implements Operation {
    @Override
    public Double getResult(Double a, Double b) {
        if(b == 0){
            return null;
        }
        return a / b;
    }
}

简单工厂，生产具体实例

public class SimpleFactory {

    public static Operation createOperate(String type){
        Operation operation =null;
        switch (type){
            case "+" :
                operation = new AddClass();
                break;
            case "-":
                operation = new SubClass();
                break;
            case "/":
                operation = new DivisionClass();
                break;
            case "*":
                operation = new MultiplicationClass();
                break;
        }
        return operation;
    }
}

消费方

public class Client {

    public static void main(String[] args) {
        Operation add = SimpleFactory.createOperate("+");
        Operation sub = SimpleFactory.createOperate("-");
        Operation division = SimpleFactory.createOperate("/");
        Operation multiplication = SimpleFactory.createOperate("*");

        System.out.println(add.getResult(2d,3d));
        System.out.println(sub.getResult(2d,3d));
        System.out.println(division.getResult(2d,3d));
        System.out.println(multiplication.getResult(2d,3d));
    }
}

优点：比较好了解，简单易操作。达到了解耦的作用，使用方不用考虑实例对象的内部具体细节，使用方通过简单工厂获取自己需要的实例对象。

缺点：违反了设计模式的OCP原则，即对扩展开发，对修改关闭。即我们给类增加新的功能的时候，尽量不修改代码，或者少修改代码。比如：当我新增新的运算操作时，需要修改简单工厂。

工厂方法

和简单工厂相比，工厂方法进一步解耦，把简单工厂进一步抽象出来一个工厂接口，由具体工厂来实现实例对象的生产，不用关注具体的细节
在这里插入图片描述
新增工厂接口

public interface Factory {
    Operation createOperation();
}

各种操作的具体工厂

public class AddFactory implements Factory {
    @Override
    public Operation createOperation() {
        System.out.println("加法运算");
        return new AddClass();
    }
}

public class SubFactory implements Factory{
    @Override
    public Operation createOperation() {
        System.out.println("减法运算");
        return new SubClass();
    }
}

public class MultiplicationFactory implements Factory {
    @Override
    public Operation createOperation() {
        System.out.println("乘法运算");
        return new MultiplicationClass();
    }
}


public class DivisionFactory implements Factory {
    @Override
    public Operation createOperation() {
        System.out.println("除法运算");
        return new DivisionClass();
    }
}

产品管理接口

public interface Operation {
    Double getResult(Double a, Double b);
}

各种产品类

public class AddClass implements Operation {
    @Override
    public Double getResult(Double a, Double b) {
        return a + b;
    }
}

public class SubClass implements Operation {
    @Override
    public Double getResult(Double a, Double b) {
        return a - b;
    }
}

public class MultiplicationClass implements Operation {
    @Override
    public Double getResult(Double a, Double b) {
        return a * b;
    }
}

public class DivisionClass implements Operation {
    @Override
    public Double getResult(Double a, Double b) {
        if(b == 0){
            return null;
        }
        return a / b;
    }
}

使用方

//方式一：直接通过创建具体工厂使用接口
public class Client {

    public static void main(String[] args) {
        Factory add = new AddFactory();
        Factory sub = new SubFactory();
        Factory division = new DivisionFactory();
        Factory multi = new MultiplicationFactory();

        System.out.println(add.createOperation().getResult(2d,3d));
        System.out.println(sub.createOperation().getResult(2d,3d));
        System.out.println(division.createOperation().getResult(2d,3d));
        System.out.println(multi.createOperation().getResult(2d,3d));
    }
}
//方式二：通过配置文件中的类全路径通过反射机制获取具体工厂
public class Client {

    public static void main(String[] args)throws Exception {
        /*Factory add = new AddFactory();
        Factory sub = new SubFactory();
        Factory division = new DivisionFactory();
        Factory multi = new MultiplicationFactory();*/


        Factory add = (Factory) Class.forName("com.h3c.com.designpattrn.factory.factorymethod.AddFactory").newInstance();
        Factory sub = (Factory) Class.forName("com.h3c.com.designpattrn.factory.factorymethod.SubFactory").newInstance();
        Factory division = (Factory) Class.forName("com.h3c.com.designpattrn.factory.factorymethod.MultiplicationFactory").newInstance();
        Factory multi = (Factory) Class.forName("com.h3c.com.designpattrn.factory.factorymethod.DivisionFactory").newInstance();
        System.out.println(add.createOperation().getResult(2d,3d));
        System.out.println(sub.createOperation().getResult(2d,3d));
        System.out.println(division.createOperation().getResult(2d,3d));
        System.out.println(multi.createOperation().getResult(2d,3d));
    }
}

总结：

工厂模式中，要增加产品类时也要相应地增加工厂类，客户端的代码也增加了不少。工厂方法把简单工厂的内部逻辑判断转移到了客户端代码来进行。

你想要加功能，本来是改工厂类的，而现在是修改客户端。而且各个不同功能的实例对象的创建代码，也没有耦合在同一个工厂类里，这也是工厂方法模式对简单工厂模式解耦的一个体现。工厂方法模式克服了简单工厂会违背开-闭原则的缺点，又保持了封装对象创建过程的优点。

但工厂方法模式的缺点是每增加一个产品类，就需要增加一个对应的工厂类，增加了额外的开发量。

抽象工厂

在这里插入图片描述
产品接口（抽象出产品有哪些共同的操作）

public interface ILogin {
    void insert(Login login);

    Login getLogin(int id);
}

public interface IUser {
    void insert(User user);

    User getUser(int uid);
}

产品类

public class User {

    private int uid;
    private String uname;

    public int getUid() {
        return uid;
    }

    public void setUid(int uid) {
        this.uid = uid;
    }

    public String getUname() {
        return uname;
    }

    public void setUname(String uname) {
        this.uname = uname;
    }

}

public class Login {

    private int id;
    private Date date;

    public int getId() {
        return id;
    }

    public void setId(int id) {
        this.id = id;
    }

    public Date getDate() {
        return date;
    }

    public void setDate(Date date) {
        this.date = date;
    }
}

产品分类（具体产品分类有哪些操作）

public class MysqlUser implements IUser {
    @Override
    public void insert(User user) {
        System.out.println("在mysql中的user表中插入一条元素");
    }

    @Override
    public User getUser(int uid) {
        System.out.println("在mysql中的user表得到uid为"+uid+"的一条数据");
        return null;
    }
}

public class MysqlLogin implements ILogin {
    @Override
    public void insert(Login login) {
        System.out.println("对 MySQL 里的 Login 表插入了一条数据");
    }

    @Override
    public Login getLogin(int id) {
        System.out.println("通过 uid 在 MySQL 里的 Login 表得到了一条数据");
        return null;
    }
}



public class OracleUser implements IUser {
    @Override
    public void insert(User user) {
        System.out.println("在oracle中的user表中插入一条元素");
    }

    @Override
    public User getUser(int uid) {
        System.out.println("在oracle中的user表得到id为"+uid+"的一条数据");
        return null;
    }
}

public class OracleLogin implements ILogin {
    @Override
    public void insert(Login login) {
        System.out.println("对 Oracle 里的 Login 表插入了一条数据");
    }

    @Override
    public Login getLogin(int id) {
        System.out.println("通过 uid 在 Oracle 里的 Login 表得到了一条数据");
        return null;
    }
}

抽象工厂（定义了抽象工厂，管理工厂有哪些需要共同的操作）

public interface Factory {

    IUser createUser();
    ILogin createLogin();
}

具体工厂（每种产品的具体工厂生产）

public class MysqlFactory implements Factory {
    @Override
    public IUser createUser() {
        return new MysqlUser();
    }

    @Override
    public ILogin createLogin() {
        return new MysqlLogin();
    }
}


public class OracleFactory implements Factory {
    @Override
    public IUser createUser() {
        return new OracleUser();
    }

    @Override
    public ILogin createLogin() {
        return new OracleLogin();
    }
}

使用方（使用方只通过一个具体的工厂就可以获取到对应的实例对象）

public class Client {

    public static void main(String[] args) {
        User user=new User();
        Login login = new Login();

        Factory factory = new OracleFactory();
        IUser iUser = factory.createUser();

        iUser.getUser(1);
        iUser.insert(user);


        ILogin iLogin = factory.createLogin();

        iLogin.getLogin(1);
        iLogin.insert(login);

    }
}

抽象工厂与工厂方法模式的区别在于：抽象工厂是可以生产多个产品的，例如 MysqlFactory 里可以生产 MysqlUser 以及 MysqlLogin 两个产品，而这两个产品又是属于一个系列的，因为它们都是属于MySQL数据库的表。而工厂方法模式则只能生产一个产品，例如之前的 MysqlFactory 里就只可以生产一个 MysqlUser 产品

优点：抽象工厂模式最大的好处是易于交换产品系列，由于具体工厂类，例如 IFactory factory=new OracleFactory();，在一个应用中只需要在初始化的时候出现一次，这就使得改变一个应用的具体工厂变得非常容易；抽象工厂模式的另一个好处就是它让具体的创建实例过程与客户端分离

缺点：如果你的需求来自增加功能，比如增加Login表，就有点太烦了。首先需要增加 ILogin，mysqlLogin,oracleLogin。 然后我们还要去修改工厂类： sqlFactory， mysqlFactory， oracleFactory 才可以实现，需要修改三个类，实在是有点麻烦

胖柯G
关注
  • 0
    点赞
  • 踩
  • 0
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
专栏目录
Java设计模式 - 简单工厂模式
我的小幸运呢
06-18 2361
简单工厂模式，大白话来说，就是有一个抽象类，这个抽象类定义了一个属性和一个抽象方法。然后有多个不同的子类继承这个抽象类，并实现抽象方法。当实例化这个抽象类的时候，对抽象类的属性赋予不同的值，再调用抽象方法，这个抽象方法就可以根据属性值来执行出不同的结果。简单工厂模式其实就是解决到底要实例化谁，将来会不会增加实例化的对象等问题。而这些问题需要考虑用一个单独的类来做这个创造示例的过程，这个就是工厂类。
Spring常用设计模式--抽象工厂模式
热门推荐
想着百万年薪努力的小赵
03-15 3万+
本专栏内容参考自：咕泡学院Tom老师的《Spring5核心原理与30个类手写实战》，仅作个人学习记录使用，如有侵权，联系速删。   抽象工厂模式是指提供一个创建一系列相关或相互依赖对象的接口，无需指定他们的具体类。客户端（应用层）不依赖于产品实体类如何被创建、如何被实现等细节，强调的是一系列相关的产品对象（属于同一产品族）一起使用创建对象需要大量重复的代码。需要提供一个产品类的库，所有的产品以同样的接口出现，从而使客户端不依赖于具体实现。   看抽象工厂模式之前，我们要了解两个概念：产品等级结构和产品族.
设计模式 - 抽象工厂模式案例
qq_48457459的博客
03-20 6188
抽象工厂模式适用的环境，抽象工厂模式vs工厂方法模式，产品等级结构和产品族的概念，模式结构的4个角色，抽象工厂模式案例及代码：计算机包含内存（RAM），CPU等硬件设备，根据如图所示的“产品等级结构-产品族示意图”，使用抽象工厂模式实现计算机设备创建过程并绘制类图
C++设计模式----工厂模式
精致的灰的博客
08-31 4748
三种工厂模式
设计模式 --- 工厂模式
shenzy
12-02 2650
工厂模式是用工厂方法代替new操作的一种模式。工厂模式在Java程序系统可以说是随处可见。因为工厂模式就相当于创建实例对象的new，我们经常要根据类Class生成实例对象，如A a=new A() 工厂模式也是用来创建实例对象的，所以以后new时就要多个心眼，是否可以考虑使用工厂模式，虽然这样做，可能多做一些工作，但会给你系统带来更大的可扩展性和尽量少的修改量（降低耦合）。
Spring常用设计模式--工厂方法模式
想着百万年薪努力的小赵
03-15 3万+
本专栏内容参考自：咕泡学院Tom老师的《Spring5核心原理与30个类手写实战》，仅作个人学习记录使用，如有侵权，联系速删.   工厂方法模式指定义一个创建对象的接口，但让实现这个接口的类决定实例化哪个类，工厂方法模式让类的实例化推迟到子类中进行。在工厂方法模式中用户只需要关心所需产品对应的工厂，无需关心创建细节，而且加入新产品时符合开闭原则。   工厂方法模式主要解决产品扩展的问题。在上一篇简单工厂模式中，随着产品链的丰富，如果每个课程的创建逻辑都有区别，则工厂的职责会变得越来越多，有点像万能工厂，.
Spring常用设计模式--简单工厂模式
想着百万年薪努力的小赵
03-15 3万+
工厂模式的由来：   在现实生活中我们都知道，原始社会自给自足（没有工厂）、农耕社会有了小作坊（简单工厂）、工业革命后有了流水线（工厂方法）、现代产业链有代工厂（抽象工厂）等。   我们的项目代码同样是由简到繁一步一步迭代来的，但是对于调用者来说却是越来越简单化了。 简单工厂模式：   是指由一个工厂对象决定创建哪一种产品类的实例，但它不属于23种常用设计模式，简单工厂模式适用于工厂类负责创建的对象较少的场景，切客户端只需要传入工厂类的参数，对于如何创建对象不需要关心。   话不多说，以代码举例：   现在
Java设计模式-工厂模式
Java厂长
08-06 1万+
Java设计模式-工厂模式 什么是工厂模式？ 工厂模式（Factory Pattern）是 Java 中最常用的设计模式之一。这种类型的设计模式属于创建型模式，它提供了一种创建对象的最佳方式。 在工厂模式中，我们在创建对象时不会对客户端暴露创建逻辑，并且是通过使用一个共同的接口来指向新创建的对象。 简单编写一个类： 1、简单工厂模式 interface IFruit{ public void eat(); //吃水果 } class Apple implements IFruit{ public voi
设计模式- 抽象工厂模式
Circ
04-14 4180
N+1 假设目前你的程序里面有三个对象IphoneX、IphoneXs、IphoneXR的尺寸,那么你使用工厂模式就已经足够了，因为她们属于同一个品类，都属于苹果，如果在添加一个IPhone2022产品，也只需要把IPhone2022加入到你的苹果工厂里面就够了。 但是如果你程序里面还需要知道华为mate10或者小米8的尺寸。这时候你怎么来创建这些对象呢？这时候工厂模式明显已经不适用了，因为工厂模式是对象都实现了同一个接口，这时候就可以使用抽象工厂模式了。 抽象工工厂模式和工厂模式的区别： 抽象工厂模式的定
设计模式——工厂模式
XHY的博客
10-12 2万+
1. 工厂模式定义 工厂模式（Factory Pattern）是 Java 中最常用的设计模式之一。这种类型的设计模式属于创建型模式，它提供了一种创建对象的最佳方式。 在工厂模式中，我们在创建对象时不会对客户端暴露创建逻辑，并且是通过使用一个共同的接口来指向新创建的对象。 2. 作用 通过工厂模式，将创建产品实例的权利移交工厂，我们不再通过new来创建我们所需的对象，而是通过工厂来获取我们需要的产品。降低了产品使用者与使用者之间的耦合关系 3. 类图 这里的工厂与产品为一对一的关系，属于简单工厂 .
设计模式之备忘录模式
yimeixiaolangzai的博客
08-07 530
备忘录模式提供了一种方式，使得对象能保存其当前状态，并在未来某个时刻恢复到这个状态。这种模式通过使用三个关键组件实现：发起人（Originator）、备忘录（Memento）和看护者（Caretaker）。备忘录模式是一种非常有用的设计模式，它可以帮助我们有效地保存和恢复对象的状态，而不破坏对象的封装性。通过实践和应用备忘录模式，开发者可以更容易地实现如撤销功能这类需求，增强用户体验和系统的可靠性。在设计需要状态恢复功能的系统时，备忘录模式无疑是一个值得考虑的选择。
LangChain设计模式支持深度解析
2401_85761003的博客
08-08 450
LangChain作为一个先进的AI应用程序开发框架，其设计中自然融入了多种设计模式的思想，以增强其灵活性和扩展性。LangChain作为一个先进的AI应用程序开发框架，其设计中自然融入了多种设计模式的思想，以增强其灵活性和扩展性。LangChain作为一个模块化的AI应用程序开发框架，其设计中融入了多种设计模式的思想，以提高代码的模块性、可扩展性和可维护性。通过理解LangChain中的这些设计模式，开发者可以更有效地利用框架提供的工具和组件，构建强大且灵活的AI应用程序。
『状态模式』
weixin_69360830的博客
08-06 396
运用状态模式对场景的控制切换
设计模式之命令模式
yimeixiaolangzai的博客
08-05 912
命令模式是一种行为型设计模式。它将请求封装为一个对象，从而使你可以用不同的请求对客户进行参数化。此外，还支持对请求进行排队、记录日志以及实现撤销和恢复操作。
设计模式之观察者模式
yimeixiaolangzai的博客
08-08 365
Subject（主题）主题是被观察的对象，它维护了一个观察者列表，并提供方法以供观察者注册和取消注册。当主题的状态发生变化时，它会通知所有已注册的观察者。Observer（观察者）观察者是需要对主题的变化做出反应的对象。每个观察者都实现了一个更新接口，当主题状态变化时，主题会调用观察者的更新方法。
单例模式：确保唯一实例的设计模式
m0_62056231的博客
08-07 659
在学习框架和大型项目开发时，我们常常会遇到“单例模式”这个词。虽然它时常被提及，但往往没有详细讲解。为了搞懂单例模式的真正意义以及它在开发中的应用，我查阅了一些资料并总结了这篇博客。希望通过这篇文章，能够帮助大家更好地理解单例模式，并在实际开发中得心应手地运用它。单例模式是一种创建型设计模式，其目的是确保一个类只有一个实例，并且提供一个全局的访问点。简单来说，就是一个类的实例是唯一的，所有请求这个实例的地方都得到相同的对象。可以将单例模式比作家庭中的家庭医生：全家只有一个医生，所有的健康问题都由他来处理。
python面向对象编程-设计模式（部分）
最新发布
m0_53614338的博客
08-08 879
面向对象编程（OOP）中的设计模式是一些经过验证的、常见的解决特定问题的方案。单例模式 (Singleton)；工厂模式 (Factory)；观察者模式(Observer)；策略模式 (Strategy)； 原型模式 (Prototype)；建造者模式 (Builder)
Spring Boot 常用设计模式
萧曳丶
08-06 549
在Spring Boot中，常用的设计模式多种多样，这些设计模式不仅帮助维护了代码的清晰度和灵活性，还使得框架易于扩展和维护。
设计模式19-状态模式
qq_41810539的博客
08-06 839
在组建构建过程中，某些对象的状态经常面临着变化。如何对这些变化进行有效的管理呢？同时又wage高层模块的稳定。状态变化模式为这一问题提供了一种解决方案。典型模式StateMemento状态模式允许对象在内部状态改变时改变其行为，对象看起来好像修改了它的类。状态模式通过将状态相关的行为封装在独立的状态类中，使得对象在不同状态下具有不同的行为，简化了状态转换的逻辑，并提高了系统的可维护性和可扩展性。在适当的场景下使用状态模式，可以显著改善代码的可读性和灵活性。
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值