设计模式读后感，之一：创建型

最近看一本设计模式，自己抽空实现了一下，分享一下，最忌比较忙，就不细说了，先把代码放在这里，之后补上注释。

书上把设计模式分为创建型，结构型和行为型，本次先来创建型。

（一），抽象工厂模式AbsractFactory

头文件

#ifndef _ABS_FACTORY_H_
#define _ABS_FACTORY_H_

#include <string>

using namespace std;

//////////////////////////////////////////////////////////////////////////
// base
class Phone
{
public:
    string m_strName;

virtual ~Phone();
};

class Computer
{
public:
    string m_strName;
};

class AbstractFactory
{
public:
    virtual  Phone* CreatePhone() = 0;
    virtual  Computer* CreateComputer() = 0;
};

//////////////////////////////////////////////////////////////////////////
// apple
class iPhone:public Phone
{
public:
    string m_strAssistName;

~iPhone();
};

class Mac:public Computer
{
     // 偷个懒
};

class AppleFactory: public AbstractFactory
{
public:
    virtual  Phone* CreatePhone();
    virtual  Computer* CreateComputer();
};

//////////////////////////////////////////////////////////////////////////
//google
class Nexus:public Phone
{
public:
    string m_strSysName;
};
class ChromeBook: public Computer
{
    // 偷个懒
};

class GoogleFactory : public AbstractFactory
{
public:
    virtual  Phone* CreatePhone();
    virtual  Computer* CreateComputer();
};

void AbstractFactoryStartFunction();

#endif

1 实现

2 
 3 #include "AbsractFactory.h"
 4 #include <iostream>
 5 
 6 using namespace std;
 7 
 8 #define RELEASE_OBJECT(pObj) {delete pObj; pObj = NULL;}
 9 
10 //google
11 Computer* GoogleFactory::CreateComputer()
12 {
13     ChromeBook* poChromeBook = new ChromeBook();
14     poChromeBook->m_strName = "ChromeBook";
15     return poChromeBook;
16 }
17 
18 Phone* GoogleFactory::CreatePhone()
19 {
20     Nexus* poNexus = new Nexus();
21     poNexus->m_strSysName = "android";
22     poNexus->m_strName = "Nexus";
23     return poNexus;
24 }
25 
26 //apple
27 Computer* AppleFactory::CreateComputer()
28 {
29     Mac* poMac = new Mac();
30     poMac->m_strName = "MacBook";
31     return poMac;
32 }
33 
34 Phone* AppleFactory::CreatePhone()
35 {
36     iPhone* poIPhone = new iPhone();
37     poIPhone->m_strAssistName = "siri";
38     poIPhone->m_strName = "Nexus";
39     return poIPhone;
40 }
41 
42 // 记得用虚析构函数哦
43 Phone::~Phone()
44 {
45     cout << "记得用虚析构函数哦" << endl;
46 }
47 
48 iPhone::~iPhone()
49 {
50     cout << "Q: 会是否子类吗？ A: yes" << endl;
51 }
52 
53 //使用相同的流程，使用不同的工厂，生产不同的实例，（没检测空指针，不要像我学习 O(∩_∩)O~）
54 void GetProduct(AbstractFactory* poFactory, Phone*& poPhone, Computer*& poComputer)
55 {
56     poPhone = poFactory->CreatePhone();
57     poComputer = poFactory->CreateComputer();
58 }
59 
60 void AbstractFactoryStartFunction()
61 {
62     AbstractFactory *poFactory = NULL;
63     Phone *poPhone = NULL;
64     Computer *poComputer = NULL;
65 
66     // for apple
67     poFactory = new AppleFactory();// 生成特点类型的工厂用于生成实例
68     GetProduct(poFactory, poPhone, poComputer);//生产实例
69 
70     cout << " PhoneName :" << poPhone->m_strName << endl;
71     cout << " PhoneAssistName :" << ((iPhone*)poPhone)->m_strAssistName << endl; //不同的产品有自己的特性
72     cout << " ComputerName :" << poComputer->m_strName << endl;
73 
74     RELEASE_OBJECT(poFactory);
75     RELEASE_OBJECT(poPhone);
76     RELEASE_OBJECT(poComputer);
77     
78     // for google
79     poFactory  = new GoogleFactory(); // 改变的只有这里
80     GetProduct(poFactory, poPhone, poComputer);
81 
82     cout << " PhoneName :" << poPhone->m_strName << endl;
83     cout << " PhoneSysName :" << ((Nexus*)poPhone)->m_strSysName << endl; //不同的产品有自己的特性
84     cout << " ComputerName :" << poComputer->m_strName << endl;
85     
86     RELEASE_OBJECT(poFactory);
87     RELEASE_OBJECT(poPhone);
88     RELEASE_OBJECT(poComputer);
89 }

（二）制造器，builder

头文件

#ifndef _BUILDER_H_
#define _BUILDER_H_

#include <string>
#include <map>
#include <sstream>

using namespace std;

// 这个类不能，也不需要实例化
class SerializationBuilder
{
public:
    virtual void  Start() = 0;
    virtual void AddCfg(string strKey, string strValue) = 0;
    virtual void End() = 0;

virtual string GetResult();

protected:
    stringstream m_strResult;
};

// *.text
class TextSerializationBuilder: public SerializationBuilder
{
public:
    virtual void  Start();
    virtual void AddCfg(string strKey, string strValue);
    virtual void End();
};

// *.ini
class IniSerializationBuilder: public SerializationBuilder
{
public:
    virtual void  Start();
    virtual void AddCfg(string strKey, string strValue);
    virtual void End();
};

// *.xml
class XmlSerializationBuilder: public SerializationBuilder
{
public:
    virtual void  Start();
    virtual void AddCfg(string strKey, string strValue);
    virtual void End();
};

// *.*
// 其实你还可以创建更多的builder而不需要修改老代码，比如json...

class Config
{
public:
    Config();
    void Serialization(SerializationBuilder& oBuilder);

private:
    map<string, string> m_mapCfg;
};

void BuilderStartFunction();

#endif

实现

#include "Builder.h"
#include <iostream>

using namespace std;

string SerializationBuilder::GetResult()
{
    return m_strResult.str();
}

//TextSerializationBuilder
void TextSerializationBuilder::Start()
{
    m_strResult << "=============[ApplictionConfig BEG]============ " <<endl;
}

void TextSerializationBuilder::AddCfg( string strKey, string strValue )
{
    m_strResult <<"[" << strKey << "]: " << strValue << endl;
}

void TextSerializationBuilder::End()
{
     m_strResult << "=============[ApplictionConfig END]============ " <<endl;
}

//IniSerializationBuilder
void IniSerializationBuilder::Start()
{
    m_strResult << "[ApplictionConfig] " <<endl;
}

void IniSerializationBuilder::AddCfg( string strKey, string strValue )
{
    m_strResult << ";" << strKey << "\n"    // 爱写注释的是好孩子(*^__^*) 嘻嘻……
                       << strKey << "=" << strValue << endl;
}

void IniSerializationBuilder::End()
{
    m_strResult << endl;
}

//XmlSerializationBuilder

void XmlSerializationBuilder::Start()
{
    m_strResult << "<ApplictionConfig> " <<endl;
}

void XmlSerializationBuilder::AddCfg( string strKey, string strValue )
{
    m_strResult << "    <"    << strKey   << ">\n"   
                       << "        " << strValue << "\n" 
                       << "    </"  << strKey    << ">" << endl;
}

void XmlSerializationBuilder::End()
{
    m_strResult << "</ApplictionConfig> " <<endl;
}

//Config
Config::Config()
{
    m_mapCfg.clear();

m_mapCfg["AppName"]  = "builder test";
    m_mapCfg["IpAddress"]  = "127.0.0.1";
    m_mapCfg["TcpPort"]     = "8888";
    m_mapCfg["晚上吃啥"]    = "想吃火锅啊！";
    m_mapCfg["无聊备注"]    = "为啥总有人说我写代码不正经呢？";
}

void Config::Serialization( SerializationBuilder& oBuilder )
{
    oBuilder.Start();

map<string, string>::iterator iter = m_mapCfg.begin();
    for (; iter != m_mapCfg.end(); iter++)
    {
        oBuilder.AddCfg(iter->first, iter->second);
    }

oBuilder.End();
}

//BuilderStartFunction
void BuilderStartFunction()
{
    Config oConfig;

SerializationBuilder* poBuidler = NULL;

poBuidler = new TextSerializationBuilder(); // <--只有这里有差异
    oConfig.Serialization(*poBuidler); // 相同的操作不同结果
    cout << poBuidler->GetResult() << endl;
    delete poBuidler; poBuidler = NULL;

poBuidler = new IniSerializationBuilder();// <--只有这里有差异
    oConfig.Serialization(*poBuidler);// 相同的操作不同结果
    cout << poBuidler->GetResult() << endl;
    delete poBuidler; poBuidler = NULL;

poBuidler = new XmlSerializationBuilder();// <--只有这里有差异
    oConfig.Serialization(*poBuidler);// 相同的操作不同结果
    cout << poBuidler->GetResult() << endl;
    delete poBuidler; poBuidler = NULL;

cout << " 每次有新的需求不用改老代码，加个builder就好了，是不是很爽，要不要谁来加一个json的？" << endl;

}

（三）工厂 factory

头文件

#ifndef _FACTORY_H_
#define _FACTORY_H_

typedef enum
{
    VEHICLE_CAR,
    VEHICLE_TRUCK,
    VEHICLE_BUS
}VEHICLE_TYPE_ENUM;

// 这里其实可以只定义一个基类，在定义若干子类型
typedef struct 
{
    unsigned int    ulSitCount;
    unsigned int    ulWheelCount;
}Vehicle;

class VehicleFactory
{
public:
    /************************************************************************/
    /*   根据输入参数生产实例，也可以是静态的               */
    /************************************************************************/
    Vehicle* CreatVehicle(VEHICLE_TYPE_ENUM emType);
};

void FactoryStartFunction();

#endif

实现

#include "Factory.h"

#include <iostream>

using namespace std;

Vehicle* VehicleFactory::CreatVehicle(VEHICLE_TYPE_ENUM emType)
{
    // 也可以返回子类，在真实环境中更为常见
    Vehicle* poVehicle = new Vehicle();

if (NULL == poVehicle)
    {
        return NULL;
    }

// 根据不同参数配置不同的实例
    switch(emType)
    {
        case VEHICLE_CAR:
            poVehicle->ulSitCount = 4;
            poVehicle->ulWheelCount = 4;
            break;

case VEHICLE_TRUCK:
            poVehicle->ulSitCount = 2;
            poVehicle->ulWheelCount = 6;
            break;

case VEHICLE_BUS:
            poVehicle->ulSitCount = 20;
            poVehicle->ulWheelCount = 6;
            break;

default:
            delete poVehicle;
            poVehicle = NULL;
    }

return poVehicle;
}

void FactoryStartFunction()
{
    VehicleFactory oFactory;  // 如果CreatVehicle是静态的不需要这个，后面使用VehicleFactory::CreatVehicle

Vehicle* poTruck = oFactory.CreatVehicle(VEHICLE_TRUCK);
    if (NULL == poTruck)
    {
        return;
    }

cout << "Truck has " <<  poTruck->ulSitCount << " Seats and " 
            <<  poTruck->ulWheelCount << " Wheels " << endl;

delete poTruck;
}

（四） 原型 prototype

头文件

#ifndef _PROTOTYPE_H_
#define _PROTOTYPE_H_

#include <string>
#include <map>
#include <iostream>

using namespace std;

class Prototype
{
public:
    unsigned int m_ulPrice;
    string m_strName;

Prototype(){};//又偷懒，不要学我
    Prototype(Prototype& other);

virtual Prototype* Clone() = 0;
    virtual void Show() = 0;
};

class YouTiao: public Prototype
{
public:
    YouTiao();
    virtual Prototype* Clone();
    virtual void Show();
};

class DouJiang: public Prototype
{
public:
    DouJiang();
    virtual Prototype* Clone();
    virtual void Show();
};

class Bread: public Prototype
{
public:
    Bread();
    virtual Prototype* Clone();
    virtual void Show();
};

class Milk: public Prototype
{
public:
    Milk();
    virtual Prototype* Clone();
    virtual void Show();
};

class PrototypeManage
{
public:
    void Clear();
    void Init(int iFoodKey, Prototype* poFood, int iDrinkKey, Prototype *poDirnk);
    Prototype* GetCopy(int iKey);

void InitChineseBreakfirst();
    void InitEnglishBreakfirst();
private:
    map<int, Prototype*> m_mapProtypes;
};

void PrototypeStartFunction();

#endif

实现

#include "Prototype.h"

//Prototype
Prototype::Prototype( Prototype& other )
{
    m_ulPrice = other.m_ulPrice;
    m_strName = other.m_strName;
}

// YouTiao
YouTiao::YouTiao()
{
    m_strName = "油条";
    m_ulPrice = 1;
}

Prototype* YouTiao::Clone()
{
    return new YouTiao(*this);
}

void YouTiao::Show()
{
    cout << "我是" << m_strName <<"  价格:" << m_ulPrice <<  "元" <<endl;
}

// DouJiang

DouJiang::DouJiang()
{
    m_strName = "豆浆";
    m_ulPrice = 2;
}

Prototype* DouJiang::Clone()
{
    return new DouJiang(*this);
}

void DouJiang::Show()
{
    cout << "我是" << m_strName <<"  价格:" << m_ulPrice <<  "元" <<endl;
}

// Bread
Bread::Bread()
{
    m_strName = "Bread";
    m_ulPrice = 3;
}

Prototype* Bread::Clone()
{
    return new Bread(*this);
}

void Bread::Show()
{
    cout << "This is " << m_strName <<"  price: $" << m_ulPrice <<  endl;
}

//Milk

Milk::Milk()
{
    m_strName = "Milk";
    m_ulPrice = 5; //米国东西就是贵
}

Prototype* Milk::Clone()
{
    return new Milk(*this);
}

void Milk::Show()
{
     cout << "This is " << m_strName <<"  price: $" << m_ulPrice <<  endl;
}

//PrototypeManage
void PrototypeManage::Clear()
{
    map<int, Prototype*>::iterator iter = m_mapProtypes.begin();
    for (;iter != m_mapProtypes.end(); iter++)
    {
        delete iter->second;
    }
    m_mapProtypes.clear();
}

void PrototypeManage::Init( int iFoodKey, Prototype* poFood, int iDrinkKey, Prototype *poDirnk )
{
    Clear();
    m_mapProtypes[iFoodKey]   = poFood;
    m_mapProtypes[iDrinkKey]  = poDirnk;
}

Prototype* PrototypeManage::GetCopy( int iKey )
{
    if (m_mapProtypes.find(iKey) == m_mapProtypes.end())
    {
        return NULL;
    }

return m_mapProtypes[iKey]->Clone();
}

void PrototypeManage::InitChineseBreakfirst()
{
    Init(0 , new YouTiao(), 1 ,new DouJiang());
}

void PrototypeManage::InitEnglishBreakfirst()
{
    Init(0 , new Bread(), 1 ,new Milk());
}

void Sell(int aiSellList[], int iListLen,PrototypeManage& oPrototypeManage)
{
    for (int i = 0; i < iListLen; i++)
    {
        Prototype* poItem = oPrototypeManage.GetCopy(aiSellList[i]);
        poItem->Show();
        delete poItem;
    }
}

//PrototypeStartFunction
void PrototypeStartFunction()
{
    int aiSellList[] = {0, 1, 1, 0, 1, 0 }; // 我们需要很多的实例，但是不用每次都创建他们，配置他们，只要从原型中复制一下就好
    PrototypeManage oPrototypeManage;

oPrototypeManage.InitChineseBreakfirst();
    Sell(aiSellList, sizeof(aiSellList)/sizeof(int), oPrototypeManage);

oPrototypeManage.InitEnglishBreakfirst(); // 重新设置原型
    Sell(aiSellList, sizeof(aiSellList)/sizeof(int), oPrototypeManage);//同样的操作产生了很不相同的结果，这是原型的好处之一：动态更换原型
}

（五）单例

头文件

#ifndef _SINGLETON_H_
#define _SINGLETON_H_

#include <string>
#include <map>
#include <iostream>

using namespace std;

typedef enum
{
    CAR_FACTORY,
}FACTORTY_TYPE;

class Singleton
{
public:
    static Singleton* GetInstance(FACTORTY_TYPE emType);

protected:
    Singleton();

private:
    static Singleton* s_poInstance;
};

class CarFactory: public Singleton
{
public:
    void GetNewCar();
};

void SingletonStartFunction();

#endif

实现

#include "Singleton.h"

Singleton* Singleton::s_poInstance = NULL; //C++ 的静态变量复制比较奇怪

Singleton* Singleton::GetInstance(FACTORTY_TYPE emType)
{
    switch (emType)
    {
        case  CAR_FACTORY:
            if (NULL == s_poInstance)
            {
                s_poInstance = new CarFactory();
            }
            break;
        default:
            cout << "unknow type :" << emType << endl;
            break;
    }

return s_poInstance;
}

Singleton::Singleton()
{

}

void CarFactory::GetNewCar()
{
    cout << "build a new cat" << endl;
}

void SingletonStartFunction()
{
   CarFactory *poFactory =  (CarFactory*)Singleton::GetInstance(CAR_FACTORY);

poFactory->GetNewCar();
}

顺便把main函数附上大家可以自己操练下：

#include <iostream>

#include <string>

#include "Factory/Factory.h"
#include "AbsractFactory/AbsractFactory.h"
#include "Builder/Builder.h"
#include "Prototype/Prototype.h"
#include "Singleton/Singleton.h"
#include "Adapter/Adapter.h"
#include "Bridge/Bridge.h"

using namespace std;

typedef void (*PF_StartFunc)();

typedef enum 
{
    DP_FACTORY,
    DP_ABSTRACT_FACTORY,
    DP_BUILDER,
    DP_PROTOTYPE,
    DP_SINGLENTON,
    DP_ADAPTER,
    DP_BRIDGE
}DP_TYPE;

typedef struct
{
    DP_TYPE          emType;
    PF_StartFunc    pfStartFunction;
}DP_START_FUNC;

DP_START_FUNC g_astDesignPatterns[] = {
    {DP_FACTORY,                     FactoryStartFunction             },
    {DP_ABSTRACT_FACTORY,    AbstractFactoryStartFunction},
    {DP_BUILDER,                       BuilderStartFunction             },
    {DP_PROTOTYPE,                 PrototypeStartFunction         },
    {DP_SINGLENTON,               SingletonStartFunction         },
    {DP_ADAPTER,                     AdapterStartFunction            },
    {DP_BRIDGE,                        BridgeStartFuction}
};

PF_StartFunc GetStartFunc(DP_TYPE emType)
{
    size_t uPatternCount = sizeof(g_astDesignPatterns)/sizeof(DP_START_FUNC);

for (size_t u = 0; u < uPatternCount; u++)
    {
        if (g_astDesignPatterns[u].emType == emType)
        {
            return g_astDesignPatterns[u].pfStartFunction;
        }
    }

return NULL;
}

int main()
{
    DP_TYPE emType = DP_BRIDGE; //每次测试修改这里就可以了

PF_StartFunc pfStartFunc = GetStartFunc(emType);

if (NULL == pfStartFunc)
    {
        cout << "emType[" << emType <<"]" << "not have start function" << endl;
        return 1;
    }

(*pfStartFunc)();

system("pause");

return 0;
}

时间： 2024-10-16 07:58:43

设计模式读后感，之一：创建型的相关文章

设计模式(3)-对象创建型模式-Abstract Factory模式

1.对象创建型模式 1.3           Abstract Factory模式 1.3.1 需求 在下面情况能够使用Abstract Factory模式: ?  一个系统要独立于它的产品的创建.组合和表示时(这个需求和FactoryMethod类似). ?  一个系统要由多个产品系列中的一个来配置时(这个需求也和Factory Method类似). ?  当你要强调一系列相关的产品对象的设计以便进行联合使用时(这个需求表明一个工厂要创建多个相关的产品对象,是比FactoryMethod多的

天天设计模式二：创建型模式实践

天天设计模式二:创建型模式实践 创建型设计模式主要应用在对象创建,以不同的方式来满足系统的灵活性配置.动态注入.等应用场景. 一.单例模式 二.抽象工厂 三.建造者模式 四.工厂方法模式 五.原型模式

小菜学设计模式——设计模式总结之创建型

1.面向过程与面向对象 1)面向过程通过划分功能模块,通过函数间相互调用来实现,但需求变化时就需要更改函数,而你改动的函数有多少地方在调用她呢?关联多少数据,这是很不容易弄得清楚地地方.或许开发者本人弄得清楚,但是下一个维护人员未必能够吃透.所以,由于这种强耦合性直接导致程序的扩展性和可维护性降低,后期维护的成本自然增高了不少. 2)面向对象关注的是对象,对象的优点在于,可以定义自己负责的事务,做要求它自己做的事情.对象应该自己负责自己,而且应该清楚的定义责任. 3)一般面向对象开发只是关心这么

设计模式之：创建型设计模式（6种）

创建型设计模式有: 共6种 简单工厂模式(Simple Factory) 工厂方法模式(Factory Method) 抽象工厂模式(Abstract Factory) 建造者模式(Builder) 原型模式(Prototype) 单例模式(Singleton) 简单工厂模式 功能:主要用于创建对象.新添加类时,不会影响以前的系统代码.核心思想是用一个工厂来根据输入的条件产生不同的类,然后根据不同类的virtual函数得到不同的结果. 优点: 适用于不同情况创建不同的类时 缺点: 客户端必须要知

NET设计模式 第二部分 创建型模式(6)：创建型模式专题总结（Creational Pattern）

创建型模式专题总结(Creational Pattern) ——.NET设计模式系列之七 Terrylee,2006年1月 概述 创建型模式,就是用来创建对象的模式,抽象了实例化的过程.它帮助一个系统独立于如何创建.组合和表示它的那些对象.本文对五种常用创建型模式进行了比较,通过一个游戏开发场景的例子来说该如何使用创建型模式. 为什么需要创建型模式 所有的创建型模式都有两个永恒的主旋律:第一,它们都将系统使用哪些具体类的信息封装起来:第二,它们隐藏了这些类的实例是如何被创建和组织的.外界对于这些

Java设计模式之五大创建型模式（附实例和详解）

一.概况 总体来说设计模式分为三大类: (1)创建型模式,共五种:工厂方法模式.抽象工厂模式.单例模式.建造者模式.原型模式. (2)结构型模式,共七种:适配器模式.装饰器模式.代理模式.外观模式.桥接模式.组合模式.享元模式. (3)行为型模式,共十一种:策略模式.模板方法模式.观察者模式.迭代子模式.责任链模式.命令模式.备忘录模式.状态模式.访问者模式.中介者模式.解释器模式. 二.设计模式的六大原则 1.开闭原则(Open Close Principle) 开闭原则就是说对扩展开放,对修

设计模式一：创建型模式

知识储备: 1.接口:若干抽象方法的集合 作用:限制实现接口的类必须按照接口给定的调用方式实现这些方法:对高层模块隐藏了类的内部实现. 2.面向对象设计SOLID原则 开放封闭原则:一个软件实体如类.模块和函数应该对扩展开放,对修改关闭.即软件实体应尽量在不修改原有代码的情况下进行扩展. 里氏替换原则:所有引用父类的地方必须能透明的使用其子类的对象. 依赖倒置原则:高层模块不应该依赖底层模块,二者都应该依赖其抽象:抽象不应该依赖细节:细节应该依赖抽象.换言之,要针对接口编程,而不是针对实现编程.

设计模式学习笔记-创建型模式总结

一.总结 创建型模式抽象了实例化的过程:它们帮助一个系统独立于如何创建.组合和表示它的那些对象.一个类创建型模式使用继承改变被实例化的类,而一个对象 创建型模式将实例化委托给另一个对象. 在这些模式中有两个不断出现的主旋律.第一,它们都将关于该系统使用哪些具体的类的信息封装起来.第二,它们隐藏了这些类的实例是如何被创建和放在 一起的.整个系统关于这些对象所知道的是由抽象类所定义的接口.因此,创建型模式在什么被创建,谁创建它,它是怎样被创建的,以及何时创建这些方面给予 了我们很大的灵活性.它们允许

设计模式(4)-对象创建型模式-Prototype模式

1.对象创建型模式 1.4          Protoype模式 1.4.1需求 通过拷贝原形对象创建新的对象. 1.4.2结构 ?P r o t o t y p e(Gr a p h i c) - 声明一个克隆自身的接口. ?C o n c r e t e P r o t o t y p e(S t a ff.W h o l e N o t e.H a l fN o t e) - 实现一个克隆自身的操作. ?  C l i e n t(G r a p h i c To o l) - 让一个原

设计模式感悟之创建型模式

创建型模式总结:     地球(客户)需要一个大自然(产品),该大自然需要有很多动物(产品功能),很多植物(产品功能).大自然使用单例模式和抽象工厂模式的结合模式.动物和植物采用简单工厂方法模式创建.以创建动物为例:在简单工厂里遇到相同的"人",直接采用原型模式克隆,法则采用建造者模式创建. public Animal {     private String mType = null;     public Animal clone()     {           ...