java工厂模式

mahaijiang

1. 1、简单模式
   
2. //所有车的接口  有一个共同改的方法 开车
   
3. public interface Car {
   
4.     public void drive();
   
5. }
   
6. //奥迪类  实现car接口因为奥迪车也是车 肯定可以开的嘛
   
7. public class Audi implements Car {
   
8.     public Audi(){
   
9.         System.out.println("生产出一辆奥迪");
   
10.     }
    
11.     @Override
    
12.     public void drive() {
    
13.         System.out.println("开奥迪");
    
14.     }
    
15. }
    
16. //宝马类  实现car接口因为宝马车也是车 肯定也可以开
    
17. public class Bmw implements Car{
    
18.     public Bmw(){
    
19.         System.out.println("生产出一辆宝马");
    
20.     }
    
21.     @Override
    
22.     public void drive() {
    
23.         System.out.println("开宝马");
    
24.     }
    
25. }
    
26. //生产车的工厂  该工厂接收一个车名 你只需要告诉他你要生产什么车  就可以生产出对应的车出来
    
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.         //告诉工厂类 你需要生产出一辆奥迪车  那么给昂他传一个参数audi进去
    
41.         Car audi = CarFactory.getCar("audi");
    
42.         //就可以生产出奥迪的车 调用开车的方法就可以开车啦
    
43.         audi.drive();
    
44.         //宝马类似
    
45.         Car bmw = CarFactory.getCar("bmw");
    
46.         bmw.drive();
    
47.     }
    
48. }
    
49. 输出：
    
50. 成产出一辆奥迪
    
51. 开奥迪
    
52. 生产出一辆宝马
    
53. 开宝马
    
54. /**
    
55. *2、工厂方法模式
    
56. *根据以上代码 大家可以发现 比传统的new方法  Audi  audi = new Audi();要方便很多 如果说你因为需求 要加一个奔驰的车  那你还要Bnez  benz = new Bnez(); 这样的**话岂不是很麻烦,用工厂模式的话  客户端就不用在new对象 将生成对象的细节可代码都交给了工厂管理和实现 你只需要写一个getObject();方法获取到你想要的对象就ok了 *囚你要加一辆奔驰的话 只需要写一个benz的类 实现car接口  然后在工厂类中进行添加相应的逻辑代码就好了  
    
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.         //调用奥迪工厂类里面的生产奥迪的方法
    
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. 输出结果：
    
91. 生产出一辆奥迪
    
92. 开奥迪
    
93. 生产出一辆宝马
    
94. 开宝马
    
95. //这样的话 奥迪工厂类  就只专注生产奥迪的车 宝马一样只生产宝马车，如果我们需要加奔驰的话 只需要再写一个上产奔驰的工厂类去实现CarFactory接口  和一个奔驰实///体类实现car接口就好了代码如下：
    
96. public class Bnez implements Car{
    
97. 
    
98.     public Bnez() {
    
99.         System.out.println("生产出一辆奔驰");
    
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里面调用：
     
113. CarFactory factory = new BenzFactory();
     
114. Car benz = factory.getCar();
     
115. benz.drive();
     
116. /**
     
117. *3、抽象工厂模式
     
118. *但是大家又会觉得 奥迪和宝马也不止一种车啊   也有奥迪跑车 和奥迪越野车， 宝马跑车和宝马越野车啊 的确这样 那么以上两种方就实现不了  因为car这个接口就不能通*用了，他只能生产car，不能生产出跑车和越野车，所以第三种方法 我们需要将car这个接口里面的getCar()方法变成两个方法（一个上产跑车的方法getPaoche();一个生产越*野车的方法getYueye()） 所以引进第三种工厂模式：抽象工厂模式
     
119. */
     
120. //跑车接口
     
121. public interface Paoche {
     
122.     public void drive();
     
123. }
     
124. //越野车接口
     
125. public interface Yueye {
     
126.     public void drive();
     
127. }
     
128. //那么这样的话奥迪车是不是就变成了两个实体类了 之前只是一个audi这个类 现在变成了 奥迪跑车类和奥迪越野车类  加上宝马的话就有四个具体实现的类了
     
129. //奥迪跑车
     
130. public class AudiPaoche implements Paoche {
     
131.     public AudiPaoche(){
     
132.         System.out.println("奥迪工厂上产出一辆奥迪跑车");
     
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("奥迪工厂生产出一辆奥迪越野车");
     
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("宝马工厂生产出一辆宝马跑车");
     
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("宝马工厂生产出一辆宝马越野车");
     
160.     }
     
161.     public void drive() {
     
162.         System.out.println("宝马越野车");
     
163.     }
     
164. }
     
165. //生产跑车和越野车的接口
     
166. public interface CarFactory {
     
167.     public Paoche getPaoche();
     
168.     public Yueye getYueye();
     
169. }
     
170. //生产奥迪的工厂类实现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. //生产宝马的工厂类实现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.         //实例化生产宝马的工厂类 来上产宝马跑车和宝马越野车  宝马工厂有 生产宝马跑车和宝马越野车  这两个方法  具体是生产跑车还是越野车  看客户端选择
     
196.         CarFactory factory = new BmwFactory();
     
197.         //在这里选择的是生产跑车  调用的是上产跑车的方法
     
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. 输出结果：
     
207. 宝马工厂生产出一辆宝马跑车
     
208. 宝马跑车在路上跑
     
209. 奥迪工厂生产出一辆奥迪越野车
     
210. 奥迪越野车在路上跑
     
211. //写了这么多 希望对大家有所帮助吧

复制代码