软件计划模式概念篇

创建型模式

1、创建型模式(Creational Pattern)对类的实例化过程进行了抽象，能够将软件模块中对象的创建和对象的使用分离。
2、为了使软件的布局更加清楚，外界对于这些对象只必要知道它们共同的接口，而不必要清楚其详细的实现细节，使整个体系的计划更加符合单一职责原则。
3、创建型模式隐藏了类的实例的创建细节，通过隐藏对象如何被创建和组合在一起达到使整个体系独立的目标。
工厂方法模式(Factory Method)

模式动机：

定义一个抽象工厂类，并在详细工厂类里重写这个抽象工厂类中定义的抽象方法。抽象化的结果使这种布局可以在不修改已有详细工厂类的情况下引进新的产品。
模式定义：

1、定义一个用于创建对象的接口，让子类决定实例化哪一个类。
2、在工厂方法模式中，父类负责定义创建对象的公共接口，而子类则负责天生详细的对象，将类的实例化操作延迟到子类中完成。
3、工厂方法模式属于类创建型模式。
布局

定义抽象产品接口（Product）：定义一个抽象产品接口，它声明了产品对象的通用属性和方法。所有详细产品类都必须实现这个接口方法。
创建详细产品类（Concrete Product）：实现抽象产品接口的详细产品类。每个详细产品类表现一种详细的产品。
定义抽象工厂接口（Creator）：创建一个抽象工厂接口，该接口声明了工厂方法，用于创建产品对象。
创建详细工厂类（Concrete Creator）：实现抽象工厂接口的详细工厂类，每个详细工厂类负责创建特定类型的产品。在客户端中使用工厂方法：
代码实现

1. #include<iostream>
2. #include<string>
3. using namespace std;
5. //抽象产品
6. class Product
7. {
8. public:
9.         virtual void productMethod() = 0;
10. };
11. //具体产品1
12. class ConcreteProduct_Xiaomi : public Product
13. {
14.         void productMethod() override
15.         {
16.                 cout << "小米手机生产。" << endl;
17.         }
18. };
20. //具体产品2
21. class ConcreteProduct_Huawei : public Product
22. {
23.         void productMethod() override
24.         {
25.                 cout << "华为手机生产。" << endl;
26.         }
27. };
29. //抽象工厂
30. class Creator
31. {
32. public:
33.         virtual Product* factoryMethod() = 0;
34. };
35. //具体工厂1
36. class ConcreteCreator_Xiaomi : public Creator
37. {
38. public:
39.         Product* factoryMethod() override
40.         {
41.                 return new ConcreteProduct_Xiaomi();
42.         }
43. };
44. //具体工厂2
45. class ConcreteCreator_Huawei : public Creator
46. {
47. public:
48.         Product* factoryMethod() override
49.         {
50.                 return new ConcreteProduct_Huawei();
51.         }
52. };
54. int main()
55. {
56.         //使用具体工厂创建具体产品
57.         Creator* Xiaomi_Fac = new ConcreteCreator_Xiaomi();
58.         Product* Xiaomi_pro = Xiaomi_Fac->factoryMethod();
59.         Xiaomi_pro->productMethod();
61.         Creator* Huawei_Fac = new ConcreteCreator_Huawei();
62.         Product* Huawei_pro = Huawei_Fac->factoryMethod();
63.         Huawei_pro->productMethod();
64. }

复制代码

应用场景

后续补充
抽象工厂模式(Abstract Factory)

模式动机：

在工厂方法模式中，每个详细工厂对应一种详细产品。偶然，我们必要一个工厂可以提供多个产品对象，而不是单一的产品对象。
抽象工厂模式定义：

1、提供一个创建一系列相关或相互依赖对象的接口，而无需指定它们详细的类。
2、抽象工厂模式属于对象创建型模式
布局：

抽象工厂接口（Abstract Factory）： 定义了一组方法，每个方法用于创建某一类对象，通常包括多个产品族的创建方法。
详细工厂类（Concrete Factory）： 实现了抽象工厂接口，负责创建详细的产品对象。每个详细工厂类通常对应一个产品族。
抽象产品接口（Abstract Product）： 义了一组方法，用于描述产品的通用行为。
详细产品类（Concrete Product）： 实现了抽象产品接口，表现真正的产品对象。每个详细产品类属于某个产品族。
代码实现：

1. #include<iostream>
2. #include<string>
3. using namespace std;
5. //抽象手机产品
6. class aF_ProductPhone
7. {
8. public:
9.         virtual void phoneMethod() = 0;
10. };
11. //具体产品-小米手机
12. class aF_ConcreteProductPhone_Xiaomi : public aF_ProductPhone
13. {
14. public:
15.         void phoneMethod() override
16.         {
17.                 cout << "小米手机生产。" << endl;
18.         }
19. };
21. //具体产品-华为手机
22. class aF_ConcreteProductPhone_Huawei : public aF_ProductPhone
23. {
24. public:
25.         void phoneMethod() override
26.         {
27.                 cout << "华为手机生产。" << endl;
28.         }
29. };
31. //抽象电脑产品
32. class aF_ProductComputer
33. {
34. public:
35.         virtual void computerMethod() = 0;
36. };
37. //具体产品-小米电脑
38. class aF_ConcreteProductComputer_Xiaomi : public aF_ProductComputer
39. {
40. public:
41.         void computerMethod() override
42.         {
43.                 cout << "小米电脑生产。" << endl;
44.         }
45. };
47. //具体产品-华为电脑
48. class aF_ConcreteProductComputer_Huawei : public aF_ProductComputer
49. {
50. public:
51.         void computerMethod() override
52.         {
53.                 cout << "华为电脑生产。" << endl;
54.         }
55. };
57. //抽象工厂
58. class aF_AbstractFactory
59. {
60. public:
61.         virtual aF_ProductPhone* createPhone() = 0;
62.         virtual aF_ProductComputer* createComputer() = 0;
63. };
65. //具体工厂-小米
66. class aF_XiaomiFactory : public aF_AbstractFactory
67. {
68. public:
69.         aF_ProductPhone* createPhone() override
70.         {
71.                 return new aF_ConcreteProductPhone_Xiaomi();
72.         }
73.         aF_ProductComputer* createComputer() override
74.         {
75.                 return new aF_ConcreteProductComputer_Xiaomi();
76.         }
77. };
79. //具体工厂-华为
80. class aF_HuaweiFactory : public aF_AbstractFactory
81. {
82. public:
83.         aF_ProductPhone* createPhone() override
84.         {
85.                 return new aF_ConcreteProductPhone_Huawei();
86.         }
87.         aF_ProductComputer* createComputer() override
88.         {
89.                 return new aF_ConcreteProductComputer_Huawei();
90.         }
91. };
92. int main()
93. {
94.         //小米工厂
95.         aF_AbstractFactory* xiaomiFac = new aF_XiaomiFactory();
96.         aF_ProductPhone* xiaomiPhone = xiaomiFac->createPhone();
97.         xiaomiPhone->phoneMethod();
98.         aF_ProductComputer* xiaomiComputer = xiaomiFac->createComputer();
99.         xiaomiComputer->computerMethod();
100.         //华为工厂
101.         aF_AbstractFactory* huaweiFac = new aF_HuaweiFactory();
102.         aF_ProductPhone* huaweiPhone = huaweiFac->createPhone();
103.         huaweiPhone->phoneMethod();
104.         aF_ProductComputer* huaweiComputer = huaweiFac->createComputer();
105.         huaweiComputer->computerMethod();
106. }

复制代码

应用场景

后续补充
单例模式(Singleton Pattern)

模式动机：

对于体系中的某些类来说，有且只能有一个实例。
（1）一个体系只能有一个窗口管理器。
（2）体系中可以有很多打印机，但是只能有一个打印机正在工作。
单例模式定义：

1、确保一个类只有一个实例，并提供一个全局访问点来访问这个唯一实例。
2、单例模式属于对象创建型模式。
3、单例负责类的实例的创建，且是唯一的。因此，在单例类的外部无法使用new创建。否则，该类的实例对象就不是单例。
布局：

代码实现：

懒汉式单例模式：

1. [/code][b]饿汉式单例模式：[/b]
2. [code]

复制代码

应用场景

后续补充
持续更新中

免责声明：如果侵犯了您的权益，请联系站长，我们会及时删除侵权内容，谢谢合作！更多信息从访问主页：qidao123.com:ToB企服之家，中国第一个企服评测及商务社交产业平台。