创建型设计模式(1)：工厂模式

最新推荐文章于 2022-04-11 18:23:15 发布
最新推荐文章于 2022-04-11 18:23:15 发布
阅读量910 收藏 2
点赞数
分类专栏： 设计模式
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/Jakob_Hu/article/details/103964576
版权

工厂模式


工厂模式对将调用的方法或者通过new创建类对象的过程进行封装。就好像使用数据库中间件的过程，无需关心底层的实现，只需要将用户名和密码上传即可。

工厂模式的优点如下，

  • 一个调用者想创建某个对象只需要知道名称即可
  • 屏蔽具体的行为过程，调用者只需掌握接口方法，减轻负担
  • 拓展性高，如果想增加一个类进入工厂，只需要拓展一个工厂类即可

从简单工厂引入，深入到工厂模式。

简单工厂分类

工厂模式分为3种，

  1. 普通简单工厂模式
  2. 多方法简单工厂
  3. 静态方法简单工厂

3种模式从上到下逐渐抽象，并更具一般性。以信息、快递和邮件的发送为例进行说明。

1.普通简单工厂

image

  1. 创建接口
    三者共有的接口，
public interface Sender {
	public void Send();
}
  1. 创建发送信息、邮件和快递的实现类，
public class EmailSender implements Sender{
	@Override
	public void send() {
		System.out.println("发送邮件");
	}
}

public class SmsSender implements Sender{
	@Override
	public void send() {
		System.out.println("发送短信");
	}
}

public class ExpressSender implements Sender{
	@Override
	public void send() {
		System.out.println("发送快递");
	}
}
  1. 创建普通简单工厂
public class SendFactory{
	public Sender produce(String type) {
		if (type == null)
			return null;
		else if ("email".equalsIgnoreCase(type))
			return new EmailSender();
		else if ("sms".equalsIgnoreCase(type))
			return new SmsSender();
		else if ("express".equalsIgnoreCase(type))
			return new ExpressSender();
		else
			return null;	
	}
}
  1. 调用普通简单工厂
public class Main {
    public static void main(String[] args) {
        SendFactory sendFactory = new SendFactory();
        Sender senderSms = sendFactory.produce("sms");
        senderSms.Send(); // 发送短信

        Sender senderEmail = sendFactory.produce("email");
        senderEmail.Send(); // 发送邮件

        Sender senderExpress = sendFactory.produce("express");
        senderExpress.Send(); // 发送快递
    }
}
  1. 小结
    普通简单工厂在使用时，如果参数type传递错误就无法正确创建对象。

2.多方法简单工厂

image
依旧使用普通简单工厂类中的3个Sender接口实现类。

  1. 基于普通简单工厂进行修改
    只需要对SendFactory类进行修改即可，
public class SendFactory {
    public Sender produceSms(){
        return new SmsSender();
    }

    public Sender produceEmail(){
        return new EmailSender();
    }

    public Sender produceExpress() {
        return new ExpressSender();
    }
}
  1. 测试多方法简单工厂
public class Main {

    public static void main(String[] args) {
        SendFactory sendFactory = new SendFactory();
        Sender senderEmail = sendFactory.produceEmail();
        senderEmail.Send(); // 发送邮件

        Sender senderSms = sendFactory.produceSms();
        senderSms.Send(); // 发送短信

        Sender senderExpress = sendFactory.produceExpress();
        senderExpress.Send(); // 发送快递
    }
}
  1. 小结
    普通工厂模式和多方法工厂模式均存在一个弊端，即需要频繁实例化工厂类。

3.静态方法简单工厂

一般情况下会将多方法简单工厂中的创建实例的方法设置为静态，从而避免频发实例化工厂类。
image

  1. 测试静态方法简单工厂
public class Main {
    public static void main(String[] args) {
        Sender senderEmail = SendFactory.produceEmail();
        senderEmail.Send(); // 发送邮件

        Sender senderSms = SendFactory.produceSms();
        senderSms.Send(); // 发送短信

        Sender senderExpress = SendFactory.produceExpress();
        senderExpress.Send(); // 发送快递
    }
}
  1. 小结
    静态方法简单工厂仍有明显的弊端，即工厂类中定义了所有市里的创建逻辑，违背高内聚的责任分配原则和闭包规则。

工厂方法模式

1.模式说明

工厂方法模式是简单工厂的延伸，将原先存在于一个工厂类中的逻辑抽调出来，创建一个接口和多个工厂类。
image
这种方式在拓展工厂功能时有很好的表现，无需修改之前的代码。

2.开发实例

基于简单工厂中创建的3个Sender接口实现类进行开发。

  1. 统一工厂类的接口行为
public interface Provider {
    public Sender produce();
}
  1. 实现3个工厂类并进行行为约束
public class EmailSendFactory implements Provider{
	@Override
	public Sender produce() {
		return new EmailSender();
	}
}

public class SmsSendFactory implements Provider{
	@Override
	public Sender produce() {
		return new SmsSender();
	}
}

public class ExpressSendFactory implements Provider{
	@Override
	public Sender produce() {
		return new ExpressSender();
	}
}
  1. 测试工厂模式
public class Main {
    public static void main(String[] args) {
        Provider providerSms = new SmsSendFactory();
        Sender senderSms = providerSms.produce();
        senderSms.Send(); // 发送短信

        Provider providerEmail = new EmailSendFactory();
        Sender senderEmail = providerEmail.produce();
        senderEmail.Send(); // 发送邮件

        Provider providerExpress = new ExpressSendFactory();
        Sender senderExpress = providerExpress.produce();
        senderExpress.Send(); // 发送快递
    }
}
  1. 小结
    上方的代码具体的好处在于拓展性。
    1） 不要把焦点放在new 上面，这里的好处并不是 new 不new的问题。
    2）真正的好处是，多方法简单工厂的最大弊端是：如果需要增加一个新的Sender接口实现类，就不得不去修改工厂类SendFactory的代码。
    工厂类作为一个基础类尽量不要做改动。试想，如果每当要加一个实现类就改动工厂，工厂类不断膨胀，后期很难维护，要符合开闭原则。
    如果用工厂方法就不一样了，对工厂进行接口化，并提供各Sender接口实现类对应的工厂类。如果要新增实现类，就再扩展一个新的工厂，不会对接口进行改变。虽然调用过程中代码量多了，但是在实际业务中会极大的方便后期维护。这样是低耦合的，并且符合开闭原则。

抽象工厂模式

是最具抽象性和一般性的形态。可以像客户端提供一个接口，客户端无需指定产品的情况下，创建多个对象。

以电脑生产为例，比较工厂方法模式和抽象工厂模式，

模式实现
工厂方法模式需要主板工厂、CPU工厂、显卡工厂等
抽象工厂模式只有一个PC工厂，该工厂中再包含主板、显卡和CPU工厂

简言之，工厂方法模式的工厂类针对同一类产品；抽象工厂模式的工厂类针对多种类的产品。

1.模式特点

  1. 系统中有多个产品族，每个具体工厂负责创建同一族但是不同种类(产品等级)的产品。产品族和产品等级的概念如下，
    image
  2. 系统一次只能消费某一产品族的产品
  3. 当系统需要新增一个产品族时，只需要增加新的工厂类即可，无需修改源代码；但是如果需要产品族中增加一个新种类的产品时，则所有的工厂类都需要修改

抽象工厂模式中的抽象工厂类的职责就是定义每个工厂要实现的功能，即定义多个产品族的产品的创建。这里，同一产品族下有多个产品时，对应的抽象工厂就会有多个抽象方法用来提供创建这些产品的接口。

2.组成角色

抽象工厂中的四种角色，

角色说明
抽象工厂提供创建产品的接口，包含多个创建产品的方法，即包含多个类似的方法
具体工厂实现抽象工厂定义的接口，完成具体产品的创建
抽象产品一般有多少抽象产品，抽象工厂中就有多少个创建产品的方法
具体产品抽象产品的实现类

image

3.开发实例

  1. 定义抽象工厂接口
public interface Factory {
    Television newTelevision();
    Refrigerator newRefrigerator();
}
  1. 定义抽象产品接口
public interface Television {
    void dosomething();
}

public interface Refrigerator {
    void dosomething();
}
  1. 实现具体工厂类
public class TCLFactory implements Factory {
    @Override
    public Television newTelevision() {
        return new TCLTelevision();
    }

    @Override
    public Refrigerator newRefrigerator() {
        return new TCLRefrigerator();
    }
}


public class MeiDFactory implements Factory {
    @Override
    public Television newTelevision() {
        return new MeiDTelevision();
    }

    @Override
    public Refrigerator newRefrigerator() {
        return new MeiDRefrigerator();
    }
}
  1. 实现具体产品类
public class TCLTelevision implements Television {
    @Override
    public void dosomething() {
        System.out.println("我是TCL电视机，我可以看电视");
    }
}

public class MeiDTelevision implements Television {
    @Override
    public void dosomething() {
        System.out.println("我是美的电视机，我可以看电视");
    }
}

public class TCLRefrigerator implements Refrigerator {
    @Override
    public void dosomething() {
        System.out.println("我是TCL冰箱，我可以洗衣服");
    }
}

public class MeiDRefrigerator implements Refrigerator {
    @Override
    public void dosomething() {
        System.out.println("我是美的冰箱，我可以洗衣服");
    }
}
  1. 测试
public class Main {
    public static void main(String[] args) {
        Factory factory = new TCLFactory();
        Television television = factory.newTelevision();
        Refrigerator refrigerator = factory.newRefrigerator();
        television.dosomething(); // 我是TCL电视机，我可以看电视
        refrigerator.dosomething(); // 我是TCL冰箱，我可以洗衣服

        factory = new MeiDFactory();
        television = factory.newTelevision();
        refrigerator = factory.newRefrigerator();
        television.dosomething(); // 我是美的电视机，我可以看电视
        refrigerator.dosomething(); // 我是美的冰箱，我可以洗衣服
    }
}

4.良好拓展性

  1. 新增产品族
    假设某天新增海尔的电视机和冰箱，
    image
    体现了开闭原则，对修改关闭，对拓展开放。产品族拓展不需要修改源代码即可实现功能拓展。
  2. 新增产品等级
    假设某天TCL和美的上新电风扇，
    image
    当需要增加一个新的产品时，所有的工厂类都需要进行修改，修改产品等级时，不满足开闭原则。所以，这也是抽象工厂的一个弊端。
Jakob_Hu
关注
专栏目录
设计模式之简单工厂模式
iva_brother的博客
01-18 2080
当我们在生产汽车的时候，就算是一个品牌也会分为不同的型号，每个车的外形可能不一样，但是汽车的零件大部分是可以通用的。如果我们为每个型号的汽车都去建立但是建立一个生产线，每个零件都在那个独立的生产线去生产，这将会造成很大的浪费，会增加很多成本。我们知道现在社会之所以发展得这么快，是因为社会有明确的分工。所以在上述生产车辆的例子中，我们可以将通用的零件放在同一生产线生产，这样可以大大的降低成本。所谓的
设计模式-简单工厂模式
xiaohua1230的博客
05-11 1477
设计模式-简单工厂模式
简单工厂创建不同几何图形（Java代码实例）
热门推荐
米莱虾
09-15 1万+
使用简单工厂模式设计一个可以创建不同几何图形（Shape），如Circle，Rectangle，Triangle等绘图工具类，每个几何图形均具有绘制Draw()和擦除Erase()两个方法；要求在绘制不支持的几何图形时，抛出一个UnsuppShapeException异常，绘制类图并使用Java语言实现。 /** * Description: 抽象产品角色 */ public abstract class Shape { public abstract void draw();
简单工厂模式（创建型）
m0_45329584的博客
03-18 390
1.简单工厂 1.1定义 简单工厂模式 (Simple Factory Pattern)：定义一个工厂类，它可以根据参数的不同返回不同类的实例，被创建的实例通常都具有共同的父类。 简单工厂模式定义的有关说明： 在简单工厂模式中用于创建实例的方法通常是静态(static)方法，因此又被称为静态工厂方法(Static Factory Method)模式 要点：如果需要什么，只需要传入一个正确的参数，就可以获取所需要的对象，而无须知道其创建细节 1.2角色 简单工厂模式的组成部分： Factory（工厂角色
简单工厂模式实例
shiaiao的博客
07-04 3229
简单工厂模式实例问题描述结构图编程实现接口实现类自定义UnsupportedShapeException异常类工厂类客户端 问题描述 使用简单工厂模式设计一个可以创建不同几何形状(Shape)，如圆形(Circle)、矩形 (Rectangle)和三角形(Triangle)等的绘图工具类，每个几何图形均具有绘制Draw()和擦除 Erase()两个方法，要求在绘制不支持的几何图形时，抛出一个UnsupportedShapeException 异常。绘制类图并编程模拟实现。 结构图 编程实现 接口 publ
JS 设计模式之：工厂模式定义与实现方法浅析
11-21
工厂模式是一种创建对象的 创建型模式，遵循 DRY（Don’t Repeat Yourself）原则。在该模式下，代码将会根据具体的输入或其他既定规则，自行决定创建哪种类型的对象。简单点儿说就是，动态返回需要的实例对象。 回顾...
探索Java设计模式：工厂模式与抽象工厂模式的比较
最新发布
08-14
工厂模式和抽象工厂模式是两种常用的创建型设计模式，它们在Java中有着广泛的应用。本文将详细探讨这两种模式的区别，并提供代码示例来加深理解。 工厂模式和抽象工厂模式都是创建型设计模式，它们提供了代码解耦和...
Python 程序语言设计模式思路-创建型模式：工厂模式，创建对象的统一接口，封装对象的创建逻辑
05-21
工厂模式（Factory Pattern）作为创建型模式的一种，通过提供一个统一的接口来创建对象，封装对象的创建逻辑，提高代码的灵活性和可维护性。
创建型设计模式---工厂设计模式实现
08-13
创建型设计模式---工厂设计模式实现
创建型设计模式----抽象工厂模式
08-13
抽象工厂模式是创建型设计模式的一种，它提供了一种创建对象族（一组具有相互依赖关系的对象）的方法，而无需指定具体类。这种模式的核心在于它允许客户端代码与具体实现细节解耦，使得更换一个产品族变得更为容易。...
C++简单工厂模式(设计绘图工具)
12-22
C++简单工厂模式(设计绘图工具)，如可创建圆形(Circle)、矩形(Rectangle)和三角形(Triangle)对象
创建型模式--工厂模式（Factory Pattern)示范代码
01-18
java 创建型模式--工厂模式（Factory Pattern)示范代码demo,关于工厂模式可以查看我的博客 http://blog.csdn.net/u012930316/article/details/54599580
设计模式之创建型模式实验.docx
12-15
①使用简单工厂模式设计一个可以创建不同几何形状( Shape)(例如圆形( Circle).、矩形 Rectangle)和三角形( ( Triangle)等的绘图工具类,每个几何图形均具有绘制方法daw()和擦除方法 erase(),要求在绘制不支持的几何图形时,抛出一个 UnsupportedShapeException异常。绘制类图并编程模拟实现。 ②在某网络管理软件中,需要为不同的网络协议提供不同的连接类,例如针对POP3协议的连接类POP3Connection、针对IMAP协议的连接类 IMAPConnection、针对HTTP协议的连接类 HTTPConnection等。
利用策略模式和简单工厂模式，实现商场收银软件。 营业员根据所购买商品的单价和数量，向客户收费
04-25
利用策略模式和简单工厂模式，实现商场收银软件。 营业员根据所购买商品的单价和数量，向客户收费 软件功能包括： 1、正常收费 2、打折收费（1折、5折、9折）
设计模式---------------简单工厂模式
weixin_33809981的博客
09-24 432
设计模式---------------简单工厂模式一、题目（Question）使用简单工厂模式设计一个可以创建不同几何形状（如圆形、方形和三角形等）的绘图工具，每个几何图形都要有绘制draw()和擦除erase()两个方法，要求在绘制不支持的几何图形时，提示一个Unsupported Exception异常。二、类图（Class Diagram）三、代码（Code）Shape...
创建型模式之简单工厂模式
stsfang
01-20 165
简单工厂模式介绍 写在前面 阅读本文之前你需要知道 1. 连接基本的UML类图结构 2. 类关系 简单工厂模式并不属于GoF的23个经典模式，但通常把它作为学习其他工厂模式的基础，它的设计思想比较简单： 首先将需要创建的各种不同对象的相关代码封装到不同的类中，这些类称为具体产品类，而将它们公共的代码进行抽象和提取后封装到一个抽象产品类中，每
设计模式之工厂模式
qq_43478882的博客
04-11 763
最近刚做完毕业设计，但回头看看代码，觉得设计不够合理，存在耦合度较高的情况（说白了就是一座屎山）。在写代码的时候很少去考虑该用什么设计模式。所以接下来一段时间会复习一下设计模式的内容。 一、简单工厂模式 1、定义 简单工厂模式并不属于GoF的23种经典的设计模式，但常常作为其他设计模式的基础。定义如下： 简单工厂模式（Simple Factory Pattern）：定义一个工厂类，它可以根据参数的不同返回不同类的实例，被创建的实例通常都具有共同的父类。 用现实例子距离。一个水果农场，顾客告
设计模式起点之简单工厂模式
weixin_43594279的博客
03-17 769
文章目录前言一、简单工厂模式二、简单工厂模式实例之图形工厂1.实例说明2.实例类图3.实例代码参考文献 前言 简单工厂模式并不是GoF 23个设计模式中的一员，但是一般将其作为学习设计模式的起点。在简单工厂模式中，可以根据参数的不同返回不同的类的实例，简单工厂模式专门定义一个类来负责创建其他类的实例，这个类称为工厂类，被创建的实例通常都具有共同的父类。 一、简单工厂模式 **简单工厂模式（Simple Factory Pattern）**又称为静态工厂方法模式（Static Factory Method P
工厂方法模式
小男孩tom的博客
11-23 122
使用场景： 1、项目中多处new同一个对象，当new的这个对象名称发生改变的时候需要在所有的地方进行修改，增加代码维护成本； 2、一个项目需要连接多种数据库Mysql、Oracle、MongoDB、Redeis等 代码示例： 案例1-链接不同数据库： <?php interface DB { public function parseDsn(); } class Mysq...
创建型设计模式解析：工厂方法、抽象工厂与单件模式
创建型设计模式是软件设计中的一种重要模式，它们主要用于对象的创建，使得对象的创建过程更加灵活，易于管理和扩展。 **1. 工厂方法模式** 工厂方法模式提供了一个简单的决策机制，可以根据条件生成不同的产品。它...
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值