什么时候用工厂模式-----转载

有一次讨论的时候，谈到了这一点：到底什么时候我们需要把类封装，并限制其必须使用工厂模式来创建实例。

一个理由是：当类的构造函数发生变化（名称变化，参数变化等）时，我们只需要更改工厂类中的一个函数就可以了。而不必search所有的构造函数名称并修改之。所以，一般情况下，我们最好都使用工厂模式封装。

果然是这样吗？

不用工厂模式，当名称变化时，确实需要search & replace。但是，难道一个模式被提练出来就是为了解决这个问题？！！似乎牛刀杀鸡了吧

那当　参数变化　时呢？

　函数的转入参数都变了，还想不改动所有的代码吗？！！

先来看看定义

－－－－－－－－－－－－－－－－－－－－－－－－－－－

Factory   Method是一种创建性模式,它定义了一个创建对象的接口,但是却让子类来决定具体实例化哪一个类.当一个类无法预料要创建哪种类的对象或是一个类需要由子类来指定创建的对象时我们就需要用到Factory 

－－－－－－－－－－－－－－－－－－－－－－－－－－－

显然上面的说法是不成立的。

如定义中说的，只有当无法预料所创建的实例时，才使用工厂模式。即：我们明确的计划不同条件下创建不同实例时，使用它。

经典的一个例子是：

日志记录器：记录可能记录到本地硬盘、系统事件、远程服务器等，用户可以选择记录日志到什么地方。

另一个例子：

数据库访问类：访问可能是SQLSERVER、ORACLE等，用记可以选择创建访问不同的数据库。

下面的代码来自 GEOS3.0.0 （http://geos.refractions.net），非常著名的一个类库，很多软件正在使用它。

看它的实例创建方式正是采用了工厂模式，用户无法直接创建point,line.polygon等实例，而必须通过GeometryFactory类

不过，我个人认为这是对工厂模式的一种滥用：当创建point,line,polygon等实例时，有上面提到的实例不确定性吗？！！

Point* createPointFromInternalCoord(const Coordinate* coord,
        const Geometry *exemplar) const;
/// Converts an Envelope to a Geometry.
//
/// Returned Geometry can be a Point, a Polygon or an EMPTY geom.
///
Geometry* toGeometry(const Envelope* envelope) const;
/// /brief
/// Returns the PrecisionModel that Geometries created by this
/// factory will be associated with.
const PrecisionModel* getPrecisionModel() const;
/// Creates an EMPTY Point
Point* createPoint() const;
/// Creates a Point using the given Coordinate
Point* createPoint(const Coordinate& coordinate) const;
/// Creates a Point taking ownership of the given CoordinateSequence
Point* createPoint(CoordinateSequence *coordinates) const;
/// Creates a Point with a deep-copy of the given CoordinateSequence.
Point* createPoint(const CoordinateSequence &coordinates) const;
/// Construct an EMPTY GeometryCollection
GeometryCollection* createGeometryCollection() const;
/// Construct the EMPTY Geometry
Geometry* createEmptyGeometry() const;
/// Construct a GeometryCollection taking ownership of given arguments
GeometryCollection* createGeometryCollection(
        std::vector<Geometry *> *newGeoms) const;
/// Constructs a GeometryCollection with a deep-copy of args
GeometryCollection* createGeometryCollection(
        const std::vector<Geometry *> &newGeoms) const;
/// Construct an EMPTY MultiLineString
MultiLineString* createMultiLineString() const;
/// Construct a MultiLineString taking ownership of given arguments
MultiLineString* createMultiLineString(
        std::vector<Geometry *> *newLines) const;
/// Construct a MultiLineString with a deep-copy of given arguments
MultiLineString* createMultiLineString(
        const std::vector<Geometry *> &fromLines) const;
/// Construct an EMPTY MultiPolygon
MultiPolygon* createMultiPolygon() const;
/// Construct a MultiPolygon taking ownership of given arguments
MultiPolygon* createMultiPolygon(std::vector<Geometry *> *newPolys) const;
/// Construct a MultiPolygon with a deep-copy of given arguments
MultiPolygon* createMultiPolygon(
        const std::vector<Geometry *> &fromPolys) const;
/// Construct an EMPTY LinearRing
LinearRing* createLinearRing() const;
/// Construct a LinearRing taking ownership of given arguments
LinearRing* createLinearRing(CoordinateSequence* newCoords) const;
std::auto_ptr<Geometry> createLinearRing(
        std::auto_ptr<CoordinateSequence> newCoords) const;
/// Construct a LinearRing with a deep-copy of given arguments
LinearRing* createLinearRing(
        const CoordinateSequence& coordinates) const;
/// Constructs an EMPTY <code>MultiPoint</code>.
MultiPoint* createMultiPoint() const;
/// Construct a MultiPoint taking ownership of given arguments
MultiPoint* createMultiPoint(std::vector<Geometry *> *newPoints) const;
/// Construct a MultiPoint with a deep-copy of given arguments
MultiPoint* createMultiPoint(
        const std::vector<Geometry *> &fromPoints) const;
/// /brief
/// Construct a MultiPoint containing a Point geometry
/// for each Coordinate in the given list.
MultiPoint* createMultiPoint(
        const CoordinateSequence &fromCoords) const;
/// Construct an EMPTY Polygon
Polygon* createPolygon() const;
/// Construct a Polygon taking ownership of given arguments
Polygon* createPolygon(LinearRing *shell,
        std::vector<Geometry *> *holes) const;
/// Construct a Polygon with a deep-copy of given arguments
Polygon* createPolygon(const LinearRing &shell,
        const std::vector<Geometry *> &holes) const;
/// Construct an EMPTY LineString
LineString* createLineString() const;
/// Copy a LineString
std::auto_ptr<LineString> createLineString(const LineString& ls) const;
/// Construct a LineString taking ownership of given argument
LineString* createLineString(CoordinateSequence* coordinates) const;
std::auto_ptr<Geometry> createLineString(
        std::auto_ptr<CoordinateSequence> coordinates) const;
/// Construct a LineString with a deep-copy of given argument
LineString* createLineString(
        const CoordinateSequence& coordinates) const;