GoF23:工厂模式(Factory)
GoF23:工厂模式(Factory)
核心本质:
- 实例化对象不使用new,用工厂方法代替
- 将选择实现类,创建对象统一管理和控制。从而将调用者跟我们的实现类解耦
工厂模式三种模式
- 简单工厂模式(静态工厂模式)
- 工厂方法模式
- 抽象工厂模式
简单工厂模式(静态工厂模式)
用来生产同一等级结构中的任意产品(对于增加新的产品,需要扩展已有的代码,不符合开闭原则)
现在定义一种情景,就是消费者去买车,他可以自己组成车,也可以找一个工厂来生产几种不同类型的车,也可以到专门生产该车型的工厂买。
- 定义一个接口
public interface Car {
void getName();
}
- 让两种不同的汽车类都去实现Car接口
public class Tesla implements Car{
@Override
public void getName() {
System.out.println("特斯拉汽车");
}
}
public class WuLing implements Car{
@Override
public void getName() {
System.out.println("五菱汽车");
}
}
在Consumer的主方法中的操作相当于是我们自己组成的对象(自己组车):
public class Consumer {
public static void main(String[] args) {
// 原先我们要使用哪个对象,都是我们自己new出来的,相当于是自己创建的
Car car1 = new WuLing();
Car car2 = new Tesla();
car1.getName();
car2.getName();
}
}
现在我们让一个工厂来生产我们所需要的对象,不需要我们自己去new了:
/**
* 简单工厂模式,并不符合开闭原则,如果新增产品,就必须对原先的代码进行修改
*/
public class CarFactory {
// 方式一:
public static Car getCar(String name) {
if ("五菱".equals(name)) {
return new WuLing();
} else if ("特斯拉".equals(name)) {
return new Tesla();
} else {
return null;
}
}
// 方式二:
public static Car getWuLing() {
return new WuLing();
}
public static Car getTesla() {
return new Tesla();
}
}
在Consumer的主方法中的操作相当于从工厂中获取我们需要的对象:
public class Consumer {
public static void main(String[] args) {
// 现在使用简单工厂模式,来获取我们需要的对象
Car car1 = CarFactory.getCar("五菱");
Car car2 = CarFactory.getCar("特斯拉");
car1.getName();
car2.getName();
}
}
但是上面的简单工厂有一些弊端,如果我们需要新增一个类,就需要对工厂中的代码进行修改,这不符合开闭原则(对扩展是开放的,对修改是关闭的)
工厂方法模式
用来生产同一等级结构中的固定产品(支持增加任意)
工厂方法模式还是承接上面的情景,只不过每一个对象,即车,都有一个专门工厂去生产该对象。
public interface Car {
void getName();
}
- 对原来的CarFactory进行提取,相当于是加上一层
public interface CarFactory {
Car getCar();
}
public class WuLing implements Car {
@Override
public void getName() {
System.out.println("五菱汽车");
}
}
- 专门生产五菱汽车的工厂
public class WuLingFactory implements CarFactory{
@Override
public Car getCar() {
return new WuLing();
}
}
public class Tesla implements Car {
@Override
public void getName() {
System.out.println("特斯拉汽车");
}
}
- 专门生产特斯拉汽车的工厂
public class TeslaFactory implements CarFactory{
@Override
public Car getCar() {
return new Tesla();
}
}
- 不去new我们需要的对象,而是new一个工厂对象去生产我们需要的对象
public class Consumer {
public static void main(String[] args) {
Car car1 = new WuLingFactory().getCar();
Car car2 = new TeslaFactory().getCar();
car1.getName();
car2.getName();
}
}
工厂方法模式就可以避免修改CarFactory中的代码,当我们需要新增一个对象时,只需要创建生产对象的工厂即可。符合开闭原则,但是无论在结构复杂度、管理复杂度……都是simple简单工厂占优势,因此在设计原则上:工厂方法模式,在实际业务中:简单工厂模式。
抽象工厂模式
围绕一个超级工厂创建其他工厂。该超级工厂又称为其他工厂的工厂。
举例说明
- UML类图:
- Creator:产品族工厂,定义了一系列的产品生产行为
- ConcreteCreator:具体的产品族工厂
- Product:抽象产品接口
- ProductA1/A2/B1/B2:都是具体的产品,实现了相应的产品接口
举个栗子:
手机是一个抽象的产品,手机有小米手机,华为手机,路由器也是一个抽象的产品,路由器有小米路由器,华为路由器。
具体的手机和抽象手机就构成了一个产品等级结构。
具体的路由器和抽象路由器就构成了另外一个产品等级结构。
实质上产品等级结构即产品的继承结构,即它们都实现了相同的接口。
划重点就是产品族中的产品都是由同一个工厂生产的,位于不同的产品等级结构。因为同一产品族中的各个产品,实现的不是相同的接口,所以不位于同一产品等级结构。
它们之间的关系如下图所示:
对上图的说明:
图中横坐标代表产品等级,新增产品等级为横坐标的增长,方向向右,具体表现为新增一列;
图中纵坐标为产品族等级,新增产品族为纵坐标的增长,方向向上,具体表现为新增一排;
对比一下工厂方法和抽象工厂方法:
工厂模式针对的是产品等级结构,定义一种生产该产品工厂的接口,让不同类型的厂商去分别实现它,每一个实现了接口的工厂专门用来生产这一种产品。
抽象工厂模式针对的是产品族等级结构,这个抽象工厂是用来生产工厂的,被生产的工厂再去生产它们各自产品族中的产品,这样,每一个实现类工厂都可以生产本产品族的不同产品。
如何选择:
在两者的使用选择,要结合实际业务,对于产品等级数量相对固定的产品族,可以优先考虑抽象工厂模式,但是如果频繁变动,则不大适用,因为在现有的产品族中新增产品等级时,就需要修改产品族工厂,也就违背了开闭原则;而对于新增产品族,只需实现相应的接口即可,不需要修改产品族工厂中的代码。
代码实现
这里以上面的手机和路由器为栗:
简要的实现说明:
- 定义抽象产品接口
//手机产品接口
public interface IPhoneProduct {
//开机
void start();
//关机
void shutdown();
//拨打电话
void callUp();
//发送短信
void sendSMS();
}
//路由器产品接口
public interface IRouterProduct {
//开机
void start();
//关机
void shutdown();
//开启wifi
void openWifi();
//设置参数
void setting();
}
- 定义小米品牌手机和路由器产品实现类、华为品牌手机和路由器产品实现类
//小米手机产品
public class XiaomiPhone implements IPhoneProduct {
@Override
public void start() {
System.out.println("开启小米手机");
}
@Override
public void shutdown() {
System.out.println("关闭小米手机");
}
@Override
public void callUp() {
System.out.println("用小米手机打电话");
}
@Override
public void sendSMS() {
System.out.println("用小米手机发短信");
}
}
//小米路由器产品
public class XiaomiRouter implements IRouterProduct {
@Override
public void start() {
System.out.println("启动小米路由器");
}
@Override
public void shutdown() {
System.out.println("关闭小米路由器");
}
@Override
public void openWifi() {
System.out.println("打开小米路由器的wifi功能");
}
@Override
public void setting() {
System.out.println("设置小米路由器参数");
}
}
//华为手机产品
public class HuaweiPhone implements IPhoneProduct {
@Override
public void start() {
System.out.println("开启华为手机");
}
@Override
public void shutdown() {
System.out.println("关闭华为手机");
}
@Override
public void callUp() {
System.out.println("用华为手机打电话");
}
@Override
public void sendSMS() {
System.out.println("用华为手机发短信");
}
}
//华为路由器产品
public class HuaweiRouter implements IRouterProduct {
@Override
public void start() {
System.out.println("启动华为路由器");
}
@Override
public void shutdown() {
System.out.println("关闭华为路由器");
}
@Override
public void openWifi() {
System.out.println("打开华为路由器的wifi功能");
}
@Override
public void setting() {
System.out.println("设置华为路由器参数");
}
}
- 定义一个抽象工厂接口,或者称之为抽象产品族工厂
//抽象产品工厂(定义了同一个产品族的产品生产行为)
public interface IProductFactory {
//生产手机
IPhoneProduct produceTelPhone();
//生产路由器
IRouterProduct produceRouter();
}
- 小米工厂和华为工厂的实现了
//小米产品工厂
public class XiaomiProductFactory implements IProductFactory {
@Override
public IPhoneProduct produceTelPhone() {
System.out.println(">>>>>>生产小米手机");
return new XiaomiPhone();
}
@Override
public IRouterProduct produceRouter() {
System.out.println(">>>>>>生产小米路由器");
return new XiaomiRouter();
}
}
//华为产品工厂
public class HuaweiProductFactory implements IProductFactory{
@Override
public IPhoneProduct produceTelPhone() {
System.out.println(">>>>>>生产华为手机");
return new HuaweiPhone();
}
@Override
public IRouterProduct produceRouter() {
System.out.println(">>>>>>生产华为路由器");
return new HuaweiRouter();
}
}
- 客户端
//客户端
public class Client {
public static void main(String[] args) {
System.out.println("===================小米系列产品=================");
//小米产品工厂实例
IProductFactory xiaomiProductFactory = new XiaomiProductFactory();
//生产小米路由器
IRouterProduct xiaomiRouter = xiaomiProductFactory.produceRouter();
xiaomiRouter.start();
xiaomiRouter.setting();
xiaomiRouter.openWifi();
xiaomiRouter.shutdown();
//生产小米手机
IPhoneProduct xiaomiPhone = xiaomiProductFactory.produceTelPhone();
xiaomiPhone.start();
xiaomiPhone.callUp();
xiaomiPhone.sendSMS();
xiaomiPhone.shutdown();
System.out.println("===================华为系列产品=================");
//华为产品工厂实例
IProductFactory huaweiProductFactory = new HuaweiProductFactory();
//生产华为路由器
IRouterProduct huaweiRouter = huaweiProductFactory.produceRouter();
huaweiRouter.start();
huaweiRouter.setting();
huaweiRouter.openWifi();
huaweiRouter.shutdown();
//生产华为手机
IPhoneProduct huaweiPhone = huaweiProductFactory.produceTelPhone();
huaweiPhone.start();
huaweiPhone.callUp();
huaweiPhone.sendSMS();
huaweiPhone.shutdown();
}
}
- 运行结果:
===小米系列产品=
>>>>>>生产小米路由器
启动小米路由器
设置小米路由器参数
打开小米路由器的wifi功能
关闭小米路由器
>>>>>>生产小米手机
开启小米手机
用小米手机打电话
用小米手机发短信
关闭小米手机
===华为系列产品=
>>>>>>生产华为路由器
启动华为路由器
设置华为路由器参数
打开华为路由器的wifi功能
关闭华为路由器
>>>>>>生产华为手机
开启华为手机
用华为手机打电话
用华为手机发短信
关闭华为手机
- 关系图:
GoF23:工厂模式(Factory)的更多相关文章
- 设计模式(一)工厂模式Factory(创建型)
设计模式一 工厂模式Factory 在面向对象编程中, 最通常的方法是一个new操作符产生一个对象实例,new操作符就是用来构造对象实例的.可是在一些情况下, new操作符直接生成对象会带来一些问题. ...
- 设计模式(一)工厂模式Factory(创建类型)
设计模式一 工厂模式Factory 在面向对象编程中, 最通常的方法是一个new操作符产生一个对象实例,new操作符就是用来构造对象实例的.可是在一些情况下, new操作符直接生成对象会带来一些问题. ...
- 工厂模式(Factory)和抽象工厂模式(Abstract Factory)
一.工厂模式(Factory):通过让子类决定该创建的对象是什么,来达到将对象创建的过程封装的目的,工厂方法让类的实例化推迟到子类 (1)涉及角色:抽象产品,具体产品,抽象创建者,具体创建者. ...
- 设计模式(一)工厂模式Factory(创建型)(转)
原文链接:http://blog.csdn.net/hguisu/article/details/7505909 设计模式一 工厂模式Factory 在面向对象编程中, 最通常的方法是一个new操作符 ...
- JAVA:将反射技术应用于工厂模式(Factory)和单例模式(Singleton)的简单代码
反射技术大量用于Java设计模式和框架技术,最常见的设计模式就是工厂模式(Factory)和单例模式(Singleton). 参考URL: http://blog.csdn.net/xiaohai79 ...
- 设计模式 - 工厂模式(factory pattern) 具体解释
版权声明:本文为博主原创文章,未经博主同意不得转载. https://blog.csdn.net/u012515223/article/details/27081511 工厂模式(factory pa ...
- 工厂模式 - Factory
简单工厂模式 SimpleFactory Pattern,将一个具体类的实例化交给一个静态工厂方法来执行. 特点: 增加功能需要修改工厂类,扩展性较差: 参考: 设计模式学习笔记 - 简单工厂模式: ...
- 设计模式--工厂模式Factory(创建型)
工厂模式属于创建型模式,分为三类,简单工厂模式.工厂方法模式.抽象工厂模式. 一.简单工厂模式 在工厂中做判断,根据产品类型从而创造相应的产品,当增加新产品时需要修改工厂类. 例如: enum CTY ...
- 工厂模式/factory模式/创建型模式
工厂模式 普通工厂模式 原本需要new出来的对象,通过一个类的方法去搞定,Factory.build(parameter),类似这种. public interface Sender { public ...
随机推荐
- 【Java】【常用类】Object 基类 源码学习
源码总览: 有好些都是native本地方法,背后是C++写的 没有关于构造器的描述,默认编译器提供的无参构造 https://blog.csdn.net/dmw412724/article/detai ...
- 知识点一:OSI模型初识
OSI(开放系统)模型是一组协议的集合,它使得两个不同的系统之间能够互相通信,分为七层 第一层:物理层 物理层负责把逐个的比特(01)从一个节点移动到下个节点 具体体现在如何把比特转换成电或者光信号. ...
- S7通信协议之你不知道的事儿
在电气学习的路上,西门子PLC应该是我的启蒙PLC,从早期的S7-300/400 PLC搭建Profibus-DP网络开始接触,到后来的S7-200Smart PLC,再到现在的S7-1200/150 ...
- 详解 File类
在讲解File类之前,本人先要讲解下 路径,因为我们对于文件的操作是离不开路径的: 目录 路径: File类 文件名称过滤器: 路径: 请观看本人博文 -- <详解 绝对路径与 相对路径> ...
- 11. this.setState更新问题
this.setState是异步的,所以在this.setState之后不能立刻得到最新的state数据关于如何获取最新的数据,有如下三种方法 1.回调函数 this.setState({ xxx:' ...
- [转]ThinkCMF框架任意内容包含漏洞分析复现
0x00 简介 ThinkCMF是一款基于PHP+MYSQL开发的中文内容管理框架,底层采用ThinkPHP3.2.3构建.ThinkCMF提出灵活的应用机制,框架自身提供基础的管理功能,而开发者可以 ...
- redis: Zset有序集合类型(七)
存值:zadd myset 1 one 取值:zrange myset 0 -1 127.0.0.1:6379> zadd myset 1 one #存值 分值为1 (integer) 1 12 ...
- 高质量动漫实时画质增强器Anime4K在mpv上的配置
Anime4K地址 https://github.com/bloc97/Anime4K mpv地址 https://mpv.io/ 这个要错峰下载,网速不太好 在C盘用户\..\AppData\ ...
- thinkphp5和nginx不得不说的故事
由于之前学习用的都是apsche,所以对ngnix一窍不通,在这里写给正在学习的同行,希望可以帮助到你们: 如果你不会用apache部署tp5的可以查看我之前发布的文章,里面有提到 phpstudy ...
- php---算法和数据结构
<?php header("content-type:text/html;charset=utf-8"); $arr = array(3,5,8,4,9,6,1,7,2); ...