- 你点一下一个按钮（比如说：帮助->关于），你再点一次的话，它不会再弹出一个窗口。
- 类比：
计划生育，让你只能生一个孩子。
- 保证一个类仅有一个实例，并提供一个访问它的全局访问点。
- 构造函数私有化（类外不可以调用构造函数，便不可以创建对象）
- 有一个私有的静态的成员变量（属性），可以是指针、引用或者对象（见“饿汉”）
- 有一个公有的函数，可以返回一个该类对象（如果有的话直接返回，如果没有则创建）
- 顾名思义：需要创建时才创建对象
1 | /* |
- 顾名思义：从一开始加载的时候就创建对象
1 | /* |
电源适配器（把220V的交流电转换为电器能够使用的电压）
想复用一些现成的类，但是接口又与复用环境要求不一致。那么使用适配器转换接口。
1 | /* |
我感觉就是工厂方法的增强版，多了更多的操作子类，随之而来的就是更多的抽象工厂子类。每个工厂子类都可以操作对应的操作子类。并且它们使用的是统一的接口。
1 | /* |
把逻辑判断从工厂类中移到客户端。
工厂类下多了几个子类用来创建对应的进行实际操作的
子类对象。1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
128
129
130
131
132
133
134
135
136
137
138
139
140
141
142
143
144/*
* FactoryMethod.cpp
*
* 工厂方法模式
* Created on: 2016年3月13日 下午8:56:50
* Author: Wayne 13186259527@163.com
*/
#include <iostream>
#include <stdlib.h>
using namespace std;
class Operation {
private:
double x, y;
char c;
public:
Operation() {
}
Operation(double x, double y, char c) {
this->x = x;
this->y = y;
this->c = c;
}
virtual double Calc(double x, double y) {
return 0;
}
;
double GetX() {
return this->x;
}
double GetY() {
return this->y;
}
char GetC() {
return this->c;
}
};
class Add: public Operation {
public:
Add() {
}
;
double Calc(double x, double y) {
return x + y;
}
};
class Sub: public Operation {
public:
Sub() {
}
;
double Calc(double x, double y) {
return x - y;
}
};
class Mul: public Operation {
public:
Mul() {
}
;
;
double Calc(double x, double y) {
return x * y;
}
};
class Div: public Operation {
public:
Div() {
}
;
double Calc(double x, double y) {
if (y == 0) {
cout << "0不能作为被除数" << endl;
exit(0);
}
return x / y;
}
};
class Factory {
public:
virtual Operation* CreateOperation() {
return NULL;
}
;
};
class AddFactory: public Factory {
public:
Operation* CreateOperation() {
return new Add();
}
};
class SubFactory: public Factory {
public:
Operation* CreateOperation() {
return new Sub();
}
};
class MulFactory: public Factory {
public:
Operation* CreateOperation() {
return new Mul();
}
};
class DivFactory: public Factory {
public:
Operation* CreateOperation() {
return new Div();
}
};
int main(void) {
cout << "hello world" << endl;
cout << "eg:5+8" << endl;
double x, y;
char c;
cin >> x >> c >> y;
double result;
Factory *f = NULL;//指向对应的工厂
Operation *p = NULL;//指向对应的实现方法的子类
switch (c) {
case '+':
f = new AddFactory();
break;
case '-':
f = new SubFactory();
break;
case '*':
f = new MulFactory();
break;
case '/':
f = new DivFactory();
break;
}
p = f->CreateOperation();
result = p->Calc(x, y);
cout << "result = " << result << endl;
return 0;
}
这段时间准备着实习招聘，把以前懂一丢丢的设计模式又拿出来看看，这次看的书，主要是《大话设计模式》，偶尔翻一翻经典的《设计模式》。这几天看的是简单工厂模式、工厂方法模式、抽象工厂模式、策略模式。觉得它们有相似之处，所以在这里写下感想。如有错误，敬请指正（如果有人看的话✧(≖ ◡ ≖✿)）
简单工厂模式
①几个子类继承基类的方法，并且各自实现。
②工厂类根据客户端传入的参数，生成对应的子类并且返回客户端。
③客户端定义的基类的指针指向生成的子类，由这个指针去调用具体方法，实现功能
1 | /* |