设计模式之工厂模式

最新推荐文章于 2024-07-29 10:42:49 发布
最新推荐文章于 2024-07-29 10:42:49 发布
阅读量208 收藏
点赞数
分类专栏： 设计模式 文章标签： 设计模式 工厂模式
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/shieryujian/article/details/68942180
版权

一、简单工厂模式
1.简单抽象工厂模式，又称作静态工厂方法模式，由工厂（使用switch）决定创建具体产品，不符合开放关闭原则。

2.简单工厂模式UML图
这里写图片描述

3.简单工厂模式示例

package cn.sy.edu.factory.simplefactory;

/**
 * 封装一个OPeration类，包含numberA、numberB两个参数
 * 然后加减乘除不同运算方式类继承此类，并用不同行为覆盖getResult方法，进行不同运算
 * ---如果此时在添加运算方式，只要添加一个运算方式类继承OPeration类就行类，不用修改以前的代码
 * ？？？但此时有一个问题，我们客户端应该选择以何种运算方式实例化OPeration类
 * @author shier
 *
 */
public abstract class OPeration {
    protected double numberA;
    protected double numberB;

    public abstract double getResult();     
}

/**
 * 加法类
 * @author shier
 *
 */
class OperationAdd extends OPeration{

    @Override
    public double getResult() {
        return numberA + numberB;
    }
}

/**
 * 减法类
 * @author shier
 *
 */
class OperationSub extends OPeration{

    @Override
    public double getResult() {
        return numberA - numberB;
    }
}

/**
 * 乘法类
 * @author shier
 *
 */
class OperationMul extends OPeration{

    @Override
    public double getResult() {
        return numberA * numberB;
    }
}

/**
 * 除法类
 * @author shier
 *
 */
class OperationDiv extends OPeration{

    @Override
    public double getResult() {
        if(numberB == 0){
            throw new RuntimeException("被除数不可以为0");
        }
        return numberA / numberB;
    }
}


package cn.sy.edu.factory.simplefactory;

/**
 * 提供一个简单工厂类用来实例化运算方式类，同时使用了多态
 * 这样增加运算方式的时候在这里添加一种实例化方式就行了
 * @author shier
 *
 */
public class OperationFactory {

    public static OPeration createOPeration(String operation){
        OPeration oper = null;

        switch (operation) {
        case "+":
            oper = new OperationAdd();
            break;

        case "-":
            oper = new OperationSub();
            break;
        case "*":
            oper = new OperationMul();
            break;
        case "/":
            oper = new OperationDiv();
            break;      
        }

        return oper;
    }
}

/*
 * 计算器类
 */
public class OperationMachine {
    public static void main(String[] args) {
        OPeration  oper = OperationFactory.createOPeration("+");

        oper.numberA = 10.0;
        oper.numberB = 23.0;

        double result = oper.getResult();
        System.out.println(result);

    }
}

二、工厂方法模式
1.工厂方法模式定义：定义一个用于创建对象的接口，让子类决定实例化那一个类。工厂方法使一个类的实例化延迟到其子类。

2.工厂方法的UML图
这里写图片描述

3.工厂方法模式示例

package cn.sy.edu.factory.methodfactory;

/**
 * 雷锋抽象类（或者接口，更好用接口）
 * 提供扫地、洗衣、买米
 * @author shier
 *
 */
public abstract class LeiFen {

    abstract void sweep();

    abstract void wash();

    abstract void buyRice();
}

class StudentLeiFen extends LeiFen{

    @Override
    void sweep() {
        System.out.println("大学生洗地");

    }

    @Override
    void wash() {
        System.out.println("大学生洗衣");

    }

    @Override
    void buyRice() {
        System.out.println("大学生买米");        
    }   
}

class VolunteerLeiFen extends LeiFen{
    @Override
    void sweep() {
        System.out.println("社区工作者洗地");

    }

    @Override
    void wash() {
        System.out.println("社区工作者洗衣");

    }

    @Override
    void buyRice() {
        System.out.println("社区工作者买米");      
    }
}

package cn.sy.edu.factory.methodfactory;

/**
 * 雷锋工厂抽象类
 * 大学生雷锋工厂、社区工作者雷锋工厂分别产生不同类型的雷锋
 * 这样比简单工厂模式，更近一步，因为简单工厂模式增加一个条件，就要在工厂类中加一个case判断
 * 违反了开放-封闭原则，而工厂方法只是扩展并没有修改
 * 但是工厂方法模式把简单工厂的内部逻辑判断转移到了客户端代码进行，现在要增加功能要修改客户端
 * @author shier
 *
 */
public abstract class LeifenFactory {
    abstract LeiFen createLfiFen();
}

class StudentLeiFenFactory extends LeifenFactory{

    @Override
    LeiFen createLfiFen() {
        return new StudentLeiFen();
    }

}

class VolunteerLeiFenFactory extends LeifenFactory{

    @Override
    LeiFen createLfiFen() {
        return new VolunteerLeiFen();
    }

}

三、抽象工厂模式
1.抽象工厂模式的定义：提供一个创建一系列相关或相互依赖对象的接口，而无须指定它们具体的类。

2.抽象工厂模式的UML图
这里写图片描述

3.抽象工厂模式+反射示例

/**
 * 用户接口包含insert、getUser两个方法
 * @author shier
 *
 */
public interface User {
    public void insert(User user);

    public User getUser(int id);

}

/**
 * OracleUser实现User接口
 * @author shier
 *
 */
public class OracleUser implements User{
    @Override
    public void insert(User user) {
        System.out.println("在oracle中给User表增加一条记录");

    }

    @Override
    public User getUser(int id) {
        System.out.println("在oracle中根据id得到User表增加一条记录");
        return null;
    }

}

/**
 * SqlserverUser实现User接口
 * @author shier
 *
 */
public class SqlserverUser implements User{

    @Override
    public void insert(User user) {
        System.out.println("在sqlsever中给User表增加一条记录");

    }

    @Override
    public User getUser(int id) {
        System.out.println("在sqlsever中根据id得到User表增加一条记录");
        return null;
    }

}
/**
 * 部门接口，提供insert、getDepartment两个方法
 * @author shier
 *
 */
public interface Department {
    public void insert(Department Department);

    public Department getDepartment(int id);
}

/**
 * OracleDepartment实现Department
 * @author shier
 *
 */
public class OracleDepartment implements Department{
    @Override
    public void insert(Department Department) {
        System.out.println("在oracle中给Department表增加一条记录");

    }

    @Override
    public Department getDepartment(int id) {
        System.out.println("在oracle中根据id得到Department表增加一条记录");
        return null;
    }
}

/**
 * SqlseverDepartment实现Department
 * @author shier
 *
 */
public class SqlseverDepartment implements Department{

    @Override
    public void insert(Department Department) {
        System.out.println("在sqlsever中给Department表增加一条记录");

    }

    @Override
    public Department getDepartment(int id) {
        System.out.println("在sqlsever中根据id得到Department表增加一条记录");
        return null;
    }
}

/**
 * 工厂接口，提供createUser、createDepartment两个方法
 * @author shier
 *
 */
public interface Factory {
    User createUser();

    Department createDepartment();
}

/**
 * OracleFactory实现Factory接口，覆写createUser、createDepartment分别产生OracleUse类和OracleDepartment类
 * @author shier
 *
 */
public class OracleFactory implements Factory{

    @Override
    public User createUser() {
        return new OracleUser();
    }

    @Override
    public Department createDepartment() {      
        return new OracleDepartment();
    }

}

/**
 * SqlseverFactory实现Factory接口，覆写createUser、createDepartment分别产生SqlserverUser类和SqlseverDepartment类
 * @author shier
 *
 */
public class SqlseverFactory implements Factory{

    @Override
    public User createUser() {
        return new SqlserverUser();
    }

    @Override
    public Department createDepartment() {
        return new SqlseverDepartment();
    }

}
/**
 * 使用抽象工厂模式+反射，解决数据库更换的问题
 * @author shier
 *
 */
public class DataFactory<T> {

    public  static User createUser(String name){
        try {
            return  (User) Class.forName(name).newInstance();
        } catch (Exception e) {
            throw new RuntimeException(e);
        } 
    }

    public static Department createDepartment(String name){
        try {
            return (Department) Class.forName(name).newInstance();
        } catch (Exception e) {
            throw new RuntimeException(e);
        } 
    }
}
十二遇见
关注
  • 0
    点赞
  • 踩
  • 0
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
专栏目录
设计模式之工厂模式(C++)
翟天保的博客
02-15 2万+
介绍设计模式之工厂模式
JAVA设计模式之工厂模式（三种工厂模式）
热门推荐
m0_65260253的博客
11-17 2万+
JAVA设计模式之工厂模式（三种工厂模式）
javascript设计模式之工厂模式
object not found的博客
08-12 1万+
函数creatPerson（）接受了三个参数，根据这几个参数创建了一个包含person信息的对象，可以用不同的参数去多次调用这个对象，而它就回每次都返回3个属性和一个方法的对象，虽然这种工厂模式可以解决创建多个相似对象的问题，但是他没有解决对象标识的问题，到这里可能有小伙伴不知道对象标识是什么，解释一下对象标识就是我们创建的对象是什么类型。工厂模式是一种众所周知的设计模式，广泛应用于软件工程领域，用于抽象创建特定对象的过程。.........
C#设计模式之工厂模式
BraveRunTo的博客
07-10 1777
C#设计模式之工厂模式 文章目录C#设计模式之工厂模式简单工厂模式模式分类模式产生的原因模式灵感的来源模式类图经典代码实现简单工厂模式的总结（优点和缺点最好在使用中自行体会）简单工厂模式的优点简单工厂模式的缺点工厂方法模式模式分类模式产生的原因模式灵感的来源模式类图经典代码实现工厂方法模式总结工厂方法模式的优点工厂方法模式的缺点抽象工厂模式模式分类模式产生的原因模式灵感的来源模式类图经典代码实现抽象工厂模式总结抽象工厂模式的优点：抽象工厂模式的缺点： 本篇博客将介绍简单工厂，工厂方法和抽象工厂，之所以放在一
Android常用设计模式之工厂模式理解
qq_36639105的博客
10-10 2261
设计模式之工厂模式
JS设计模式之工厂模式
weixin_44051815的博客
11-19 2343
JS设计模式之工厂模式 工厂模式大体分为三类： 简单工厂模式、 工厂方法模式、抽象工厂模式。三者之间的关系，也是渐进式的，抽象化的范围也是越来越高。 1. 简单工厂模式： 对同一类对象创建过程的抽象，在形式上它仅仅只是简单的通过 switch 等判断语句，根据不同条件去生成不同对象，且只能创建现有的数据，如果要添加，必须手动添加。 interface IPhone { name: string; price: number; } enum Phones { hw, mi } /
设计模式 之 工厂模式
大佛拈花的博客
08-28 1万+
工厂模式可以屏蔽接口的具体实现，调用的时候只关注接口的具体名称而无需关注实现。这是他的优点。如果增加其他的功能，只需要实现接口即可。同样的，当需要大量的额功能是，这时候就需要创建多个类，增加了类的数目，也为系统带来了复杂性。下面的代码是演示工厂设计模式。 场景：当我们调用接口的时候我们根据传递进来的进口通信...
一文小结设计模式之工厂模式（Java实现三种）
a760352276的博客
11-10 2292
设计模式之工厂模式简单工厂引入简单工厂UML扩展小结工厂方法引入工厂方法UML小结抽象工厂引入抽象工厂UML小结 工厂方法是常用的创建型模式之一，其主要核心是将对象交由工厂去实例化，我们只需要通过工厂去获得该我们想要的实例即可。本文简单描述三种工厂模式，但是简单工厂模式并不属于23种设计模式之一，其作为一个铺垫可以更好的理解工厂方法和抽象工厂两种设计模式。 简单工厂 我们先来看最原始的工厂模式，也就是简单工厂。其通过传入的字符参数不同来对应生产不同的实例，而工厂通过大量的if...else来对我们传入的字符
设计模式之工厂模式和抽象工厂
LiLiYuan.的博客
10-02 1373
设计模式分类 通常来说设计模式分为三大类： 创建型模式，共 5 种：工厂模式、抽象工厂模式、单例模式、建造者模式、原型模式。 结构型模式，共 7 种：适配器模式、装饰器模式、代理模式、外观模式、桥接模式、组合模式、享元模式。 行为型模式，共 11 种：策略模式、模板方法模式、观察者模式、迭代子模式、责任链模式、命令模式、备忘录模式、状态模式、访问者模式、中介者模式、解释器模式。 下面用图片来整体描述一下设计模式之间的关系： 工厂模式 工厂模式（Factory Pattern）的意义就跟它的名字一样，在
设计模式之工厂模式总结
12-21
编辑Java笔记");}}增加Python笔记public ...设计模式是软件开发中的宝贵经验总结，工厂模式作为其中的一员，可以帮助我们编写更加灵活、可维护的代码。理解并熟练运用工厂模式，能够提升软件设计的质量和可扩展性。
Java设计模式之工厂模式
08-27
Java设计模式之工厂模式是Java设计模式中的一种，主要用于解决不同类型数据采集的接口问题。该模式通过定义一个工厂接口，提供不同的数据采集类实现该接口，并通过工厂类来获取不同的数据采集类对象，从而隐藏了new...
Java设计模式之工厂模式实现方法详解
08-28
Java设计模式之工厂模式实现方法详解 工厂模式是 Java 设计模式中的一种重要模式，它提供了一种创建对象的接口，以便将创建对象的具体过程屏蔽隔离起来，达到提高灵活性的目的。工厂模式主要有三种：简单工厂模式、...
设计模式之工厂模式1
08-08
工厂模式是一种设计模式，属于创建型模式，它的主要目的是通过提供一个统一的接口来创建对象，使得客户端在使用时不需要关心具体的对象实例化过程。在工厂模式中，一个工厂类负责创建对象，而具体创建哪种类型的对象...
PHP设计模式之工厂模式定义与用法详解
12-20
【工厂模式】是一种常见的设计模式，它属于创建型模式，主要目标是提供一个创建对象的接口，隔离了实例化过程，使得系统对扩展开放而对修改封闭。在PHP中，工厂模式的应用能帮助我们更好地管理和控制对象的创建。 ...
python设计模式——单例模式
最新发布
软件测试技术的博客
07-29 246
单例模式（Singleton Pattern）即一个类只能拥有一个实例对象，实例化多次的结果都会指向同一个对象。这种模式涉及到一个单一的类，该类负责创建自己的对象，同时确保只有单个对象被创建。这个类提供了一种访问其唯一的对象的方式，可以直接访问，不需要实例化该类的对象。特点：全局唯一，允许更改。
设计模式实战：日志系统的设计与实现
qq_40254606的博客
07-26 791
通过本项目，我们综合应用了单例模式、适配器模式和桥接模式，解决了日志系统的设计需求。通过这些模式，我们实现了系统模块的解耦和灵活扩展，使得代码结构更加清晰、易于维护。
基于STM32F103的FreeRTOS系列（一）·单片机设计模式介绍·裸机程序的设计模式
时光の尘的博客
07-22 1314
裸机程序的设计模式可以分为：轮询、前后台、定时器驱动、基于状态机。：周期性地查询各个模块或函数的状态，适用于简单且响应时间要求不高的系统，但无法有效解决复杂函数之间的相互影响问题。：通过将关键任务放在前台处理，而非关键任务放在后台，以确保关键任务的优先执行。这种方式对优先级管理有效，但复杂函数之间的相互影响仍可能存在。：通过定时器周期性地触发任务执行，适合需要定期执行任务的场景，但不能解决函数间相互影响的问题。：将系统的各种状态和状态转移定义清晰，通过状态切换来控制系统行为。
设计模式-单例模式
weixin_51722520的博客
07-27 194
单例设计模式
C++ 设计模式之工厂模式怎么实现
05-16
工厂模式是一种常见的创建型设计模式，用于创建对象，而不是通过直接调用构造函数来创建它们。工厂模式定义了一个接口，用于创建相关对象，但是让子类决定要实例化的类。在C++中，工厂模式可以通过以下步骤实现： 1. 创建一个抽象基类，该类定义了一个纯虚拟函数，该函数将返回一个指向基类的指针。这个基类就是我们的工厂接口。 ```c++ class Product { public: virtual ~Product() {} virtual void operation() = 0; }; ``` 2. 创建具体的产品类，它们继承自抽象基类，并实现了其纯虚拟函数。这些类就是我们的具体产品。 ```c++ class ConcreteProductA : public Product { public: void operation() override { /* 具体产品 A 的操作 */ } }; class ConcreteProductB : public Product { public: void operation() override { /* 具体产品 B 的操作 */ } }; ``` 3. 创建一个工厂类，该类实现了工厂接口，并根据需要创建具体的产品。这个工厂类就是我们的具体工厂。 ```c++ class Factory { public: virtual ~Factory() {} virtual std::unique_ptr<Product> createProduct() = 0; }; class ConcreteFactoryA : public Factory { public: std::unique_ptr<Product> createProduct() override { return std::make_unique<ConcreteProductA>(); } }; class ConcreteFactoryB : public Factory { public: std::unique_ptr<Product> createProduct() override { return std::make_unique<ConcreteProductB>(); } }; ``` 4. 在客户端代码中使用具体工厂创建具体产品。 ```c++ int main() { std::unique_ptr<Factory> factory = std::make_unique<ConcreteFactoryA>(); std::unique_ptr<Product> product = factory->createProduct(); product->operation(); return 0; } ``` 这就是工厂模式的基本实现方式。通过这种方式，我们可以将对象的创建过程与客户端代码分离，从而更好地实现模块化和可扩展性。
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值