设计模式学习——工厂模式(Factory Pattern)

1、有一个工厂,专门生产不同品牌的汽车。当有人需要从此工厂提货的时候,只需要告诉他,要什么品牌的,就可以了,并不关心这些车是怎么生产出来的。

2、以上方式,如果增加品牌的时候,也要修改工厂,有点麻烦。于是,把工厂也抽象了。

1的类图与实现:

首先,是通用的车

 1  ///
 2  /// @file    Car.h
 3  /// @author  marrs([email protected])
 4  /// @date    2017-08-12 20:10:31
 5  ///
 6
 7 #ifndef __CAR_H__
 8 #define __CAR_H__
 9
10 #include <iostream>
11
12 namespace marrs{
13
14 using std::cout;
15 using std::cerr;
16 using std::endl;
17
18 class Car
19 {
20     public:
21         Car() : b_IsRunning(0){}
22         virtual ~Car(){};
23     public:
24         virtual void Run() = 0;
25         virtual void Stop() = 0;
26     protected:
27         bool b_IsRunning;
28 };
29
30 }
31
32 #endif //__CAR_H__

然后是不同品牌的车,继承自Car

 1  ///
 2  /// @file    Benz.h
 3  /// @author  marrs([email protected])
 4  /// @date    2017-08-12 20:20:54
 5  ///
 6
 7 #ifndef __BENZ_H__
 8 #define __BENZ_H__
 9
10 #include "Car.h"
11
12 namespace marrs{
13
14 class Benz
15 : public Car
16 {
17     public:
18         ~Benz(){}
19     public:
20         void Run();
21         void Stop();
22 };
23
24 }
25
26 #endif //__BENZ_H__
 1  ///
 2  /// @file    Benz.cc
 3  /// @author  marrs([email protected])
 4  /// @date    2017-08-12 20:21:54
 5  ///
 6
 7 #include "Benz.h"
 8
 9 namespace marrs{
10
11 void Benz::Run()
12 {
13     if (b_IsRunning)
14     {
15         cerr << "Benz is running!" << endl;
16     }
17
18     cout << "Benz is going to running!" << endl;
19     b_IsRunning = true;
20 }
21
22 void Benz::Stop()
23 {
24     if (!b_IsRunning)
25     {
26         cerr << "Benz isn‘t running..." << endl;
27     }
28
29     cout << "Benz is going to stopping!" << endl;
30     b_IsRunning = false;
31 }
32
33 }
 1  ///
 2  /// @file    Audi.h
 3  /// @author  marrs([email protected])
 4  /// @date    2017-08-12 20:20:54
 5  ///
 6
 7 #ifndef __AUDI_H__
 8 #define __AUDI_H__
 9
10 #include "Car.h"
11
12 namespace marrs{
13
14 class Audi
15 : public Car
16 {
17     public:
18         ~Audi(){}
19     public:
20         void Run();
21         void Stop();
22 };
23
24 }
25
26 #endif//__AUDI_H__
 1  ///
 2  /// @file    Audi.cc
 3  /// @author  marrs([email protected])
 4  /// @date    2017-08-12 20:21:54
 5  ///
 6
 7 #include "Audi.h"
 8
 9 namespace marrs{
10
11 void Audi::Run()
12 {
13     if (b_IsRunning)
14     {
15         cerr << "Audi is running!" << endl;
16     }
17
18     cout << "Audi is going to running!" << endl;
19     b_IsRunning = true;
20 }
21
22 void Audi::Stop()
23 {
24     if (!b_IsRunning)
25     {
26         cerr << "Audi isn‘t running..." << endl;
27     }
28
29     cout << "Audi is going to stopping!" << endl;
30     b_IsRunning = false;
31 }
32
33 }
 1  ///
 2  /// @file    Lamborghini.h
 3  /// @author  marrs([email protected])
 4  /// @date    2017-08-12 20:20:54
 5  ///
 6
 7 #ifndef __LAMBORGHINI_H__
 8 #define __LAMBORGHINI_H__
 9
10 #include "Car.h"
11
12 namespace marrs{
13
14 class Lamborghini
15 : public Car
16 {
17     public:
18         ~Lamborghini(){}
19     public:
20         void Run();
21         void Stop();
22 };
23
24 }
25
26 #endif//__LAMBORGHINI_H__
 1  ///
 2  /// @file    Lamborghini.cc
 3  /// @author  marrs([email protected])
 4  /// @date    2017-08-12 20:21:54
 5  ///
 6
 7 #include "Lamborghini.h"
 8
 9 namespace marrs{
10
11 void Lamborghini::Run()
12 {
13     if (b_IsRunning)
14     {
15         cerr << "Lamborghini is running!" << endl;
16     }
17
18     cout << "Lamborghini is going to running!" << endl;
19     b_IsRunning = true;
20 }
21
22 void Lamborghini::Stop()
23 {
24     if (!b_IsRunning)
25     {
26         cerr << "Lamborghini isn‘t running..." << endl;
27     }
28
29     cout << "Lamborghini is going to stopping!" << endl;
30     b_IsRunning = false;
31 }
32
33 }

接着,有个生产工厂

 1  ///
 2  /// @file    Factory.h
 3  /// @author  marrs([email protected])
 4  /// @date    2017-08-12 20:27:42
 5  ///
 6
 7 #ifndef __FACTORY_H__
 8 #define __FACTORY_H__
 9
10
11 #include "Benz.h"
12 #include "Audi.h"
13 #include "Lamborghini.h"
14
15
16 enum Brand
17 {
18     EN_BRAND_CAR_BANZ = 0,
19     EN_BRAND_CAR_AUDI,
20     EN_BRAND_CAR_LAMBORGHINI,
21 };
22
23
24 namespace marrs{
25
26 using std::cout;
27 using std::endl;
28
29 class Factory
30 {
31 public:
32     Car * Produce(int int_brand);
33     void Reclaim(Car * car_brand);
34 };
35
36 }
37
38
39 #endif //__FACTORY_H__
 1  ///
 2  /// @file    Factory.cc
 3  /// @author  marrs([email protected])
 4  /// @date    2017-08-12 20:39:05
 5  ///
 6
 7 #include "Factory.h"
 8
 9 namespace marrs{
10
11 Car * Factory::Produce(int int_brand)
12 {
13     switch(int_brand)
14     {
15         case EN_BRAND_CAR_BANZ:
16             return new Benz;
17         case EN_BRAND_CAR_AUDI:
18             return new Audi;
19         case EN_BRAND_CAR_LAMBORGHINI:
20             return new Lamborghini;
21         default:break;
22     }
23     return NULL;
24 }
25
26 void Factory::Reclaim(Car * car_brand)
27 {
28     delete car_brand;
29 }
30
31 }

为了方便统一处理方式,我把车的销毁也放到工厂类里了。

 1  ///
 2  /// @file    main.cc
 3  /// @author  marrs([email protected])
 4  /// @date    2017-08-12 20:40:59
 5  ///
 6
 7 #include "Factory.h"
 8
 9 using namespace marrs;
10
11 int main()
12 {
13     Factory factory;
14
15     Car * car_first = factory.Produce(EN_BRAND_CAR_BANZ);
16     car_first->Run();
17     car_first->Stop();
18     factory.Reclaim(car_first);
19
20     Car * car_second = factory.Produce(EN_BRAND_CAR_AUDI);
21     car_second->Run();
22     car_second->Stop();
23     factory.Reclaim(car_second);
24
25     Car * car_third = factory.Produce(EN_BRAND_CAR_LAMBORGHINI);
26     car_third->Run();
27     car_third->Stop();
28     factory.Reclaim(car_third);
29
30 }

编译,运行

[[email protected] ~/object-oriented/Factory-Pattern]$>g++ * -o car_factory.exe
[[email protected] ~/object-oriented/Factory-Pattern]$>./car_factory.exe
Benz is going to running!
Benz is going to stopping!
Audi is going to running!
Audi is going to stopping!
Lamborghini is going to running!
Lamborghini is going to stopping!

2的类图与实现 (画图功底不行....略乱)

在1的基础之上,修改Factory

 1  ///
 2  /// @file    Factory.h
 3  /// @author  marrs([email protected])
 4  /// @date    2017-08-12 20:27:42
 5  ///
 6
 7 #ifndef __FACTORY_H__
 8 #define __FACTORY_H__
 9
10
11 #include "Car.h"
12
13 namespace marrs{
14
15 using std::cout;
16 using std::endl;
17
18 class Factory
19 {
20     public:
21         virtual ~Factory(){}
22     public:
23         virtual Car * Produce() = 0;
24         void Reclaim(Car * car_brand)
25         {
26             delete car_brand;
27         }
28 };
29
30 }
31
32
33 #endif //__FACTORY_H__

然后是不同的工厂

 1  ///
 2  /// @file    Benz_Factory.h
 3  /// @author  marrs([email protected])
 4  /// @date    2017-08-12 21:21:58
 5  ///
 6
 7 #ifndef __BENZ_FACTORY_H__
 8 #define __BENZ_FACTORY_H__
 9
10 #include "Factory.h"
11 #include "Benz.h"
12
13 namespace marrs{
14
15 class BenzFactory
16 : public Factory
17 {
18     public:
19         Car * Produce()
20         {
21             return new Benz;
22         }
23 };
24
25 }
26
27 #endif // __BENZ_FACTORY_H__
 1  ///
 2  /// @file    Audi_Factory.h
 3  /// @author  marrs([email protected])
 4  /// @date    2017-08-12 21:21:58
 5  ///
 6
 7 #ifndef __AUDI_FACTORY_H__
 8 #define __AUDI_FACTORY_H__
 9
10 #include "Factory.h"
11 #include "Audi.h"
12
13 namespace marrs{
14
15 class AudiFactory
16 : public Factory
17 {
18     public:
19         Car * Produce()
20         {
21             return new Audi;
22         }
23 };
24
25 }
26
27 #endif // __AUDI_FACTORY_H__
 1  ///
 2  /// @file    Lamborghini_Factory.h
 3  /// @author  marrs([email protected])
 4  /// @date    2017-08-12 21:21:58
 5  ///
 6
 7 #ifndef __LAMBORGHINI_FACTORY_H__
 8 #define __LAMBORGHINI_FACTORY_H__
 9
10 #include "Factory.h"
11 #include "Lamborghini.h"
12
13 namespace marrs{
14
15 class LamborghiniFactory
16 : public Factory
17 {
18     public:
19         Car * Produce()
20         {
21             return new Lamborghini;
22         }
23 };
24
25 }
26
27 #endif // __LAMBORGHINI_FACTORY_H__

最后修改main.cc

 1  ///
 2  /// @file    main.cc
 3  /// @author  marrs([email protected])
 4  /// @date    2017-08-12 20:40:59
 5  ///
 6
 7 #include "Benz_Factory.h"
 8 #include "Audi_Factory.h"
 9 #include "Lamborghini_Factory.h"
10
11 using namespace marrs;
12
13 void BenzAction()
14 {
15     Factory * factory = new BenzFactory;
16     Car * car_first = factory->Produce();
17     car_first->Run();
18     car_first->Stop();
19     factory->Reclaim(car_first);
20     delete factory;
21 }
22
23 void AudiAction()
24 {
25     Factory * factory = new AudiFactory;
26     Car * car_first = factory->Produce();
27     car_first->Run();
28     car_first->Stop();
29     factory->Reclaim(car_first);
30     delete factory;
31 }
32
33 void LamborghiniAction()
34 {
35     Factory * factory = new LamborghiniFactory;
36     Car * car_first = factory->Produce();
37     car_first->Run();
38     car_first->Stop();
39     factory->Reclaim(car_first);
40     delete factory;
41 }
42
43
44 int main()
45 {
46     BenzAction();
47     AudiAction();
48     LamborghiniAction();
49
50     return 0;
51 }

编译,运行

[[email protected] ~/object-oriented/Factory-Pattern_2]$>g++ * -o car_Factory.exe
[[email protected] ~/object-oriented/Factory-Pattern_2]$>./car_Factory.exe
Benz is going to running!
Benz is going to stopping!
Audi is going to running!
Audi is going to stopping!
Lamborghini is going to running!
Lamborghini is going to stopping!
时间: 2024-11-03 03:36:35

设计模式学习——工厂模式(Factory Pattern)的相关文章

【设计模式】工厂模式 Factory Pattern

1)简单工厂(不是模式) 简单工厂只是一种变成习惯,并非23种设计模式之一. 简单工厂提供将实例话那种类型留给运行时判断,而非编译时指定.简单工厂模式就是由一个工厂类根据传入的参数决定创建出哪一个类的实例. 角色: 工厂类:接收参数,返回参数指定的类的实例. 抽象产品:返回实例的类型,具体产品的基类. 具体产品:继承自抽象产品的类. 2)工厂方法模式 沿着上面的思路,创建的接口是稳定的,但是创建对象剧烈变化.将稳定的接口抽象成基类,让子类确定实例哪个产品,将实际创建工作推迟到子类中. 工厂方法用

设计模式一 工厂模式Factory

设计模式一 工厂模式Factory 在面向对象编程中, 最通常的方法是一个new操作符产生一个对象实例,new操作符就是用来构造对象实例的.但是在一些情况下, new操作符直接生成对象会带来一些问题.举例来说, 许多类型对象的创造需要一系列的步骤: 你可能需要计算或取得对象的初始设置; 选择生成哪个子对象实例; 或在生成你需要的对象之前必须先生成一些辅助功能的对象. 在这些情况,新对象的建立就是一个 "过程",不仅是一个操作,像一部大机器中的一个齿轮传动. 模式的问题:你如何能轻松方便

Android设计模式之一个例子让你彻底明白工厂模式(Factory Pattern)

提出疑问 这几天研究工厂模式的时候,看到网上的一些文章中举的例子我就很疑惑,我相信这也是许多人的疑惑:工厂模式的功能就是创建实例,我们创建实例直接new不就完了吗,干嘛还得再封装一层工厂类,然后用工厂类再去new出这个实例?这不多此一举吗? 比如我看到这样的例子,我们的用户分为金牌用户和银牌用户,我们要创建一个金牌用户或者银牌用户. 定义一个用户接口 public interface ICustomer { String describe(); } 金牌用户实现类 public class Go

23种设计模式--工厂模式-Factory Pattern

一.工厂模式的介绍       工厂模式让我们相到的就是工厂,那么生活中的工厂是生产产品的,在代码中的工厂是生产实例的,在直白一点就是生产实例的类,代码中我们常用new关键字,那么这个new出来的实例就就依赖与这个类,2者之间的耦合度就高,此时我们就可以使用面向对象的去解决这个问题,将变化点封装起来,这就是我们将要首先引入的简单工厂模式:先来说一个场景,比如我们吃水果这个例子吧,我们有时候想吃苹果,有时候想吃橘子,但是每次都需要去买这些水果,后来有个水果店,又卖橘子,又卖苹果,这个水果店就当于简

创建型模式篇(工厂模式Factory Pattern)

一.工厂模式(Factory Pattern) 1.定义: 在软件系统,经常面临着"某个对象"的创建工作,由于需求的变化,这个对象的具体实现经常面临着剧烈的变化,但是它却拥有比较稳定的接口.提供一种封装机制来隔离这个对象的变化,从而保持系统中其他依赖这个变化对象的对象,就要用到工厂模式. 2.目的:定义一个用户创建对象的接口,让子类决定实例化哪一个类,FactoryMethod使一个类的实例化延迟到它的子类. 3.结构图: 工厂模式:定义一个用于创建对象的接口,但是让子类决定实例化哪个

抽象工厂模式(abstarct factory pattern)和工厂模式(factory pattern)的比较

抽象工厂模式和工厂模式从字面上来看就有必然的联系,他们都是创建型模式.总结来说,工厂模式(factory pattern)只是个小工厂,只提供一层接口的实现类的输出,而抽象工厂模式(abstract factory pattern)是工厂模式的进一步升级,可以上升到两层以上的工厂模式继承,是工厂的工厂.一计算机来说,工厂模式可以是不同型号显示器,CPU或者网卡的提供者,而抽象工厂模式是显示器工厂.CPU工厂和网卡工厂的工厂.可以通过抽象工厂来获得CPU工厂,进而获得某个型号的CPU.整个依赖关系

工厂模式(factory pattern)

工厂模式主要用来封装对象的创建,有3种分类:简单工厂(simple factory).工厂方法(factory method).抽象工厂(abstract factory). 简单工厂包括3种组成元素:抽象产品.具体产品.具体工厂(简单工厂),结构图如下: C++实现: //抽象产品 class Car { public: virtual string getDescription() = 0; }; //具体产品 class Audi : public Car { string getDesc

设计模式~简单工厂模式(Factory)

简单工厂模式Simple Factory根据提供给它的数据,返回一个类的实例.通常它返回的类都有一个公共的父类(或者接口对象). 简单工厂的作用是实例化对象,而不需要客户了解这个对象属于哪个具体的子类.简单工厂实例化的类具有相同的接口或者基类,在子类比较固定并不需要扩展时,可以使用简单工厂.如数据库生产工厂就是简单工厂的一个应用.         采用简单工厂的优点是可以使用户根据参数获得对应的类实例,避免了直接实例化类,降低了耦合性:缺点是可实例化的类型在编译期间已经被确定,如果增加新类 型,

设计模式之工厂模式 Factory实现

simpleFactory //car接口 public interface Car { void run(); } //两个实现类 public class Audi implements Car{ public void run() { System.out.println("奥迪在跑"); } } public class Byd implements Car{ public void run() { System.out.println("Byd在跑");

设计模式学习 - 工厂模式

工厂模式: 定义了一个创建对象的接口,但由它的子类决定实例化哪一个对象.工厂方法将对象的实例化延迟到了子类. 模式组成: 一组使用者:父类定义一个创建对象的接口及其他通用接口,子类负责创建对象接口的具体实现(在案例中为 PizzaStore 及 NYPizzaStore) 一组产品类:(在案例中为 抽象Pizza类及其具体实现的子类) 注: 每一个使用者的子类负责创建一个(组)相似对象. UML 类图: 代码具体实现: 1. 对象的创建者: PizzaStore 类 // pizza Store