一、概念
提供一個創建一系列相關或相互依賴對像的接口，而無需指定它們具體的類。
二、模式動機
這一系列對像之間是相互依賴的，相當于一個產品族
三、模式的結構
通過上圖我們可以清楚的看到抽像工廠模式包括以下4個角色：
1.抽像工廠角色（abstractfactory）：抽像工廠模式的核心，與具體的商業邏輯無關，通常是一個java接口或者抽像類。
2.具體工廠角色（concrete factory）：該角色通常與具體的商業邏輯緊密相關，該角色里面的工廠方法依據具體的商業邏輯實例化具體的產品并返回，客戶端通過該角色并調用該角色的工廠方法，獲得具體產品對像，該角色通常都是一個具體java類來承擔。
3.抽像產品角色：擔任這個角色的類是工廠方法模式所創建的產品的父類，或者他們共同擁有的接口，通常是一個接口或者抽像類。
4.具體產品角色：抽像工廠模式所創建的任何產品都是這個角色的實例，有一個具體java類來承擔。
樣例代碼如下：
|
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
145
146
147
148
149
150
151
152
153
154
155
156
157
158
159
160
161
162
|
public class abstractproducta { /** * @roseuid 59ac05990327 */ public abstractproducta() { }}public class producta1 extends abstractproducta { /** * @roseuid 59ac05990359 */ public producta1() { }}public class producta2 extends abstractproducta { /** * @roseuid 59ac05990381 */ public producta2() { }}public class abstractproductb { /** * @roseuid 59ac059903ba */ public abstractproductb() { }}public class productb1 extends abstractproductb { /** * @roseuid 59ac059a001f */ public productb1() { }}public class productb2 extends abstractproductb { /** * @roseuid 59ac059a0049 */ public productb2() { }}public abstract class abstractfactory { /** * @roseuid 59ac05690005 */ public abstractfactory() { } /** * @return abstractproducta * @roseuid 59abfb0103be */ public abstract abstractproducta createproducta() ; /** * @return abstractproductb * @roseuid 59abfb3b029d */ public abstract abstractproductb createproductb() ;}public class concretefactory1 extends abstractfactory { /** * @roseuid 59ac057a02fc */ public concretefactory1() { } /** * @return abstractproducta * @roseuid 59abfb9c00c9 */ public abstractproducta createproducta() { return new producta1(); } /** * @return abstractproductb * @roseuid 59abfba30011 */ public abstractproductb createproductb() { return new productb1(); }}public class concretefactory2 extends abstractfactory { /** * @roseuid 59ac057a02c0 */ public concretefactory2() { } /** * @return abstractproducta * @roseuid 59abfcc701b9 */ public abstractproducta createproducta() { return new producta2(); } /** * @return abstractproductb * @roseuid 59abfcc9001f */ public abstractproductb createproductb() { return new productb2(); }} |
|
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
|
public class client { /** * @roseuid 59ac055700ab */ public client() { } public static void main(string[] args){ abstractfactory theabstractfactory; abstractproducta theabstractproducta; abstractproductb theabstractproductb; theabstractfactory=new concretefactory1(); theabstractproducta=theabstractfactory.createproducta(); theabstractproductb=theabstractfactory.createproductb(); }} |
跟據上面的模式結構圖我們對“提供一個創建一系列相關或相互依賴對像的接口，而無需指定它們具體的類” 進行一個簡要的分析：
1.相關或相互依賴對像，在這里面producta1的實例和productb1的實例就是一組相互關聯（如內在的關聯關系）或相互依賴（如整體和部分）關系，依據業務邏輯，producta1
只能和同一產品等級結構abstractproductb下的productb1相互關聯而無法與productb2關聯在一起。
2.提供一個創建一系列相關或相互依賴對像的接口，而無需指定它們具體的類，這里面的接口，即為結構圖中的abstractproducta和abstractproductb，客戶端只依賴這些產品的接口進行編程，而不依賴于具體實現，即符合依賴倒轉原則。“無需指定它們具體的類” 即客戶端（client）跟本就不知道producta1、producta2、productb1和productb2的存在，客戶端只需要調用具體工廠的工廠方法即可返回具體的產品實例。
四、模式樣例
我們接著工廠方法模式中的樣例進行進一步分析，現在這個生產輪胎的工廠已經不滿足只生產轎車輪胎了，他現已經引入了發動機的生產線（engineline）、車門（doorline）等整個車的各種零部件生產線，可以說他現在可以輕松制造一部car，但是也并非所有的car都能制造，比如他現只能生產benz和bmw兩種類型的車（這樣的工廠也夠nx了），比如現在一部車只包含車輪胎、車門和發動機（當然肯定不止這么多），那么這個工廠就可以跟據客戶的要求生產bmw和benz車了，如下圖：
代碼如下：
|
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
145
146
147
148
149
150
151
152
153
154
155
156
157
158
159
160
161
162
163
164
165
166
167
168
169
170
171
172
173
174
175
176
177
178
179
180
181
182
183
184
185
|
public interface door { public void open(); public void close();}public class benzdoor implements door { @override public void open() { system.out.println("奔馳車門開"); } @override public void close() { system.out.println("奔馳車門關"); }}public class bmwdoor implements door { @override public void open() { system.out.println("寶馬車門開"); } @override public void close() { system.out.println("寶馬車門關"); }}public interface tire { public void getcolor(); public void getlife(); public void getwidth();}public class benztire implements tire { @override public void getcolor() { system.out.println("benz車color"); } @override public void getlife() { system.out.println("benz車life"); } @override public void getwidth() { system.out.println("benz車width"); }}public class bmwtire implements tire { @override public void getcolor() { system.out.println("bmw車color"); } @override public void getlife() { system.out.println("bmw車life"); } @override public void getwidth() { system.out.println("bmw車width"); }}public interface engine { public void start(); public void stop();}public class benzengine implements engine { @override public void start() { system.out.println("benz車start"); } @override public void stop() { system.out.println("benz車stop"); }}public class bmwengine implements engine { @override public void start() { system.out.println("bmw車start"); } @override public void stop() { system.out.println("bmw車stop"); }}public interface partfactory { public door createdoor(); public tire createtire(); public engine createengine();}public class benzpartfactory implements partfactory { @override public door createdoor() { return new benzdoor(); } @override public tire createtire() { return new benztire(); } @override public engine createengine() { return new benzengine(); }}public class bmwpartfactory implements partfactory { @override public door createdoor() { return new bmwdoor(); } @override public tire createtire() { return new bmwtire(); } @override public engine createengine() { return new bmwengine(); }}public class car { private door door; private engine engine; private tire tire; public car(partfactory factory) { this.door = factory.createdoor(); this.engine = factory.createengine(); this.tire = factory.createtire(); } public door getdoor() { return door; } public engine getengine() { return engine; } public tire gettire() { return tire; } }public class client { public static void main(string[] args) { partfactory partfactory=new benzpartfactory(); car benzcar=new car(partfactory); benzcar.getdoor().open(); benzcar.getengine().start(); benzcar.gettire().getcolor(); }} |
運行結果如下：
奔馳車門開
benz車start
benz車color
跟據上面的類圖及運行結果可以做如下分析：
benzdoor、benztire和benzengine有很強的關聯關系，我們可以說一部benz車，不可能用bmw的車門，即bmwdoor。這種很強的關聯關系通過benzpartfactory進行了很好的維護。對于客戶端來說，如上面的client類，如果客戶想要一部benz車，那么我只需要一個生產benz車的工廠即可，這個工廠所有的產品實例，都是benz車的部件。從運行結果我們也可以看出。
試想一下，隨著這個工廠的發展，他現在也要生產audi的車，這時我們只要增加一個audi的車門的類audidoor、auditire 、audiengine和audipartfactory就可以了，其它的類不需要做任何的修改。但客戶說，我要在車上裝一對翅膀呢，堵車時可以飛，這時我們就要對每個工廠都要增加能返回翅膀的工廠方法，要對每個工廠進行修改，這是不符合開閉原則的。所以說抽象工廠對增加產品等級結構方面是不支持開閉原則的，對于產品族維度（如audi車）是支持開閉原則的。
五、模式的約束
對于產生一個相互關聯或依賴的產品族適用，且支持在產品族方向的擴展，不適用于產品等級方向的擴展。
六、模式的變體與擴展
1、抽像工廠提供靜態工廠方法：抽像工廠可以提供一個靜態的工廠方法，通過參數返回具體的工廠實例。
2、抽像工廠與具體工廠合并：如果在產品族方向上確定只有一個產品族，那么抽像工廠就沒有必要了，這時只需要一個具體工廠就可以了，我們可以進一步延深，為這個具體工廠提供一個靜態方法，該方法返回自已的實例。
七、與其它模式的關系
如果只有一個產品等級結構，那么就是工廠方法模式了，如下圖：
如果有多個產品等級結構，那么抽像工廠里面的每一個工廠方法都是"工廠方法"模式。
八、模式優缺點
在產口族方向支持開閉原則，在產口等級結構方向不支持開閉原則。
以上就是本文的全部內容，希望對大家的學習有所幫助，也希望大家多多支持服務器之家。
原文鏈接：http://www.cnblogs.com/bateman6988/p/7469048.html
