JAVA设计模式之工厂模式

时间：2017-06-09 18:46:00 阅读：223 评论：0 收藏：0 [点我收藏+]

这两天突然想学学java源代码，不过看到一篇文章说看java源代码要先看设计模式，这样更容易理解源代码的结构，所以就准备学学java设计模式，首先当然是看java创建模式的工厂模式了，刚开始直接看抽象工厂模式是什么意思，百度百科的实在是看不懂,后来又在网上看了看其他的文章，仔细思考后，还算是理解了，现在跟大家分享下。

首先说说简单工厂模式，我用现实中的汽车工厂举例子，首先有个汽车类的接口叫做Car,里面有个开车的方法叫做drive(),然后有个吉利车的类叫做Jili,实现了car的接口,还有个奇瑞车的类叫做Qirui,也实现了Car的接口(因为都是车嘛，当然能开了)。

 1 interface Car{
 2             public void drive(){
 3                      System.out.println("我开车");
 4             }
 5        class Jili implements Car{
 6             public Jili(){
 7                      System.out.println("生产一台吉利车");
 8             }
 9             pulic void drive(){
10                      System.out.println("我开吉利车");
11             }
12       }
13       class Qirui implements Car{
14             public  Qirui(){
15                      System.out.println("生产一台奇瑞车");
16             }
17             pulic void drive(){
18                      System.out.println("我开奇瑞车");
19             }
20       }

那现在如果我要用Jili这个类，最基本的方式就是

      Jili jili=new Jili();

如果用Qirui这个类，最基本的方式也是

      Qirui qirui=new Qirui();

哦，那现在如果有个比亚迪车就得new Biyadi();然后同样有个drive()的方法，这样每个都得new个汽车对象，但是其实吉利，奇瑞和比亚迪他们都属于汽车，同样都有drive()方法，那是不是我们能创建一个生产汽车的工厂，然后你想要什么汽车只要告诉工厂就可以，工厂就帮你生产了，这样你不用管生产的细节工作（也就是new对象的过程），这样会更好呢，到此，简单工厂模式就出来了，简单工厂模式就是创建具有相同特征的类的实例,然后把创建汽车的方法静态化，这样就可以直接用工厂生产了，代码如下

 1 class CarFactory{
 2              public static Car createCar(String carname){
 3                   if("jili".equals(carname)){
 4                         return new Jili();
 5                   }else if("qirui".equals(carname)){
 6                         return new Qirui();
 7                   }else if("biyadi".equals(carname)){
 8                         return new Biyadi();
 9                   }
10             }

这就ok了，这样如果你要生产出一台汽车，直接调用Car car=CarFactory.createCar("jili");就可以了。

这种工厂虽然挺好，但是如果我每次要加入一个新车都得修改工厂类来加入新的判断语句，这样不符合开闭原则，所以慢慢人们又想出一种更加好的生产方式，这就是工厂方法模式。

首先我们把生产汽车的工厂类抽象出来当成一个接口，

 1 Interface CarFactory{
 2             public static Car createCar();
 3          }
 4          然后呢，让具体工厂类实现这个生产汽车的接口,这样就会有三个具体工厂，一个是吉利车生产工厂，一个是奇瑞车生产工厂，一个是比亚迪车生产工厂
 5          class JiliFactory  implements CarFactory{
 6             public static Car createCar(){
 7                   return new Jili();
 8             }
 9          }
10          class QiruiFactory  implements CarFactory{
11             public static Car createCar(){
12                   return new Qirui();
13             }
14          }
15          class BiyadiFactory  implements CarFactory{
16             public static Car createCar(){
17                   return new Biyadi();
18             }
19          }

这样做的好处就是如果我还要生产一个长城汽车，不用去修改CarFactory这个工厂，只需要再写个长城工厂类去实现CarFactory这个接口就可以了。这就是工厂方法模式，不过工厂方法模式和简单工厂模式的各有优点，也不能就说工厂方法模式就好，关键在于看实际情况去决定用哪种模式。

随着社会的进步，汽车种类也多了，比如分为越野车和跑车两个系列，而工厂方法模式一般是针对于一种系列的抽象产品的生产，而把工厂方法模式进行扩充，变成可以对多种系列的产品进行生产，这就是抽象工厂模式了。

百度说抽象工厂模式是创建多个产品族的产品对象，那我在这解释下什么是产品族，现在我们还是以汽车工厂生产汽车为例，随着汽车行业的发展，汽车在应用上分为越野车和跑车，这样原来Car这个接口就不能通用，而变成了YueyeChe()和PaoChe()这两个接口，而越野车适合在山路上跑，跑车适合在赛路上跑，所有drive的方法也改变了，代码如下

1  interface YueyeChe(){
2             public driveShanlu();
3          }
4          interface PaoChe(){
5             public driveSailu();
6          }

而吉利和奇瑞也都生产跑车和越野车，这样大家就好理解了，跑车就是一个抽象产品族，越野车也是一个抽象产品族，而吉利跑车，吉利越野车，奇瑞跑车，奇瑞越野车是真正的类，这样我们还有四个类

 1 public JiliPaoChe implements PaoChe{
 2             public driveSailu(){
 3                 System.out.println("我在赛路开吉利跑车");  
 4             }
 5          }
 6          public QiruiPaoChe implements PaoChe{
 7             public driveSailu(){
 8                 System.out.println("我在赛路开奇瑞跑车");  
 9             }
10          }
11          public JiliYueyeChe implements PaoChe{
12             public driveSailu(){
13                 System.out.println("我在山路开吉利越野车");  
14             }
15          }
16          public QiruiYueyeChe implements PaoChe{
17             public driveSailu(){
18                 System.out.println("我在山路开奇瑞越野车");  
19             }
20          }

车的接口和类就定义好了，相信大家也理解什么是产品族了，下面我们该看工厂怎么实现了，首先还是向工厂方法模式那样，有个生产汽车的工厂接口,不过我们对这个接口进行了一些扩充，因为Car类分成了跑车和越野车，所有我们接口也就是能生产出跑车和越野车这两种车型

1  Interface CarFactory{
2             public static PaoChe createPaoChe();
3  
4             public static YueyeChe createYueyeChe();
5          }

和工厂方法一样我们需要两个真正的工厂类来生产真正的汽车，恩.....当然，吉利工厂可以生产吉利跑车和吉利越野车，奇瑞工厂可以生产奇瑞跑车和奇瑞越野车，代码如下

 1 class JiliFactory  implements CarFactory{
 2             public static PaoChe createPaoChe(){
 3                   return new JiliPaoChe();
 4             }
 5             public static YueyeChe createYueyeChe(){
 6                   return new JiliYueyeChe();
 7             }
 8          }
 9          class QiruiFactory  implements CarFactory{
10             public static PaoChe createPaoChe(){
11                   return new QiruiPaoChe();
12             }
13             public static YueyeChe createYueyeChe(){
14                   return new QiruiYueyeChe();
15             }
16          }

ok了，抽象工厂模式也完成了，大家如果想生产一个吉利跑车,就可以JiliFactory.createPaoChe()；这样吉利跑车就出来了，不错吧，同理如果我们还要一个比亚迪的汽车工厂只要实现CarFactory这个工厂就行了，代码如下

1 class BiyadiFactory  implements CarFactory{
2             public static PaoChe createPaoChe(){
3                   return new BiyadiPaoChe();
4             }
5             public static YueyeChe createYueyeChe(){
6                   return new BiyadiYueyeChe();
7             }
8          }

相信大家应该理解了什么是抽象工厂模式，不过具体什么情况该如果选择哪种模式，还需要多多学习，才能融会贯通。

JAVA设计模式之工厂模式

原文：http://www.cnblogs.com/printN/p/6973263.html

踩

(0)

评论一句话评论（0）

分享档案

更多>

2021年09月23日 (328)
2021年09月24日 (313)
2021年09月17日 (191)
2021年09月15日 (369)
2021年09月16日 (411)
2021年09月13日 (439)
2021年09月11日 (398)
2021年09月12日 (393)
2021年09月10日 (160)
2021年09月08日 (222)