工厂模式

                                                                                                         
 Java设计模式--工厂模式

一:问题的背景提出.

      工厂模式是Java中的常用的设计模式之一,在框架里面使用的比较多如经典的Spring框架,其中著名的BeanFactory----管理Bean的工厂.是管理对象等的指导思想.属于创建型设计模式.提供了一种创建对象的策略,不在是直接使用关键字 new直接创建对象了.而是创建一个对象接口,是对象创建延迟到了子类的.降低了耦合度.不同条件下创建不同的实例的.通俗的讲就是将我们的需求有工厂帮我们输出我们想要的产品（对象）.

     工厂模式的介绍:

     意图：定义一个创建对象的接口，让其子类自己决定实例化哪一个工厂类，工厂模式使其创建过程延迟到子类进行。

     主要解决：主要解决接口选择的问题。

     何时使用：我们明确地计划不同条件下创建不同实例时。

     如何解决：让其子类实现工厂接口，返回的也是一个抽象的产品。

     关键代码：创建过程在其子类执行。
    现实的生活中,计算机中的工厂模式和实际的工厂的所有的特征非常的相似.有两个关键的角色就是;产品和工厂.直接了当--工厂就是生产产品的嘛。不过就是我们需要的对象吧.因此关键的一点就是如何联系工厂和产品这两个角色之间的联系了.

二:处理两者之间的关系的四种情况.这里就以现实生活中的汽车制造厂为例进行分析介绍

       (1):小汽车厂是单一的产品线

             就只是有高档,中档,抵挡三种类型的.

       (2):多产品生产线

             有小汽车,公共汽车两种的（都有高,中,低）特征都相同.

       (3): 多产品线(部分特征相同) 

             小汽车,公共汽车有高,中低,就有部分都是相同的.  

       (4)：多产品生产线--但是所有的特征都是不相同的.

             小汽车有高档,中档两类型.公共汽车就是只有抵挡类型的.

         上面的工厂生产汽车的几种情况就是分别映射到工厂模式一般分为简单工厂,工厂,抽象工厂3类的.

    三:简单工厂实例       

       1:定制抽象产品接口(类比一家大型的小汽车制造厂)

        代码如下:

               public interface Car {

      

          }

       2:定制具体产品子类(定制具体的产品,就是高档小汽车,中档小汽车,抵挡小汽车)

        代码如下:(生产高档小汽车)

        public class TopCar implements Car {

       

       }  

      （中档小汽车）

       public class MidCar implements Car{

       }

      (抵挡小汽车)

      public class LowCar implements Car {

      }

     3：定义工厂类（简单工厂）

     public class CarSimpleFactory {

   /*

    * 定义小汽车的类型,这里的类型固定建议使用枚举类型替代

    */

   public static final String TOPTYPE="toptype";

   public static final String MIDTYPE="midtype";

   public static final String LOWTYPE="lowtype";

   

   //生产小汽车的方法

   public static Car car(String type){
   Car car=null;
   if(type.equals(TOPTYPE)){
   car=new TopCar();
   }else if(type.equals(MIDTYPE)){
   car=new MidCar();
   }else if(type.equals(LOWTYPE)){
   car=new LowCar();
   }else{
   car=null;
   }
   return car;

       }

     }

      分析简单工厂的特点:首先说明一点的就是这个一个实在的类,不是接口或抽象类.这个在后面的工厂模式有对比就有发现的.简单工厂的方法建议是静态方法的,就不要需要创建这个类的实例了的,因为返回的就是接口类型的的变量.所以也简称为静态工厂的.还可以将构造方法私有化的.

    但是发现;如果要新增一个超高档的小汽车,那么修改的地方就比较多了,扩展性就比较差的.那么我们就来优化这个问题嘛.

    思考一下:实现扩展性比较好通常的做法就是向更高的层次的抽象嘛,一句话直说吧就是将那个简单工厂类变成抽象类或者接口嘛，通常就是这么做的嘛.

        工厂模式

   
4000
  将简单的工厂类变成抽象工厂类换接口是是实现的一个比较通用的思路.然后提供一个创建具体小汽车的抽象方法不就可以啦。

             思路大概是这几个

             1::定制抽象产品接口 ：Car

             2:定制具体的产品子类: TopCar,MidCar,LowCar

             3:定制抽象工厂类:AbstractFactory+careate()抽象方法

             4:定制具体工厂子类：TopFactory，MidFactory,LowFactory

        前面的两步都是相同的就不贴代码啦：

            抽象工厂类代码:

             public abstract class AbstractFactory {

              public abstract Car create();

           }

          高档工厂代码：

          public class TopFactory extends AbstractFactory{

          public Car create(){
  return new TopCar();

        }

      }     

          中档工厂代码:

           public class MidFactory extends AbstractFactory {

           public Car create(){

       return new MidCar();

        }

      }

       抵挡工厂代码:

       public class LowFactory extends AbstractFactory {
           public Car create(){
    
   return new LowCar();
        }
      }

     就是将简单工厂的具体类修改为抽象工厂层+具体工厂类层了.一个比较重要的改变就是现在的工厂模式的create()方法已经是抽象的了,修改扩展起来都是比较方便的.如果需求改变了,我们做的就是增加相应的类或删除相应的类,而不是去修改主类的.对比之下发现都是优于简单工厂的.但是还有发现的就是工厂模式是针对的单一的生产线的,例如这里就是生产小汽车的,如果要是生产公交车,大客车呐？看来还是需要优化的.

        优化的地方还是这个抽象的工厂类,思路之前是分析过的.还是想上一层的抽象的.

       那么就是将抽象工厂类彻底的抽象就可以了,然后就是将具体的工厂子类抽象即可.

       现在新增公共汽车接口:(有高档和中档之分)

       public interface Bus{

      }

       具体的高档公共汽车类

      public class TopBus implements Bus{

     }

       具体中档公交汽车类

      public class MidBus implements Bus{

     }

     高层次的抽象工厂

     public abstract class AbstractFactory{

     }

    定义抽象子工厂1:用于生产具有相同特征的小汽车和公共汽车,例如相同的都有高档的属性就可以使用这个创建一个实现类---TopFactory来是实现属性的汽车生产的.

     public abstract class AbstractFactoryOne extends AbstractFactory{

      public abstract Car create();

      public abstract Bus create();

     }

    定义抽象工厂2：用于生产具有不同特征的小汽车和公共汽车

     public abstract class AbstractoryTwo extends AbstractFactory{

      public abstractory Car create();

     }   

     public abstract class AbstractoryThree extends AbstractFactory{
      public abstractory Bus create();
     }
.    ...
      添加实现类就可以完成想应的功能啦.
     来分析一下这个抽象类的特点.那个最高层次的抽象类就是便于统一管理子类的,没有方法的,表明不同的子类有不同的功能的.理解起来还是可以的吧.

     至于派生的子类抽象工厂就是特征相同的放在一起的,就是高档工厂就是生产高档的汽车的,不会为每个类别的高档汽车都创建一个工厂的,如果那样的,工厂类泛滥是我们不愿意看到的,并且随着类别的增加管理起来会变得很困难的哟的.

     抽象工厂和工厂模式是统一的,就是在类别上做了扩展来应对未来更对的产品系的.最重要的就是根据场景来设计自己的工厂类就可以完成想要的实现.在学习多态的时候就是这样写的,但是这是一种分析问题的策略,更高层次的理解问题的实质吧.介绍了一种解决问题的使用方法.

    这里只是简单的介绍了一下使用的步骤和分析思路.算是开个头吧.后面继续补充吧.