按块读取大文件

1.对象创建型模式

1.2           FACTORY METHOD模式

1.2.1功能

工厂方法模式使用抽象工厂类定义一个用于创建对象（产品）的接口，让子类（即具体工厂类）决定实例化哪一个类（即哪一个产品）;

在工厂方法模式中，核心的工厂类不再负责所有的产品的创建，而是将具体创建的工作交给子类去做。这个核心类则摇身一变，成为了一个抽象工厂角色，仅负责给出具体工厂子类必须实现的接口，而不接触哪一个产品类应当被实例化这种细节。  

1.2.2结构

注：这里把Creator改成Factory可能更直观一点

?  Creator:

                — 声明工厂方法，该方法返回一个P r o d u c t类型的对象。C r e a t o r也可以定义一个工厂方法的缺省实现，它返回一个缺省的C o n c r e t e P r o d u c t对象。

                — 可以调用工厂方法以创建一个P r o d u c t对象。

?  C o n c r e t e C r e a t o r

                — 重定义工厂方法以返回一个C o n c r e t e P r o d u c t实例。

?P r o d u c t

                — 定义工厂方法所创建的对象的接口。

?C o n c r e t e P r o d u c t

                — 实现Pr o d u c t接口。

1.2.3优缺点

工厂方法模式的优点如下：  

（1）在工厂方法模式中，工厂方法用来创建客户所需要的产品，同时还向客户隐藏了哪种具体产品类将被实例化这一细节，用户只需要关心所需产品对应的工厂，无需关心创建细节，甚至无需知道具体产品类的类名。  

（2）基于工厂角色和产品角色的多态性设计是工厂方法模式的关键。它能够使工厂可以自主确定创建何种产品对象，而如何创建这个对象的细节则完全封装在具体工厂内部。工厂方法模式之所以又被称为多态工厂模式，正是因为所有的具体工厂类都具有同一抽象父类。  

（3）使用工厂方法模式的另一个优点是在系统中加入新产品时，无需修改抽象工厂和抽象产品提供的接口，无需修改客户端，也无需修改其他的具体工厂和具体产品，而只要添加一个具体工厂和具体产品就可以了，这样，系统的可扩展性也就变得非常好，完全符合“开闭原则”。  

工厂方法模式的缺点如下：  

（1）在添加新产品时，需要编写新的具体产品类，而且还要提供与之对应的具体工厂类，系统中类的个数将成对增加，在一定程度上增加了系统的复杂度，有更多的类需要编译和运行，会给系统带来一些额外的开销。  

（2）由于考虑到系统的可扩展性，需要引入抽象层，在客户端代码中均使用抽象层进行定义，增加了系统的抽象性和理解难度，且在实现时可能需要用到DOM、反射等技术，增加了系统的实现难度。  

1.2.4  例子-C++

//Product.h

#ifndef _PRODUCT_H_

#define _PRODUCT_H_

class Product

{

       public:

              virtual ~Product() = 0;

       protected:

              Product();

       private:

};

class ConcreteProduct :public Product

{

       public:

              ~ConcreteProduct();

              ConcreteProduct();

       protected:

       private:

};

#endif //~_PRODUCT_H_

//Product.cpp

#include"Product.h"

#include<iostream>

using namespace std;

Product::Product()

{

}

Product::~Product()

{

}

ConcreteProduct::ConcreteProduct()

{

       cout << "ConcreteProduct...." << endl;

}

ConcreteProduct::~ConcreteProduct()

{

}

//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();

protected:

private:

};

#endif //~_FACTORY_H_

//Factory.cpp

#include "Factory.h"

#include "Product.h"

#include <iostream>

using namespace std;

Factory::Factory()

{

}

Factory::~Factory()

{

}

ConcreteFactory::ConcreteFactory()

{

       cout << "ConcreteFactory....." << endl;

}

ConcreteFactory::~ConcreteFactory()

{

}

Product* ConcreteFactory::CreateProduct()

{

       return new ConcreteProduct();

}

//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();

       return 0;

}

1.2.5 例子-JAVA

public class TestMain {

       /**

        * @param args

        */

       public static void main(String[] args){

              // TODO Auto-generatedmethod stub

              BallPenballPen=new BlackBallPen();

              PenCorepenCore=ballPen.getPenCore();

              penCore.writeWord("工厂方法模式");

              return;

       }

}

按块读取大文件,布布扣,bubuko.com

按块读取大文件

原文：http://blog.csdn.net/u010367506/article/details/23916087