工厂模式介绍

工厂模式一共分为：

简单工厂模式   又称静态工厂模式

工厂方法模式   又称多态工厂模式 polimorphic factory

抽象工厂模式   又称工具箱模式

 

 

 

下面通过  女娲捏土造成 来说明：

 

1.简单工厂模式

 

这个模式的问题是 ：部分满足 开放封闭原则。只要再造一种新人，不如人妖。那就得修改女娲那个类。累死女娲

 

体现在代码里就是：

 

女娲类的核心是：

switch(type){

     case '男人':  。。。;

     break;

 

      case '女人':。。。;

     break;

 

       default

            break;

}

当玉环大帝说，造个人妖吧，女娲类就得修改成

switch(type){

     case '男人':  。。。;

     break;

 

      case '女人':。。。;

     break;

 

     case '人妖‘：。。。；

      break;

 

     default

            break;

}

 

这样就只是部分地满足了 开放封闭原则：对扩展开放，对修改封闭。

 

 

 

 

2.工厂方法模式

能完全满足开放封闭原则。

通过抽象出 女娲类。

 

就好比：女娲说，我自己也亲自去造人了，谁要造人就从我这拿绳。

           造女人，就拿阴绳；造男人，就拿阳绳；如果某天要造人妖，就拿阴阳绳吧

体现在代码里就是：

      public interface 女娲(){

          public 人 造人();

   }

 

   具体的女娲就是实现上面的接口：

      public class 造男人女娲 implements 女娲(){

              public 人 造人(){

                     return   ’男人‘；

               }

     }

 

       public class 造女人女娲 implements 女娲(){

              public 人 造人(){

                     return   ’女人‘；

               }

     }

 

     实际在 造的时候就是：

          女娲 nw_man = new 造男人女娲();

         nw_man.造人(); //这样造出来的就是男人。  这就是多态。一种对象的多种形态。女娲有造男人的女娲，造女人的女娲。。。

 

   多态的条件有三个： 有继承，有重写, 子类实例指向引用

 

所以工厂方法模式也叫多态工厂模式！！！

 

实际有一次在项目中式通过配置文件来实现的。通过修改配置文件，会更加方便。不过要用到反射。具体的代码，回去再研究研究

 

三：抽象工厂方法

    面对的情形是： 产品族，要增加一类产品族。

 

一个经典的，很能说明问题的例子是：

我有一个制作工厂，现在的业务是承接PC机的RAM和CPU的生产，还承接MAC机的RAM和CPU的生产。

 

在这里MAC机的RAM和CPU就叫做一个产品族。

 

那代码设计应该是怎么样的呢？

有多少种产品族，就有多少个抽象的工厂。

 

比如现在是2个产品族，PC机的和MAC机的。

 

最顶级的抽象接口是：

//抽象工厂角色

　　public interface ComputerProducer 　　{ 　//功能很明白，就是我们厂子就生成CPU和RAM

　      Cpu createCpu();

   　　Ram createRam();

　　}

//

　　//两个具体工厂角色 　　

     public class PcProducer implements ComputerProducer 　　{ //生成PC配件的工厂　

                　public Cpu createCpu() 　　{ 　　return new PcCpu(); 　　}

             　　public Ram createRam() 　　{ 　　return new PcRam(); 　　} 　　

 

   } 　

 

　public class MacProducer implements ComputerProducer 　　{ 　　//生产Mac配件的工厂

                  public Cpu createCpu() 　　{ 　　return new MacCpu(); 　　}

            　　public Ram createRam() 　　{ 　　return new MacRam(); 　　}

　　}

 

里面具体的产品类是：

 

公司承接的2中配件：

//两个抽象产品

　　public interface Cpu 　　{ 　　}//生产cpu 　

      public interface Ram 　　{　　}//生成ram

 

然后具体的产品就可以实现上面的接口：

   //四个具体产品

　　public class PcCpu implements Cpu 　　{ 　　} 　　 　　

      public class PcRam implements Ram 　　{ 　　} 　　

 

      public class MacRam implements Ram 　　{　　}

      public class MacCpu implements Cpu 　　{ 　　}

 

客户来了，那么：

      ComputerProducer  工厂1 = new PCProducer();//那么工厂1生成出来的cpu和RAM都是PC机上的

      ComputerProducer  工厂2 = new MACProducer();//那么工厂2生成出来的cpu和RAM都是MAC机上的

 

     工厂1.createCpu();  //这就是生产PC的CPU。

 

 

如果此时，火星机的RAM和CPU也找到我们厂子来生成。那么很简单：

来一个火星机具体工厂

    public class 火星Producer implements ComputerProducer 　　{ //生成火星机配件的工厂　

                　public Cpu createCpu() 　　{ 　　return new PcCpu(); 　　}

             　　public Ram createRam() 　　{ 　　return new PcRam(); 　　} 　　

 

   } 　

 

具体 的产品再加2个：

    public class 火星Cpu implements Cpu 　　{ 　　} 　　 　　 

     public class 火星Ram implements Ram 　　{ 　　} 　

 

 

然后

      ComputerProducer  工厂3 = new 火星Producer();//那么工厂3生成出来的cpu和RAM都是火星机上的

 

 

方便吧。其实女娲的故事也可以用进来，看下图：

 

 

终极总结：

 

      1.简单工厂，就是在工厂类里switch。什么具体的事情都放在工厂类里来做；  一有新产品要做，就要修改工厂类

                         所以只是部分满足   开放封闭原则；

      2. 工厂方法， 把工厂类抽象出来，然后继承具体的工厂。如果新产品来了，就再继承出一个新的产品工厂。

                         完全满足 开放封闭原则。

        3. 抽象工厂方法  面对的是产品族的情况。新增加一个产品族，可以在满足开放封闭原则的情况下实现。

                                但是如果新增一个产品，那就得破坏开放封闭原则了。

 

 

再借鉴下别人的总结：

 

简单工厂：用来生产同一等级结构中的任意产品。（对于增加新的产品，无能为力）
工厂模式：用来生产同一等级结构中的固定产品。（支持增加任意产品）
抽象工厂：用来生产不同产品族的全部产品。（对于增加新的产品，无能为力；支持增加产品族）

 

 

好的。谢谢地球。加油