源码在我的githubgitee中获取

工厂模式

工厂模式介绍

	工厂模式是我们最常用的实例化对象模式了,是用工厂方法代替new操作的一种模式。著名的Jive论坛 ,就大量使用了工厂模式,工厂模式在Java程序系统可以说是随处可见。因为工厂模式就相当于创建实例对象的new,我们经常要根据类Class生成实例对象,如A a=new A() 工厂模式也是用来创建实例对象的,所以以后new时就要多个心眼,是否可以考虑使用工厂模式,虽然这样做,可能多做一些工作,但会给你系统带来更大的可扩展性和尽量少的修改量。(百度百科)

	工厂模式又分为:
  • 简单工厂模式:允许接口创建对象,但不会暴露对象的创建逻辑。
  • 工厂方法模式: 允许接口创建对象,但使用哪个类来创建对象,则是交由子类决定的
  • 抽象方法模式: 抽象工厂是一个能够创建一系列相关的对象而无需指定/公开其具体类的接口。该模式能够提供其他工厂的对象,在其内部创建其他对象。

简单工厂模式

属于创建型模式,又叫做静态工厂方法模式,不属于23种GOF设计模式之一。是由一个工厂对象决定创建出哪一种产品类的实例。违背“开放 - 关闭原则”,一旦添加新产品就不得不修改工厂类的逻辑,这样就会造成工厂逻辑过于复杂。

假设现在有一家餐馆

public interface Restaurant {
public void cook();
}

餐馆有两种菜品:红烧肉和鸡蛋羹

//鸡蛋羹
public class Egg implements Restaurant {
@Override
public void cook() {
System.out.println("鸡蛋羹做好了");
}
}
//红烧肉
public class Meet implements Restaurant{
@Override
public void cook() {
System.out.println("红烧肉做好了");
}
}

餐馆里有服务员,来负责向后厨传达客人的需求

public class Waiter {
//同样可以定义常量然后通过switch语句来实现
public static Restaurant getFood(String orderType) {
Restaurant restaurant = null;
if(orderType.equals("红烧肉")){
restaurant = new Meet();
}else if (orderType.equals("鸡蛋羹")){
restaurant = new Egg();
}
return restaurant;
}
}

现在顾客来了,要点一份红烧肉,就只需要和服务员说就行

public class Customer {
public static void main(String[] args) {
Restaurant restaurant = Waiter.getFood("红烧肉");
restaurant.cook();
}
}

输出

红烧肉做好了

通过以上方法,的确实现了 提供创建实例的功能,而无需关心具体实现。但是我们不难发现,这种方法的扩展性很差,如果餐馆新出了一款菜品,还需要我们在服务员方法里修改。这使得当餐馆的菜品很多时,工厂方法代码逻辑将会非常复杂

工厂方法模式

工厂方法模式,又称工厂模式、多态工厂模式和虚拟构造器模式,通过定义工厂父类负责定义创建对象的公共接口,而子类则负责生成具体的对象。是在工厂模式家族中是用的最多模式,一般项目中存在最多的就是这个模式。是对简单工厂模式的一个优化,让每个对象都有一个与之对应的工厂。

这里我们接着用上面的例子,假设这家餐厅的生意非常好,所以餐馆的老板把餐馆所有负责点餐的服务员都辞退了,取而代之的是添加了一个收银台,然后让每个厨师只负责做一样菜。这样客人只需要和收银台说要求就行了。

这里我们接着用上面的类。除去服务员Waiter类

新建Cashier接口

/**
* @author codermy
* @createTime 2020/6/15
*/
public interface Cashier {
public Restaurant getFood();
}

然后给每一个菜品新建一个工厂类

EggCooker

/**
* @author codermy
* @createTime 2020/6/15
*/
public class EggCooker implements Cashier {
@Override
public Restaurant getFood() {
return new Egg();
}
}

MeetCooker

/**
* @author codermy
* @createTime 2020/6/15
*/
public class MeetCooker implements Cashier{
@Override
public Restaurant getFood() {
return new Meet();
}
}

然后顾客点单只需要在收银台,餐厅的系统会自动将信息传递给相应的厨师,对应的厨师就能在餐馆中把菜做好

/**
* @author codermy
* @createTime 2020/6/15
* 消费者
*/
public class Customer {
public static void main(String[] args) {
Cashier order = new EggCooker();
Restaurant food = order.getFood();
food.cook();
}
}

输出结果

鸡蛋羹做好了

工厂方法模式解决了简单工厂模式不符合的开闭原则,当添加一个菜品时,只需要再雇佣一个厨师就行(从现实角度看,老板有点亏哦)。但是这也增加了系统的复杂度(菜越多,厨师就越多,这哪家餐馆顶的住)

抽象工厂模式

这个模式解决了每个工厂只能创建一类产品(工厂方法模式)的问题

这里用餐馆的例子不太形象,不是很容易理解,强行举例可能会和上面的方法弄混,我自己绕了好一会,所以我们换一个例子。

现在我们人手不离手机,我们假设手机有如下几个功能

//手机产品接口
public interface IphoneProduct {
void callup();//打电话
void sendSms();//发短信
}

每个人家里又都有路由器,路由器有如下功能

//路由器产品接口
public interface IRouterProduct {
void openwifi();//开启wifi
void setting();//设置wifi
}

然后现在有一个抽象产品工厂,是来生产这两样产品的,假设生产手机和路由器的方法是一样的,只是需要加上厂商信息

//抽象产品工厂
public interface IProductFactory {
//生产手机
IphoneProduct iphoneProduct();
//生产路由器
IRouterProduct iRouterProduct();
}

现在有两家厂商,小米和华为工厂,可以生产手机和路由器,他们两家厂商分别由两条产业线来做手机和路由器

//小米手机
public class XiaomiPhone implements IphoneProduct{ @Override
public void callup() {
System.out.println("用小米手机打电话");
} @Override
public void sendSms() {
System.out.println("用小米手机发短信");
}
}
//小米路由器
public class XiaomiRouter implements IRouterProduct { @Override
public void openwifi() {
System.out.println("打开小米wifi");
} @Override
public void setting() {
System.out.println("设置小米wifi");
}
}
//小米厂商
public class XiaomiFactory implements IProductFactory {
@Override
public IphoneProduct iphoneProduct() {
return new XiaomiPhone();
} @Override
public IRouterProduct iRouterProduct() {
return new XiaomiRouter();
}
}
//华为手机
public class HuaweiPhone implements IphoneProduct { @Override
public void callup() {
System.out.println("用华为手机打电话");
} @Override
public void sendSms() {
System.out.println("用华为手机发短信");
}
}
//华为路由器
public class HuaweiRouter implements IRouterProduct { @Override
public void openwifi() {
System.out.println("打开华为wifi");
} @Override
public void setting() {
System.out.println("设置华为wifi");
}
}
//华为工厂
public class HuaweiFactory implements IProductFactory {
@Override
public IphoneProduct iphoneProduct() {
return new HuaweiPhone();
} @Override
public IRouterProduct iRouterProduct() {
return new HuaweiRouter();
}
}

消费者类

//消费者/测试类
public class Customer {
public static void main(String[] args) { System.out.println("==============小米产品=================");
XiaomiFactory xiaomiFactory = new XiaomiFactory();//新建一个小米工厂
IphoneProduct xiaomiiphoneProduct = xiaomiFactory.iphoneProduct();//小米工厂开始生产小米手机
xiaomiiphoneProduct.callup();//测试小米手机打电话功能
IRouterProduct xiaomiiRouterProduct = xiaomiFactory.iRouterProduct();//小米工厂开始生产小米路由器
xiaomiiRouterProduct.openwifi();//测试小米路由器打开wifi功能 System.out.println("==============华为产品=================");
HuaweiFactory huaweiFactory = new HuaweiFactory(); IphoneProduct huaweiiphoneProduct1 = huaweiFactory.iphoneProduct();
huaweiiphoneProduct1.callup();
IRouterProduct huaweiiRouterProduct = huaweiFactory.iRouterProduct();
huaweiiRouterProduct.openwifi();
}
}

输出

==============小米产品=================
用小米手机打电话
打开小米wifi
==============华为产品=================
用华为手机打电话
打开华为wifi

抽象工厂模式相较于以上两种模式难以理解一些。这里提供另一种写法比较好理解,来自Guide哥的博客(以下所有内容)

不知道大家玩过穿越火线或者吃鸡这类游戏了吗,游戏中存在各种枪。我们假设现在存在AK、M4A1两类枪,每一种枪对应一种子弹。我们现在这样考虑生产AK的工厂可以顺便生产AK使用的子弹,生产M4A1的工厂可以顺便生产M4A1使用的子弹。(AK工厂生产AK系列产品包括子弹啊,AK枪的类型啊这些,M4A1工厂同理)

————————————————

(1)创建相关接口:

public interface Gun {
public void shooting();
}

子弹

public interface Bullet {
public void load();
}

(2)创建接口对应实现类:

AK类

public class AK_Bullet implements Bullet {

    @Override
public void load() {
System.out.println("Load bullets with AK");
} }

M4A1类

public class M4A1 implements Gun {

    @Override
public void shooting() {
System.out.println("shooting with M4A1"); } }

AK子弹类

public class AK_Bullet implements Bullet {

    @Override
public void load() {
System.out.println("Load bullets with AK");
} }

M4A1子弹类

public class AK_Bullet implements Bullet {

    @Override
public void load() {
System.out.println("Load bullets with AK");
} }

(3)创建工厂接口

public class AK_Bullet implements Bullet {

    @Override
public void load() {
System.out.println("Load bullets with AK");
} }

(4)创建具体工厂

生产AK和AK子弹的工厂

public class AK_Bullet implements Bullet {

    @Override
public void load() {
System.out.println("Load bullets with AK");
} }

生产M4A1和M4A1子弹的工厂

public class AK_Bullet implements Bullet {

    @Override
public void load() {
System.out.println("Load bullets with AK");
} }

(5)测试

public class AK_Bullet implements Bullet {

    @Override
public void load() {
System.out.println("Load bullets with AK");
} }

输出结果:

Load bullets with AK
shooting with AK

java23种设计模式——三、工厂模式的更多相关文章

  1. Spring 实现两种设计模式:工厂模式和单态模式(单例模式)

    本文摘自:李刚 著 <轻量级 Java EE企业应用实战 Struts2+Spring+hibernate整合开发> 在Spring 中大量使用的以下两种设计模式:工厂模式和单态模式. 工 ...

  2. java23种设计模式之八: 工厂方法模式

    定义: 定义一个创建产品对象的工厂接口,将产品对象的实际创建工作推迟到具体子工厂类当中.这满足创建型模式中所要求的“创建与使用相分离”的特点. 我们把被创建的对象称为“产品”,把创建产品的对象称为“工 ...

  3. 24种设计模式--抽象工厂模式【Abstract Factory Pattern】

    女娲造人,人是造出来了,世界是热闹了,可是低头一看,都是清一色的类型,缺少关爱.仇恨.喜怒哀乐等情绪,人类的生命太平淡了,女娲一想,猛然一拍脑袋,忘记给人类定义性别了,那怎么办?抹掉重来,然后就把人类 ...

  4. java23种设计模式之四:建造者模式

    在软件开发过程中有时需要创建一个复杂的对象,这个复杂对象通常由多个子部件按一定的步骤组合而成.例如:在新招收一个员工时,对个人信息对象的创建,在不同的阶段,需要个人信息的内容也不一样,姓名.性别.年龄 ...

  5. Java--23种设计模式之decorator模式

    装饰模式:装饰模式以对客户端透明的方式扩展对象的功能,是继承关系的一个替代方案,提供比继承更多的灵活性.动态给一个对象增加功能,这些功能可以再动态的撤消.增加由一些基本功能的排列组合而产生的非常大量的 ...

  6. java23种设计模式之一: 策略模式

    由于最近在研究学习设计模式,我会用自己的理解方式来表述对设计模式的学习和认识,通过最常用.好记的案例来记住和使用设计模式,希望对设计代码方面有所提高和改进. 一.应用背景     在软件开发中常常遇到 ...

  7. java23种设计模式之一: 代理模式(动态代理)

    在学习Spring的时候,我们知道Spring主要有两大思想,一个是IoC,另一个就是AOP,对于IoC,依赖注入就不用多说了,而对于Spring的核心AOP来说,我们不但要知道怎么通过AOP来满足的 ...

  8. java23种设计模式之: 策略模式,观察者模式

    策略模式  --老司机开车,但是他今天想到路虎,明天想开奔驰...针对他不同的需求,来产生不同的应对策略    策略类是一个接口,定义了一个大概的方法,而实现具体的策略则是由实现类完成的,这样的目的是 ...

  9. java23种设计模式之五:代理模式

    一.代理模式介绍 代理模式的定义:就是为一个接品(对象)提供一个代理的对象,并由这个代理对象控制对原对象的访问流程 其中代理又分为:静态代理和动态代理 静态代理:指的是自己要写一个代理类,或者用工具生 ...

随机推荐

  1. 小甲鱼零基础汇编语言学习笔记第五章之[BX]和loop指令

         这一章主要介绍什么是[BX]以及loop(循环)指令怎么使用,loop和[BX]又怎么样相结合,段前缀又是什么鬼,以及如何使用段前缀.   1.[BX]的概念      [BX]和[0]类似 ...

  2. 精讲RestTemplate第1篇-在Spring或非Spring环境下如何使用

    一.什么是 RestTemplate? RestTemplate是执行HTTP请求的同步阻塞式的客户端,它在HTTP客户端库(例如JDK HttpURLConnection,Apache HttpCo ...

  3. 数据结构C语言实现----选择排序

    选择排序 第一步:从一串无序数字串中选一个最小的与第一个数交换位置 第二步:从剩下的数字中选一个最小的与第二个数交换位置 第三步:从剩下的数字中选一个最小的与第三个数字交换位置 以此类推... 运行结 ...

  4. python爬虫学习05-爬取图片

    python爬虫学习05-爬取图片 确定要爬取的网址:https://shenan.tuchong.com/20903415/#image309854686 要爬取的内容:使用浏览器插件xpath对图 ...

  5. Kaggle-pandas(3)

    Summary-functions-and-maps 教程 在上一教程中,我们学习了如何从DataFrame或Series中选择相关数据. 正如我们在练习中所展示的,从我们的数据表示中提取正确的数据对 ...

  6. 强大的输入框-应用快速启动uTools

    uTools uTools是一个 极简.插件化.跨平台 的现代桌面软件.通过自由选配丰富的插件,打造你得心应手的工具集合. 当你熟悉它后,能够为你节约大量时间,让你可以更加专注地改变世界. uTool ...

  7. office2010的破解工具

    office2010的破解工具,找了好多的密钥都不合适,直接用这个软件一键搞定, 下载地址:https://pan.baidu.com/s/1phPwihCDipGwGdSmjWNeYw 提取码:8m ...

  8. C语言学习笔记之输出缓冲

    在c语言中经常用到输出函数printf,当我们像往常一样在输出函数中输入我们的想要的输出的东西后加\n换行 验证结果如我们输出的一样 如果我们在后面加入死循环会不会出现这些语句呢 结果卡死了,可还是输 ...

  9. 朴素贝叶斯分类器基本代码 && n折交叉优化

    自己也是刚刚入门.. 没脸把自己的代码放上去,先用别人的. 加上自己的解析,挺全面的,希望有用. import re import pandas as pd import numpy as np fr ...

  10. 16、Java中级进阶 面向对象 封装

    1.封装概述 封装可以被认为是一个保护屏障,将类的某些信息隐藏在类内部,不允许外部程序直接访问,而是通过类提供的方法来实现对隐藏信息的操作访问,可以有效的防止该类的代码和数据被其他类随意访问. 要访问 ...