网站开发和设计实训,做网站的技术盏,网站内页设计,社区网站源码系列文章
可跳转到下面链接查看下表所有内容https://blog.csdn.net/handsomethefirst/article/details/138226266?spm1001.2014.3001.5501文章浏览阅读2次。系列文章大全https://blog.csdn.net/handsomethefirst/article/details/138226266?spm1001.2014.3001.5501 目录
系…系列文章
可跳转到下面链接查看下表所有内容https://blog.csdn.net/handsomethefirst/article/details/138226266?spm1001.2014.3001.5501文章浏览阅读2次。系列文章大全https://blog.csdn.net/handsomethefirst/article/details/138226266?spm1001.2014.3001.5501 目录
系列文章
1.简介
2.简单工厂模式
2.1 简介
2.1.1 组成结构
2.1.2 优点和缺点
2.1.3 应用场景
2.2 代码案例
2.2.1 主要步骤
2.2.2 代码
3.工厂方法模式
3.1简介
3.1.1 组成结构
3.1.2 优点和缺点
3.1.3 应用场景
3.2 代码案例
3.2.1 主要步骤
3.2.2 代码
4.抽象工厂模式
4.1简介
4.1.1 组成结构
4.1.2 优点和缺点
4.2 代码案例
4.2.1 主要步骤
4.2.2 代码
5.区别 1.简介
工厂模式主要是为创建对象提供过渡接口以便将创建对象的具体过程屏蔽隔离起来即定义一个用于创建对象的接口让子类决定应该实例化哪个类使类的实例化延迟到子类。 也可以这样理解 工厂模式可以分为三类 1.简单工厂模式Simple Factory 2.工厂方法模式Factory Method 3.抽象工厂模式Abstract Factory
2.简单工厂模式
2.1 简介
简单工厂模式是通过一个工厂类将所有对象的创建封装起来通过传入不同的参数工厂负责创建不同的具体对象。
建立对象的类是工厂被建立的对象是产品使用产品的人无需关心这个产品是怎样生产的这样便降低了模块之间的耦合。
2.1.1 组成结构
1.工厂类用来创建所有产品通过传入的type不同从而创建不同的产品。例如本节案例代码中的Factory类。
2.抽象产品类它一般是具体产品继承的父类或者实现的接口。例如本节案例代码中的Car类。
3.具体产品类此类继承抽象产品类自工厂类所创建的对象就是此角色的实例。例如本节案例代码中的CarA类和CarB类。
特点一个工厂生产所有的具体产品。 2.1.2 优点和缺点
优点 1.将所有对象的创建集合到了一个工厂类中客户端只需要调用工厂类的接口传入不同的参数而无需关注具体对象的创建过程。
2.可以通过工厂类创建不同的对象而客户端无需改动实现了客户端和具体所有对象的解耦提高了代码的灵活性。缺点 1.每新增一个产品则需要修改工厂类的逻辑违反了开闭原则。 2.当产品足够多的时候代码会过于臃肿不利于维护。
2.1.3 应用场景
1.需要根据不同的参数类型创建不同的对象时。
2.2 代码案例
当前代码场景
我们现在一个工厂要生产车型A和车型B
2.2.1 主要步骤
第一步创建抽象产品类Car和创建抽象run函数 第二步创建具体产品类车型ACarA实现其抽象run函数。 第三步创建具体产品类车型BCarB实现其抽象run函数 第四步创建工厂类Factory并书写根据不同参数创建不同车型的createCar方法。 第五步客户端此例是main.cpp调用创建工厂类对象通过传递不同的参数工厂创建不同的对象并返回给客户。
2.2.2 代码
// 抽象产品类
class Car
{public:virtual void run() 0; // 抽象共同接口string cartype;
};// 具体产品类车A
class CarA : public Car
{public:CarA(){cartype A 车;}virtual void run(){std::cout this is cartype cartype endl;}
};// 具体产品类车B
class CarB : public Car
{public:CarB(){cartype B 车;}virtual void run(){std::cout this is cartype cartype endl;}
};// 工厂类
class Factory
{
public:Car *createCar(int type){switch (type){case CAR_TYPE_A:return new CarA();break;case CAR_TYPE_B:return new CarB();break;default:return nullptr;break;}}
};int main()
{Factory *mFactory new Factory(); // c创建工厂类Car *acar mFactory-createCar(CAR_TYPE_A); // 根据具体的参数创建对应的对象此处是父类指针指向子类对象Car *bcar mFactory-createCar(CAR_TYPE_B);acar-run();bcar-run();// 注意析构delete acar;delete bcar;delete mFactory;return 0;
}
3.工厂方法模式
3.1简介
工厂方法模式在简单工厂模式的基础上去掉了简单工厂模式中的创建所有对象的方法并提供了一个抽象生产产品的接口并使其它可以被子类继承。这样在简单工厂模式里集中在工厂方法上的压力可以由工厂方法模式里不同的工厂子类来分担。 简单工厂模式的特点是一个工厂只生产所有产品而工厂方法模式则是一个工厂只生产一个产品这样当生产产品的时候只需要确定是哪个工厂即可。
3.1.1 组成结构
1.抽象工厂类是具体工厂类的父类其包含一个具体工厂类必须实现的抽象接口。例如本节案例代码的Factory类抽象接口是createCar函数。2.具体工厂类对应其具体产品用以创建对应的具体产品的对象。例如本节案例代码的工厂A和工厂B工厂A负责生产车型A, 工厂B负责生产车型B。3.抽象产品类它是具体产品继承的父类。例如本节案例代码的Car类。4.具体产品类具体工厂类所创建的对象就是此类的实例。例如本节案例代码的车型A类和车型B类。 3.1.2 优点和缺点
优点 1.当需要增加新的工厂和产品的时候可以不用更改现有代码增加了代码的可扩展性将对象的创建和使用进行了解耦。缺点 1.当产品种类过多时由于每一种产品都需要实现一个工厂类增加代码复杂性。
3.1.3 应用场景
当只有一类产品时。同时客户端需要生成不同的对象。
3.2 代码案例
此时场景为 A工厂生产车型AB工厂生产车型B
3.2.1 主要步骤
第一步创建抽象产品类Car类。
第二步创建抽象产品类的两个子类CarA类和CarB类其子类是具体产品类。
第三步创建抽象工厂类Factory类并提供生产对象的抽象接口。
第四步创建两个具体工厂类一个是生产CarA的工厂类一个是生产CarB的工厂类并实现抽象方法创建不同的产品对象。
第五步客户端此例是main.cpp调用创建不同的工厂类对象从而创建出多个不同的产品对象。
3.2.2 代码
// 抽象产品类
class Car
{public:virtual void run() 0; // 抽象共同接口string cartype;
};// 具体产品类车A
class CarA : public Car
{public:CarA(){cartype A 车;}virtual void run(){std::cout this is cartype cartype endl;}
};// 具体产品类车B
class CarB : public Car
{public:CarB(){cartype B 车;}virtual void run(){std::cout this is cartype cartype endl;}
};// 抽象工厂类
class Factory
{
public:virtual Car *createCar() 0;
};// 具体工厂类工厂A对应产品A
class FactoryA : public Factory
{
public:virtual Car *createCar(){return new CarA();}
};
// 具体工厂类工厂B对应产品B
class FactoryB : public Factory
{
public:virtual Car *createCar(){return new CarB();}
};int main()
{Factory *mFactoryA new FactoryA(); // 创建具体工厂类ACar *acar mFactoryA-createCar(); // 根据具体的工厂类创建对应的对象此处是父类指针指向子类对象acar-run();Factory *mFactoryB new FactoryB(); // 创建具体工厂类BCar *bcar mFactoryB-createCar(); // 根据具体的工厂类创建对应的对象此处是父类指针指向子类对象bcar-run();// 注意析构delete acar;delete bcar;delete mFactoryA;delete mFactoryB;return 0;
}
4.抽象工厂模式
之前的工厂方法模式一个工厂只生产一个产品而在实际生活中通过一个工厂会生产多种产品比如车的组成需要轮胎和方向盘那么当出现多个产品的时候便需要使用抽象工厂模式。
4.1简介
提供一个创建一系列相关或相互依赖的对象接口而无需指定它们的具体类。其实抽象工厂模式就是多个工厂方法模式只是因为工厂方法是一个工厂只创建一个产品而抽象工厂模式是一个工厂创建多个产品。
4.1.1 组成结构
抽象工厂类是具体工厂类的父类其内部定义了创建多个产品对象的抽象接口必须由具体工厂类实现。 例如本节代码案例中的Factory类抽象接口为createTire和createWheel。
具体工厂类对应其具体产品用以创建对应的具体产品的对象。 例如本节代码案例中的 具体工厂工厂白色和具体工厂工厂黑色。
抽象产品类定义了产品的共同接口具体的产品类必须实现这个接口。工厂模式会由多个产品因此抽象产品类也是多个。 例如本节代码案例中的第一个抽象产品类轮胎和第二个抽象产品类方向盘。
具体产品类是抽象工厂模式中具体创建的对象。 例如本节代码案例中的白轮胎和黑轮胎白方向盘和黑方向盘。 4.1.2 优点和缺点
优点 创建产品族将一系列的产品族统一到一起进行创建缺点 扩展困难当产品族中有新产品比如新增发动机产品时需要修改抽象工厂的接口。
4.2 代码案例
现在场景为 白色工厂需要生产白色轮胎和白色方向盘。 黑色工厂需要生产黑色轮胎和黑色方向盘。 白色系列产品由白色工厂统一管理。 黑色系列产品由黑色工厂统一管理。
4.2.1 主要步骤
第一步创建第一个抽象产品类轮胎类。
第二步创建第一个抽象产品类的两个子类白轮胎类和黑轮胎类其子类是具体产品类。
第三步创建第二个抽象产品类方向盘类。
第四步创建第二个抽象产品类的两个子类白方向盘类和黑方向盘类其子类是具体产品类。
第五步创建抽象工厂类Factory类并提供生产所有对象的两个抽象接口。
第六步创建两个具体工厂类一个是生产白色产品的白色工厂类一个是生产黑色产品的白色工厂类并实现两个抽象方法创建不同的产品对象。
第七步客户端此例是main.cpp调用创建不同的工厂类对象从而创建出多个不同的产品对象。 4.2.2 代码
// 第一个抽象产品类轮胎
class Tire
{public:virtual void whcihtype() 0;string Tiretype;
};// 第一个抽象产类的第一个具体产品类白轮胎
class WhiteTire : public Tire
{public:WhiteTire(){Tiretype 白色轮胎;}virtual void whcihtype(){std::cout this is Tiretype Tiretype endl;}
};// 第一个抽象产类的第二个具体产品类黑轮胎
class BlackTire : public Tire
{public:BlackTire(){Tiretype 黑色轮胎;}virtual void whcihtype(){std::cout this is Tiretype Tiretype endl;}
};// 第二个抽象产品类方向盘
class Wheel
{
public:virtual void whcihtype() 0;string Wheeltype;
};// 第二个抽象产类的第一个具体产品类白色方向盘
class WhiteWheel : public Wheel
{public:WhiteWheel(){Wheeltype 白色方向盘;}virtual void whcihtype(){std::cout this is Wheeltype Wheeltype endl;}
};// 第二个抽象产类的第二个具体产品类黑色方向盘
class BlackWheel : public Wheel
{public:BlackWheel(){Wheeltype 黑色方向盘;}virtual void whcihtype(){std::cout this is Wheeltype Wheeltype endl;}
};// 抽象工厂类
class Factory
{
public:virtual Tire *createTire() 0; // 抽象接口virtual Wheel *createWheel() 0;
};// 具体工厂类工厂白色对应生产白色轮胎和白色方向盘
class FactoryWhite : public Factory
{
public:virtual Tire *createTire(){return new WhiteTire(); // 生产白轮胎}virtual Wheel *createWheel(){return new WhiteWheel(); // 生产白方向盘}
};// 具体工厂类工厂黑色对应生产黑色轮胎和黑色方向盘
class FactorBlock : public Factory
{
public:virtual Tire *createTire(){return new BlackTire(); // 生产黑轮胎}virtual Wheel *createWheel(){return new BlackWheel(); // 生产黑方向盘}
};int main()
{Factory *mFactoryWhite new FactoryWhite(); // 创建具体工厂类工厂白色Tire *mWhiteTire mFactoryWhite-createTire(); // 创建白色轮胎mWhiteTire-whcihtype();Wheel *mWhiteWheel mFactoryWhite-createWheel(); // 创建白色方向盘mWhiteWheel-whcihtype();Factory *mFactoryBlock new FactorBlock(); // 创建具体工厂类工厂黑色Tire *mBlockTire mFactoryBlock-createTire(); // 创建黑色轮胎mBlockTire-whcihtype();Wheel *mBlockWheel mFactoryBlock-createWheel(); // 创建黑色方向盘mBlockWheel-whcihtype();// 注意析构delete mFactoryWhite;delete mWhiteTire;delete mWhiteWheel;delete mFactoryBlock;delete mBlockTire;delete mBlockWheel;return 0;
}
5.区别
简单工厂模式 一个抽象产品类可以派生出多个具体产品类。 无抽象工厂类只有一个工厂类此工厂类负责生产所有产品。
工厂方法模式 一个抽象产品类可以派生出多个具体产品类。 一个抽象工厂类可以派生出多个具体工厂类。 每个具体工厂类只能创建一个具体产品类的实例。
抽象工厂模式 多个抽象产品类每个抽象产品类可以派生出多个具体产品类。 一个抽象工厂类可以派生出多个具体工厂类。 每个具体工厂类可以创建多个具体产品类的实例。
总结
抽象产品类工厂方法模式和简单工厂模式都只有一个抽象产品类而抽象工厂模式有多个。
具体产品类工厂方法模式和简单工厂模式都只能有一个抽象产品类派生出多个具体产品类而抽象工厂模式可以从多个抽象产品类派生出多个具体产品类。
抽象工厂类工厂方法模式和抽象工厂模式都有一个抽象工厂类而简单工厂模式没有。
具体工厂类简单工厂模式只有一个工厂类而工厂方法模式和抽象工厂模式可以有多个具体工厂类。工厂方法模式的具体工厂类只能创建一个具体产品类的实例而抽象工厂模式可以创建多个。
