Java常用设计模式详解（一）---工厂模式

设计模式的原则：针对借口编程

工厂模式的作用：

         A.应用程序的设计中把对象的的创建集中在一个地方创建或者统一由某类来管理（spring）

         B.在不改动应用程序的基础上可以直接添加对象，同时也利于对象的维护。

工厂模式的种类：

         A.简单工厂

         B.工厂方法

         C.抽象工厂

楔子：

        话说东北某老板家里有三辆车，奔驰，宝马，蓝博基尼，雇了一名有经验的司机，不同的场合他会吩咐司机开不同的车应酬。

     简单工厂：

     abstruact:

               package com.product.abstruct;

            public interface Car {

                    public void drive();//车是用来开的，所以得有个发动机
               }

     implements:

             package com.product.implement;

             import com.product.abstruct.Car;

             public class Audi implements Car {

                 public void drive(){//宝马他也是车不是马，也得有发动机
                          // TODO Auto-generated method stub
                          System.out.println("yes,today wo are driving Audi。。。。");
                   }
               }
            
             package com.product.implement;

             import com.product.abstruct.Car;

             public class Benz implements Car {

             public void drive(){//奥迪他也是车不是迪奥，也得有发动机
                     // TODO Auto-generated method stub
                     System.out.println("yes,today wo are driving Benz。。。。");
                     System.out.println("老板,一些按照您的吩咐....");
                    }
               }

                 ======兰博基尼省======

    Factory类：

       factory类是一个管理类，是汽车的直接负责人，这个人就是老板的司机；

                package com.product.factory;
             import com.product.abstruct.Car;
             import com.product.implement.Audi;
             import com.product.implement.Benz;

             public class Driver {
                      public static Car driveCar(String carName) throws Exception{
                               if(carName.equalsIgnoreCase("Benz")){
                                       return new Benz();
                                 }
                                 if(carName.equalsIgnoreCase("bmw")){
                                        return new Bwm();
                                  }  
                                        return new Audi();
                               }
                     }

           某一天老板要去英格兰观看利物浦主场对阵维拉的比赛，需要开宝马去机场，于是把司机叫来，让他下午2点开宝马来接他。。。

                   package com.product.test;
              import com.product.abstruct.Car;
              import com.product.factory.Driver;

                    public class Test {
                           public static void main(String[] args) throws Exception{
                                   //tell the driver which car wo drive todaty wo will to Amsterdam
                                    Car car = Driver.driveCar("Benz");//让司机开车过来接
                                    //Mrs wang go
                                   car.drive();//一键启动
                              }

                       }

           工厂方法：

         随着老板的生意越做越大，越来越有钱，于是乎他有买了几辆跑车----法拉利、保时捷、捷豹三部座驾，由于车两增加了，所有的汽车都要有老司机一个人管理，年检、保险、罚单、洗车，老司机一个人实在吃不消，而且老板会吩咐老司机从周一到周六要开不同款式的车外出，这个时候老司机就不得不记住老板哪天需要开哪辆车外出，于是乎给老板提议：给每台车都聘请一个司机，每辆汽车都有一个专门的人员负责，需要外出的时候招呼我一声，我就会派相应的人员过来接老板，老板毫不犹豫的说:就这么办.......

        抽象汽车类：

                    package com.product.car.abstruct;

                    public interface Car {

                            public void drive();
                     }

          奥迪汽车：

                     package com.product.car.implement;
                     import com.product.car.abstruct.Car;

                     public class AudiDriver implements Car  {

                           public void drive() {
  
                                System.out.println("想当官四个圈");
  
                            }
                      }

            奔驰汽车：

                     package com.product.car.implement;
                     import com.product.car.abstruct.Car;

                     public class AudiDriver implements Car {

                          public void drive() {

                                System.out.println("想当官四个圈");

                          }
                     }

             ======省略其他汽车======

             汽车总管（老司机）

 

                      package com.product.car.manager;
                      import com.product.car.abstruct.Car;

                      public interface CarManager {
 
                            public Car driveCar();
 
                       }

              新招聘的奥迪司机：

                       package com.product.car.managerImpl;
                       import com.product.car.abstruct.Car;
                       import com.product.car.implement.AudiDriver;
                       import com.product.car.manager.CarManager;

                      public class AudiManager implements CarManager {

                           public Car driveCar() {
  
                              return new AudiDriver();
  
                            }
                       }

             新招聘的奔驰司机：

                      package com.product.car.managerImpl;
                      import com.product.car.abstruct.Car;
                      import com.product.car.implement.BenzDriver;
                      import com.product.car.manager.CarManager;

                      public class BenzManager implements CarManager {
 
                           public Car driveCar(){
  
                                  return new BenzDriver();
  
                            }
                      }

             某天老板想去利物浦：

                       package com.product.test;
                       import com.product.car.abstruct.Car;
                       import com.product.car.implement.BenzDriver;
                       import com.product.car.manager.CarManager;

                       public class Test {
 
                           public static void main(String[] args) throws Exception{
                                   //找到汽车主管，告诉他今天我想开宝马去看利物浦对阵维拉的比赛
                                 CarManager carManager = (CarManager) new BenzDriver();
                                //负责宝马汽车的司机接到管家的电话，给宝马加满油,宝马来喽
                               Car driveCar = carManager.driveCar();
                                //飞奔利物浦
                               driveCar.drive();
                           }
                    }

 以上就是工厂模式中的简单工厂，工厂方法，先来比较一下这两种模式的却别以及各自的优势所在，

   程序设计角度：

       a.简单工厂没有抽象类，只有一个工厂类，把需要创建对象的参数传递过来，由工厂类统一创建

       b.定义一个创建产品对象的接口，该接口扮演这核心的角色，他只需要定义子类必须实现的方法即可，将对象交给对象本身来创建

   优势劣势：

       a.相对简单工厂工厂方法要更加的抽象，这样做的好处在于不改变工厂角色的基础上（不辞退老司机或者给他调岗）可以很轻松的增加新的成员（招聘更多的司机）；

       b.简单工厂的优势在于简单，仅仅是根据参数来创建相应对象即可，但劣势也相当明显，所有的对象都集中在该类中创建，所创建的对象只能是事先就知道的（忽然有一天老板买来一辆手动挡捷达，老板就必须通知老司机，我买了一辆捷达，在X放着）；成员对象的添加会引起核心类增加方法，违反高内聚，当系统中的具体产品类不断增多时候，可能会出现要求工厂类根据不同条件创建不同实例的需求．这种对条件的判断和对具体产品类型的判断交错在一起，很难避免模块功能的蔓延，对系统的维护和扩展非常不利；

接下来时工厂模式的应用，程序设计中我们如何合理的应用工厂设计模式呢

　　a.对于某个产品，调用者清楚地知道应该使用哪个具体工厂服务，实例化该具体工厂，生产出具体的产品来。Java Collection中的iterator() 方法即属于这种情况。

　b.只是需要一种产品，而不想知道也不需要知道究竟是哪个工厂为生产的，即最终选用哪个具体工厂的决定权在生产者一方，它们根据当前系统的情况来实例化一个具体的工厂返回给使用者，而这个决策过程这对于使用者来说是透明的。