大话设计模式:工厂模式

有了前面介绍的简单工厂模式,为什么又会出来一个工厂模式呢?它们之间的区别又在哪里?工厂模式的精髓又在哪里?

工厂方法模式: 定义一个用于创建对象的接口,主要解决了让子类决定实例化哪一个类,而不是像简单工厂一样,让工厂来直接决定实例化哪一个产品。工厂方法模式是对简单工厂模式的稍微改进。工厂方法模式的用意是定义一个创建产品对象的工厂接口,将实际工作推迟到子类中。

还以书上的计算器为例:

工厂模式主要包括以下几个模块:

(1)抽象工厂:一个接口,子类的具体工厂实现该接口(AbstructFectory);

(2)具体工厂:具体工厂负责生产具体的产品(AddFactory);

(3)抽象产品:具体产品继承该抽象产品;(Operation);

(4)具体产品:生产具体产品,实际的功能操作(OperationAdd);

优点:使程序模块化更高,低耦合。可维护性更强。

(1)与简单工厂模式相比,制造产品的工厂类不再只有一个,而是每种具体产品类都对应一个生产它的具体工厂类(OperationAdd--AddFactory)。而这些具体工厂类的共同特征再被提取出来形成一个抽象产品类(Operation),这些具体产品类都继承自这个抽象产品类。

(2)当需要增加一种产品的时候,需要做的是:

a.增加一种继承自抽象产品的具体产品类(开根号的运算类OperationSquart);

b.增加一种继承在抽象工厂的具体工厂类(SquartFactory),

c.更改客户端。而不需要在简单工厂模式中那样更改工厂类的switch。

因为当我们在要添加一个M的N次方的功能的时候,我们只需要添加一个相应的工厂类和一个相应的运算类就可以了,我们不需要再去修改原有的工厂类了。这样在添加功能的过程中,整个工厂和产品体系没有修改的变化,而只是有了扩展的变化,这样就不会影响原有的功能的运行,这样就符合了另一个非常重要的开放-封闭(对于扩展是开放的,对于修改使关闭的)原则精神。

缺点:

(1)只能生产同一种类型的产品,产品结构单一,所有的具体产品都继承产品抽象类;

(2)简单工厂模式里我们是通过修改工厂类你的switch-case来选择实例化那个对象,但是这里我们虽然不需要修改工厂类了,但是我们需要修改客户端,也就是说工厂方法将内部的逻辑判断移动到了客户端。本来是要修改工厂类的,但是现在改成了修改客户端。

其uml图如下:

具体实现代码:

#include <iostream>
using namespace std;  

//抽象产品类
class Operation
{
protected:
	double numberA;
	double numberB;  

public:
	double getA()
	{
		return numberA;
	}
	double getB()
	{
		return numberB;
	}
	void setA(double number)
	{
		numberA=number;
	}
	void setB(double number)
	{
		numberB=number;
	}  

	virtual double GetResult()
	{
		double result=0;
		return result;
	}
};
//下面是四个具体产品类,只能是同一类的产品;
class OperationAdd:public Operation
{
public:
	double GetResult()
	{
		double result=0;
		result=numberA+numberB;
		return result;
	}
};  

class OperationSub:public Operation
{
public:
	double GetResult()
	{
		double result=0;
		result=numberA-numberB;
		return result;
	}
};  

class OperationMul:public Operation
{
public:
	double GetResult()
	{
		double result=0;
		result=numberA*numberB;
		return result;
	}
};  

class OperationDiv:public Operation
{
public:
	double GetResult()
	{
		double result=0;
		if(numberB!=0)
			result=numberA/numberB;
		return result;
	}
};  

//抽象工厂类
class AbstractFactory
{
public:
	virtual Operation* createOperation()
	{
		return new Operation;
	}
};
//下面是四个具体工厂类,分别用于产生四个具体产品
class AddFactory:public AbstractFactory
{
public:
	Operation* createOperation()
	{
		Operation* oper=new OperationAdd;
		return oper;
	}
};  

class SubFactory:public AbstractFactory
{
public:
	Operation* createOperation()
	{
		Operation* oper=new OperationSub;
		return oper;
	}
};  

class MulFactory:public AbstractFactory
{
public:
	Operation* createOperation()
	{
		Operation* oper=new OperationMul;
		return oper;
	}
};  

class DivFactory:public AbstractFactory
{
public:
	Operation* createOperation()
	{
		Operation* oper=new OperationDiv;
		return oper;
	}
};  

//客户端
int main()
{  //客户端判断具体实例化那个子工厂,那个具体产品;
	AbstractFactory* af=NULL;
	af=new AddFactory();  

	Operation* oper=NULL;
	oper=af->createOperation();  

	oper->setA(3);
	oper->setB(2);
	cout<<oper->GetResult()<<endl;  

	if(af!=NULL)
	{
		delete af;
		af=NULL;
	}
	if(oper!=NULL)
	{
		delete oper;
		oper=NULL;
	}  

	system("pause");
	return 0;
}  

运行结果:

时间: 2024-09-30 07:39:52

大话设计模式:工厂模式的相关文章

6.大话设计模式-工厂模式

工厂模式和简单工厂有什么区别.废话不多说,对比第一篇例子应该很清楚能看出来. 优点: 工厂模式弥补了简单工厂模式中违背开放-封闭原则,又保持了封装对象创建过程的优点. using System;using System.Collections.Generic;using System.Linq;using System.Text;using System.Threading.Tasks; namespace DesignModel{    public interface Factory   

大话设计模式---工厂模式

简单工厂 VS 工厂方法 简单工厂模式的最大优点在于工厂类中包含了必要的逻辑判断,根据客户端的选择条件动态实例化相关的类,对于客户端来说,去除了与具体产品的依赖.但添加新功能时需要修改原有的类,违背开发-封闭原则. 工厂方法模式:定义一个用于创建对象的接口,让子类决定实例化哪一个类.工厂方法使一个类的实例化延迟到其子类. 工厂方法模式实现时,客户端需要决定实例化哪个工厂来实现运算类,选择判断的问题还是存在的,也就是说,工厂方法把简单工厂的内部逻辑判断移到了客户端代码来进行.你想要加功能,本来是改

2.大话设计模式-策略模式

1 using System; 2 using System.Collections.Generic; 3 using System.Linq; 4 using System.Text; 5 using System.Threading.Tasks; 6 7 namespace DesignModel 8 { 9 /// <summary> 10 /// 策略模式 11 /// </summary> 12 public class TacticsModel 13 { 14 //对于

5.大话设计模式-代理模式

using System; using System.Collections.Generic; using System.Linq; using System.Text; using System.Threading.Tasks; namespace DesignModel { public class Proxy:IAction { ZQZ zzz = null; public Proxy(ZQZ mm) { zzz = mm; } public void SendFlower() { zzz

设计模式---工厂模式---生产水果

设计模式---工厂模式 需要一个基本的抽象类:相当一个基本的工厂 需要若干个具体类:相当若干个产品 需要工具类:相当工厂中机器,用来选择不同的产品生产 需要主类:相当顾客所想的订单 主类 ----> 工厂类 ----> 产品类 ---> 产品具体类 老板根据顾客的订单,在工具堆中选择合适的,然后去工厂中生产适合的产品,返回给顾客 优势:能够在不修改原先的代码情况,增加所需的类与方法. 不足:会增多类文件的数量 接口:提供的内容,相当于协议,即外界使用此接口时,接口的内容是不允许外界对接口

设计模式——工厂模式学习

1.概念 工厂模式定义:实例化对象,用工厂方法代替new操作.达到解耦的目的(避免硬编码耦合).工厂方法模式是类的创建模式,又叫做虚拟构造子(Virtual Constructor)模式或者多态性工厂(Polymorphic Factory)模式. 工厂模式是我们最常用的模式了,著名的Jive论坛 ,就大量使用了工厂模式,工厂模式在Java程序系统可以说是随处可见.因为工厂模式就相当于创建实例对象的new,我们经常要根据类Class生成实例对象,如A a=new A() 工厂模式也是用来创建实例

二十三种设计模式——工厂模式

二十三种设计模式--工厂模式 简单工厂模式 简单工厂模式又称静态工厂方法(StaticFactory Method)模式,不属于23种模式之一. 简单工厂模式是工厂模式最简单使用的模式. 类图: 程序: #include <iostream> #include<string> using namespace std; class NationalFlag//父类 { public: NationalFlag(){} ~NationalFlag(){} virtual void di

设计模式-工厂模式[Factory]

先看下一个简单的实现: 1 package org.masque.designpatterns.factorymethod.one; 2 /** 3 * 4 * Description: Sample子类的标示 5 * BeanEm.java Create on 2014年7月11日 下午2:37:58 6 * @author [email protected] 7 * @version 1.0 8 * Copyright (c) 2014 Company,Inc. All Rights Res

5分钟读书笔记之 - 设计模式 - 工厂模式

一个类或者对象中,往往会包含别的对象.在创建这种对象的时候,你可能习惯于使用常规方式,即用 new 关键字和类构造函数. 这会导致相关的俩个类之间产生依赖. 工厂模式,就是消除这俩个类之间的依赖性的一种模式,它使用一种方法来决定究竟实例化那个具体的类. 简单工厂模式 假设你想开几个自行车商店,每个商店都有几种型号的自行车出售,可以用这样一个类来表示: var BicycleShop = function(){} BicycleShop.prototype = { sellBicycle:func

大话设计模式----工厂方法模式

一.工厂方法模式:定义一个用于创建对象的接口,让子类决定实例化哪一个类.工厂方法使一个类的实例化延迟到其子类. 二.代码示例 public class LeiFeng { public void seep() { System.out.println("扫地"); } public void wash() { System.out.println("洗衣"); } public void buyRice() { System.out.println("买大