java工廠模式

mahaijiang

1. 1、簡單模式
   
2. //所有車的接口  有一個共同改的方法 開車
   
3. public interface Car {
   
4.     public void drive();
   
5. }
   
6. //奧迪類  實現(xiàn)car接口因為奧迪車也是車 肯定可以開的嘛
   
7. public class Audi implements Car {
   
8.     public Audi(){
   
9.         System.out.println("生產(chǎn)出一輛奧迪");
   
10.     }
    
11.     @Override
    
12.     public void drive() {
    
13.         System.out.println("開奧迪");
    
14.     }
    
15. }
    
16. //寶馬類  實現(xiàn)car接口因為寶馬車也是車 肯定也可以開
    
17. public class Bmw implements Car{
    
18.     public Bmw(){
    
19.         System.out.println("生產(chǎn)出一輛寶馬");
    
20.     }
    
21.     @Override
    
22.     public void drive() {
    
23.         System.out.println("開寶馬");
    
24.     }
    
25. }
    
26. //生產(chǎn)車的工廠  該工廠接收一個車名 你只需要告訴他你要生產(chǎn)什么車  就可以生產(chǎn)出對應(yīng)的車出來
    
27. public class CarFactory {
    
28.     public static Car getCar(String caename){
    
29.         if(caename.equals("audi")){
    
30.             return new Audi();
    
31.         }else if(caename.equals("bmw")){
    
32.             return new Bmw();
    
33.         }
    
34.             return null;
    
35.     }
    
36. }
    
37. //測試
    
38. public class Test {
    
39.     public static void main(String[] args) {
    
40.         //告訴工廠類 你需要生產(chǎn)出一輛奧迪車  那么給昂他傳一個參數(shù)audi進(jìn)去
    
41.         Car audi = CarFactory.getCar("audi");
    
42.         //就可以生產(chǎn)出奧迪的車 調(diào)用開車的方法就可以開車?yán)?br />
43.         audi.drive();
    
44.         //寶馬類似
    
45.         Car bmw = CarFactory.getCar("bmw");
    
46.         bmw.drive();
    
47.     }
    
48. }
    
49. 輸出：
    
50. 成產(chǎn)出一輛奧迪
    
51. 開奧迪
    
52. 生產(chǎn)出一輛寶馬
    
53. 開寶馬
    
54. /**
    
55. *2、工廠方法模式
    
56. *根據(jù)以上代碼 大家可以發(fā)現(xiàn) 比傳統(tǒng)的new方法  Audi  audi = new Audi();要方便很多 如果說你因為需求 要加一個奔馳的車  那你還要Bnez  benz = new Bnez(); 這樣的**話豈不是很麻煩,用工廠模式的話  客戶端就不用在new對象 將生成對象的細(xì)節(jié)可代碼都交給了工廠管理和實現(xiàn) 你只需要寫一個getObject();方法獲取到你想要的對象就ok了 *囚你要加一輛奔馳的話 只需要寫一個benz的類 實現(xiàn)car接口  然后在工廠類中進(jìn)行添加相應(yīng)的邏輯代碼就好了  
    
57. *這種模式雖然好一些 但是囚我們每次要加一個汽車類的話，都要在工廠類里面修改判斷邏輯代碼，還是有一定的局限性，不符合開閉原則，因此我們下面介紹更好一點的方式*：工廠方法模式
    
58. */
    
59. //首先我們將carFactory工廠類 抽象成一個接口
    
60. public interface CarFactory {
    
61.     public Car getCar();
    
62. }
    
63. //然后我們再寫兩個首先該接口的具體工廠類（奧迪和寶馬）
    
64. public class AudiFactory implements CarFactory {
    
65.     @Override
    
66.     public Car getCar() {
    
67.         return new Audi();
    
68.     }
    
69. }
    
70.     public class BmwFactory implements CarFactory {
    
71.     @Override
    
72.     public Car getCar() {
    
73.         return new Bmw();
    
74.     }
    
75. }
    
76. //測試
    
77. public class Test {
    
78.     public static void main(String[] args) {
    
79.         //實例化奧迪工廠類
    
80.         CarFactory factory = new AudiFactory();
    
81.         //調(diào)用奧迪工廠類里面的生產(chǎn)奧迪的方法
    
82.         Car audi = factory.getCar();
    
83.         audi.drive();
    
84.         //寶馬和奧迪一樣
    
85.         CarFactory factory2 = new BmwFactory();
    
86.         Car bmw = factory2.getCar();
    
87.         bmw.drive();
    
88.     }
    
89. }
    
90. 輸出結(jié)果：
    
91. 生產(chǎn)出一輛奧迪
    
92. 開奧迪
    
93. 生產(chǎn)出一輛寶馬
    
94. 開寶馬
    
95. //這樣的話 奧迪工廠類  就只專注生產(chǎn)奧迪的車 寶馬一樣只生產(chǎn)寶馬車，如果我們需要加奔馳的話 只需要再寫一個上產(chǎn)奔馳的工廠類去實現(xiàn)CarFactory接口  和一個奔馳實///體類實現(xiàn)car接口就好了代碼如下：
    
96. public class Bnez implements Car{
    
97. 
    
98.     public Bnez() {
    
99.         System.out.println("生產(chǎn)出一輛奔馳");
    
100.     }
     
101.     @Override
     
102.     public void drive() {
     
103.         System.out.println("開奔馳");
     
104.     }
     
105. }
     
106. public class BnezFactory implements CarFactory{
     
107.     @Override
     
108.     public Car getCar() {
     
109.         return null;
     
110.     }
     
111. }
     
112. //在Test里面調(diào)用：
     
113. CarFactory factory = new BenzFactory();
     
114. Car benz = factory.getCar();
     
115. benz.drive();
     
116. /**
     
117. *3、抽象工廠模式
     
118. *但是大家又會覺得 奧迪和寶馬也不止一種車啊   也有奧迪跑車 和奧迪越野車， 寶馬跑車和寶馬越野車啊 的確這樣 那么以上兩種方就實現(xiàn)不了  因為car這個接口就不能通*用了，他只能生產(chǎn)car，不能生產(chǎn)出跑車和越野車，所以第三種方法 我們需要將car這個接口里面的getCar()方法變成兩個方法（一個上產(chǎn)跑車的方法getPaoche();一個生產(chǎn)越*野車的方法getYueye()） 所以引進(jìn)第三種工廠模式：抽象工廠模式
     
119. */
     
120. //跑車接口
     
121. public interface Paoche {
     
122.     public void drive();
     
123. }
     
124. //越野車接口
     
125. public interface Yueye {
     
126.     public void drive();
     
127. }
     
128. //那么這樣的話奧迪車是不是就變成了兩個實體類了 之前只是一個audi這個類 現(xiàn)在變成了 奧迪跑車類和奧迪越野車類  加上寶馬的話就有四個具體實現(xiàn)的類了
     
129. //奧迪跑車
     
130. public class AudiPaoche implements Paoche {
     
131.     public AudiPaoche(){
     
132.         System.out.println("奧迪工廠上產(chǎn)出一輛奧迪跑車");
     
133.     }
     
134.     public void drive() {
     
135.         System.out.println("奧迪跑車在路上跑");
     
136.     }
     
137. }
     
138. //奧迪越野車
     
139. public class AudiYueye implements Yueye {
     
140.     public AudiYueye(){
     
141.         System.out.println("奧迪工廠生產(chǎn)出一輛奧迪越野車");
     
142.     }
     
143.     public void drive() {
     
144.         System.out.println("奧迪越野車在路上跑");
     
145.     }
     
146. }
     
147. //寶馬跑車
     
148. public class BmwPaoche implements Paoche{
     
149.     public BmwPaoche(){
     
150.         System.out.println("寶馬工廠生產(chǎn)出一輛寶馬跑車");
     
151.     }
     
152.     public void drive() {
     
153.         System.out.println("寶馬跑車在路上跑");
     
154.     }
     
155. }
     
156. //寶馬越野車
     
157. public class BmwYueye implements Yueye {
     
158.     public BmwYueye(){
     
159.         System.out.println("寶馬工廠生產(chǎn)出一輛寶馬越野車");
     
160.     }
     
161.     public void drive() {
     
162.         System.out.println("寶馬越野車");
     
163.     }
     
164. }
     
165. //生產(chǎn)跑車和越野車的接口
     
166. public interface CarFactory {
     
167.     public Paoche getPaoche();
     
168.     public Yueye getYueye();
     
169. }
     
170. //生產(chǎn)奧迪的工廠類實現(xiàn)CarFactory
     
171. public class AudiFactory implements CarFactory{
     
172.     @Override
     
173.     public Paoche getPaoche() {
     
174.         return new AudiPaoche();
     
175. }
     
176.     @Override
     
177.     public Yueye getYueye() {
     
178.         return new AudiYueye();
     
179.     }
     
180. }
     
181. //生產(chǎn)寶馬的工廠類實現(xiàn)CarFactory
     
182. public class BmwFactory implements CarFactory {
     
183.     @Override
     
184.     public Paoche getPaoche() {
     
185.         return new BmwPaoche();
     
186.     }
     
187.     @Override
     
188.     public Yueye getYueye() {
     
189.         return new BmwYueye();
     
190.     }
     
191. }
     
192. //測試
     
193. public class Test {
     
194.     public static void main(String[] args) {
     
195.         //實例化生產(chǎn)寶馬的工廠類 來上產(chǎn)寶馬跑車和寶馬越野車  寶馬工廠有 生產(chǎn)寶馬跑車和寶馬越野車  這兩個方法  具體是生產(chǎn)跑車還是越野車  看客戶端選擇
     
196.         CarFactory factory = new BmwFactory();
     
197.         //在這里選擇的是生產(chǎn)跑車  調(diào)用的是上產(chǎn)跑車的方法
     
198.         Paoche paoche = factory.getPaoche();
     
199.         paoche.drive();
     
200. 
     
201.         CarFactory factory2 = new AudiFactory();
     
202.         Yueye yueye = factory2.getYueye();
     
203.         yueye.drive();
     
204.     }
     
205. }
     
206. 輸出結(jié)果：
     
207. 寶馬工廠生產(chǎn)出一輛寶馬跑車
     
208. 寶馬跑車在路上跑
     
209. 奧迪工廠生產(chǎn)出一輛奧迪越野車
     
210. 奧迪越野車在路上跑
     
211. //寫了這么多 希望對大家有所幫助吧

復(fù)制代碼