Factory模式--工厂模式

工厂模式顾名思义，这种模式可以像工厂一样为我们产生我们所需要的东西。

为什么要使用工厂模式？《设计模式精解》中给出了这样的答案

在面向对象系统设计中经常可以遇到以下的两类问题:
1)为了提高内聚(Cohesion)和松耦合(Coupling),我们经常会抽象出一些类的公共接口以形成抽象基类或者接口。这样我们可以通过声明一个指向基类的指针来指向实际的子类实现,达到了多态的目的。这里很容易出现的一个问题 n 多的子类继承自抽象基类,我们不得不在每次要用到子类的地方就编写诸如 new ×××;的代码。这里带来两个问题

1)客户程序员必须知道实际子类的名称(当系统复杂后,命名将是一个很不好处理的问题,为了处理可能的名字冲突,有的命名可能并不是具有很好的可读性和可记忆性,就姑且不论不同程序员千奇百怪的个人偏好了。

2)程序的扩展性和维护变得越来越困难。

2)还有一种情况就是在父类中并不知道具体要实例化哪一个具体的子类。这里的意思为:假设我们在类 A 中要使用到类 B,B 是一个抽象父类,在 A 中并不知道具体要实例化那一个 B 的子类,但是在类 A 的子类 D 中是可以知道的。在 A 中我们没有办法直接使用类似于 new ×××的语句,因为根本就不知道×××是什么。
以上两个问题也就引出了 Factory 模式的两个最重要的功能:
1)定义创建对象的接口,封装了对象的创建;
2)使得具体化类的工作延迟到了子类中。

下面给出工厂设计模式的C++/java的具体实现方法

一、C++的实现

Factory.h

#ifndef _FACTORY_H_ #define _FACTORY_H_ class Product; class Factory { public: virtual ~Factory() = 0; virtual Product* CreateProduct() = 0; protected: Factory(); private: }; class ConcreteFactory:public Factory { public: ~ConcreteFactory(); ConcreteFactory(); Product* CreateProduct(); }; #endif

 

Factory.cpp

#include "Factory.h" #include "Product.h" #include <iostream> using namespace std; Factory::Factory() { cout << "Factory Construct" << endl; } Factory::~Factory() { cout << "Factory DesConstruct" << endl; } ConcreteFactory::ConcreteFactory() { cout << "ConcteteFactory Construct" << endl; } ConcreteFactory::~ConcreteFactory() { cout << "ConcreteFactory DesConstruct" << endl; } Product* ConcreteFactory::CreateProduct() { return new ConcreteProduct(); }

 

Product.h

#ifndef _PRODUCT_H_ #define _PRODUCT_H_ class Product { public: virtual ~Product() = 0; protected: Product(); private: }; class ConcreteProduct:public Product { public: ~ConcreteProduct(); ConcreteProduct(); }; #endif

 

Product.cpp

#include "Product.h" #include <iostream> using namespace std; Product::Product() { cout << "Product Construct" << endl; } Product::~Product() { cout << "Product DesConstruct"<< endl; } ConcreteProduct::ConcreteProduct() { cout<<"ConcreteProduct Construct"<<endl; } ConcreteProduct::~ConcreteProduct() { cout<< "Construct ConcreteProduct" << endl; }

 

main.cpp

#include "Factory.h" #include "Product.h" #include <iostream> using namespace std; int main(int argc,char* argv[]) { Factory* fac = new ConcreteFactory(); Product* p = fac->CreateProduct(); getchar(); return 0; }

 

java的实现不用这么麻烦，定义一个接口，然后继承就可以实现了。代码可能的实现方式如下

//首先定义好一个接口，让相关类去实现 public interface Animal{ public void eat(); public void drink(); } public class Human implements Animal { public void eat(){ System.out.println("Human can eat"); } public void drink(){ System.out.println("Human can drink"); } } public class Monkey implements Animal { public void eat(){ System.out.println("Monkey can eat"); } public void drink(){ System.out.println("Monkey can drink"); } } //定义好相关的类后，就要开工厂实现了 public class AnimalFactory { //定一个产生动物的方法 public static Animal createAnimal (Class c){ //定义一个动物的类型 Animal animal = null; try { //产生一个动物 animal = (Animal)Class.forName(c.getName()).newInstance(); } catch (InstantiationException e) { System.out.println("必须指定动物类型"); } catch (IllegalAccessException e) { System.out.println("你定义的不是一个禽兽"); } catch (ClassNotFoundException e) { System.out.println("你确定有这种动物吗？"); } return animal; } } //然后就可以进行调用了，调用的方法如下 Animal human = AnimalFactory.createAnimal(Human.class); human.eat(); human.drink();

 

利用上面的思路我们就可以创造出许许多多的动物出来了。这就是工厂模式的常用套路，很好理解，也很实用。工厂方法模式还有一个非常重要的应用，就是延迟始化(Lazy initialization)，什么是延迟始化呢？一个对象初始化完毕后就不释放，等到再次用到得就不用再次初始化了，直接从内存过中拿到就可以了。你可以建立一个对象的map，创造对象的时候可以首先从map中判断对象是否存在不在，就create一个，如果存在的话就直接拿过来用，这样会对提高内存的利用率有所帮助。