本文實例講述了java設計模式之工廠模式。分享給大家供大家參考，具體如下：
一、 簡單工廠
先來思考一個問題。我們平時寫程序時，會有這種情況，a對象里面需要調用b對象的方法，這時我們使用的一般是new關鍵字來創建一個b實例，然后調用b實例的方法。這種做法的壞處在于：a類的方法實現直接調用了b類的類名（這種方式也被稱為硬編碼耦合），一旦系統需要重構：需要使用c類來代替b類時，程序就不得不修改a類代碼，如果應用中有100個或者10000個類以硬編碼方式耦合了b類，則需要修改100個、10000個地方，這顯然是一種非常可怕的事情。
換一個角度來看這個問題：對已a對象而言，它只需要調用b對象的方法，并不關心b對象的實現、創建過程，考慮讓b類實現一個ib接口，而a類只需要與ib接口耦合——a類并不直接使用new關鍵字來創建b實例，而是重新定義一個工廠類：ibfactory，由該工廠類負責創建ib實例，而a類用過調用ibfactory工廠的方法來得到ib的實例。通過以上設計：需要使用c類代替b類，則只需要讓c類也實現ib接口，并改寫ibfactory工廠中創建ib實例的實現代碼，讓該工廠產生c實例即可。這種將多個類對象交給工廠類來生成的設計方式叫做簡單工廠模式。
以下是簡單工廠模式的代碼：
|
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
|
/** * 簡單工廠模式 * * 需要工廠生產的對象實例所實現的共同的接口 * 發型接口 * @author administrator * */public interface hair { /** * 畫發型 */ public void draw();}/** * 左偏分發型 * @author administrator * */public class lefthair implements hair { @override public void draw() { system.out.println("----------------畫左偏分發型-----------------"); }}/** * 右偏分發型 * @author administrator * */public class righthair implements hair { @override public void draw() { system.out.println("-----------------畫右偏分發型------------------"); }}/** * 生產發型的工廠 * 要生產什么發型 只需在這里改就行了 * @author administrator * */public class hairfactory { public hair gethair() { return new lefthair(); //return new righthair(); }}/** * 客戶端測試類 * @author administrator * */public class hairtest { public static void main(string[] args) { hairfactory factory = new hairfactory(); hair hair = factory.gethair(); hair.draw(); }} |
可以看到，如果想把hairtest里面生成的lefthair改成righthair，只需修改hairfactory里面gethair方法的實現即可。
使用簡單工廠模式的優勢在于：讓對象的調用者和對象的創建過程分離，當對象調用者需要對象時，直接向工廠請求即可，從而避免了對象的調用者與對象實現類以硬編碼方式耦合，以提高系統的可維護性、可擴展性。當然，工廠模式也有一個小小的缺陷，當產品修改時，工廠類也要做相應的修改，此處可使用策略模式進行解決，下面是代碼。
|
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
|
public interface hairbuilder { /** * 制造發型 * @return */ public hair gethair();}public class lefthairbuilder implements hairbuilder { @override public hair gethair() { return new lefthair(); }}public class righthairbuilder implements hairbuilder { @override public hair gethair() { return new righthair(); }}public class hairfactory { private hairbuilder hairbuilder; public hairfactory(hairbuilder hairbuilder) { this.hairbuilder = hairbuilder; } public void sethairbuilder(hairbuilder hairbuilder) { this.hairbuilder = hairbuilder; } public hair gethair() { return hairbuilder.gethair(); }}public class hairtest { public static void main(string[] args) {// hairbuilder builder = new lefthairbuilder(); hairbuilder builder = new righthairbuilder(); hairfactory factory = new hairfactory(builder); hair hair = factory.gethair(); hair.draw(); }} |
這種做法的好處是無需再去修改工廠類，將工廠里面的創建對量邏輯根據不同的策略抽象出來，程序需要創建什么對象，只需網工廠中傳入相應的builder即可。
二、工廠方法
在簡單工廠模式中，系統使用工廠類生產所有產品實例，且該工廠類決定生產哪個類的實例，即工廠類負責所有的邏輯判斷、實例創建等工作。
如果不想再工廠類中進行邏輯判斷，程序可以為不同的產品類提供不同的工廠，不同的工廠類生產不同的產品，無需再工廠類中進行復雜的邏輯判斷。這就有點類似于上面的簡單工廠模式結合策略模式，不同的是前者只有一個工廠，后者需要有多個工廠。下面是工廠方法模式的代碼。
|
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
|
/** * 工廠方法模式 * 需要工廠生產的對象實例所實現的共同的接口 * @author administrator * */public interface person { public void drawperson();}public class man implements person { @override public void drawperson() { system.out.println("---------------------draw a man--------------------"); }}public class women implements person { @override public void drawperson() { system.out.println("--------------------draw a women---------------------"); }}/** * 生產人的工廠 * @author administrator * */public interface personfactory { //生產人 public person getperson();}/** * 生產man的工廠 * @author administrator * */public class manfactory implements personfactory { @override public person getperson() { return new man(); }}/** * 聲場women的工廠 * @author administrator * */public class womenfactory implements personfactory { @override public person getperson() { return new women(); }}/** * 客戶端測試類 * @author administrator * */public class persontest { public static void main(string[] args) {// personfactory factory = new manfactory(); personfactory factory = new womenfactory(); person person = factory.getperson(); person.drawperson(); }} |
這種的典型的特點就是在客戶端代碼中根據不同的工廠生產其對應的產品，不必把復雜的邏輯都放在工廠類里面判斷。這種實現有一個很明顯的缺陷，就是客戶端與工廠類進行了耦合。
三、抽象工廠
采用上面的工廠方法的設計架構，客戶端代碼成功與被調用對象的實現類分離，但帶來了另一種耦合：客戶端代碼與不同的工廠類耦合。為了解決這種耦合的問題，考慮在增加一個工廠類，用來生成工廠實例，實現生產產品的工廠與客戶端分離，這種設計方式被稱為抽象工廠模式。下面是抽象工廠模式的代碼
|
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
|
/** * 抽象工廠模式 * 生產personfactory的工廠 * @author administrator * */public class personfactoryfactory { public static personfactory getpersonfactory(string type) { if(type.equalsignorecase("man")) { return new manfactory(); } else { return new womenfactory(); } }}/** * 客戶端測試類 * @author administrator * */public class persontest { public static void main(string[] args) { personfactory factory = personfactoryfactory.getpersonfactory("man"); person person = factory.getperson(); person.drawperson(); }} |
希望本文所述對大家java程序設計有所幫助。
原文鏈接：https://blog.csdn.net/zw19910924/article/details/52373892
