设计模式之 工厂模式的理解

工厂模式其实在java中用到的还是比较常见的，因为工厂模式个人认为十分契合java面向对象编程的原理，具体来说，

工厂模式是什么 ：

工厂通过对外暴露出接口，然后你只需要通过工厂来拿到你所需要的对象。这样做的好处有两点，

1.你不需要去关注对象具体怎么实现的，你只要直接得到就行；

2. 降低耦合度。 在你的代码中不必直接与用到的对象发生关系，便于后期的维护。假如对象需要作出改变，那与你现在的业务代码也不必直接冲突，便于降低耦合，易于代码的分工开发与后期的维护。

举个例子说明下：

假如我想喝饮料了，咱们最直接的想法是，我去商店买饮料，而不是我去买原料然后制作饮料。这里的商店就是指的是工厂，而我想喝饮料 就是指的是我在coding时需要的新的对象。

 

 

工厂模式分类：

其实只有三种：   工厂方法模式，简单工厂模式 ，抽象工厂模式 

第二种基于第一种基础上简化，第三种基于第一种基础上复杂化。

 

1.工厂方法模式：

 

普通工厂模式 就是这样的，有专门的可乐饮料商店，有专门的雪碧饮料商店；

我想要哪个饮料就去对应的商店买。

先上代码 ： 

代码主要分为4块 ，产品抽象类（饮料类），产品具体类（可乐饮料类 雪碧饮料类），工厂抽象类（饮料工厂） ，工厂具体类 （可乐饮料工厂 ，雪碧饮料工厂）

产品抽象类（饮料类）：

/**
 * FileName: Drink
 * Author:   Administrator
 * Date:     2019/5/30 0030 下午 4:52
 * Description: 所有饮料的父类
 
 */
package moshi;

public class Drink {
    public void say(){
        System.out.println("所有的饮料和女人一样都是水做的");
    }
}

产品具体类（可乐饮料类 雪碧饮料类）:

/**
 * Copyright (C), 2015-2019, XXX有限公司
 * FileName: spriteDrinke
 * Author:   Administrator
 * Date:     2019/5/30 0030 下午 5:01
 * Description: 雪碧饮料
  
 */
package moshi;

public class spriteDrinke extends Drink {
    @Override
    public void say() {
        System.out.println("我是雪碧 -- 喝进去满嘴放炮");
    }
}




/**
 * Copyright (C), 2015-2019, XXX有限公司
 * FileName: cokeDrinke
 * Author:   Administrator
 * Date:     2019/5/30 0030 下午 4:55
 * Description: 可乐饮料
 */
package moshi;

public class cokeDrinke extends Drink{
    @Override
    public void say() {
        System.out.println("我是可口可乐~~~~灰不溜的 还挺好喝");
    }
}

  工厂抽象类（饮料工厂） ：

package moshi;

/**
 *
 * 〈这是饮料商店的接口〉
 *
 * @author Administrator
 * @create 2019/5/30 0030
 * @since 1.0.0
 */

public interface inteFactory {
    Drink creatDrink();
}

工厂具体类 （可乐饮料工厂 ，雪碧饮料工厂）：

/**
 * Copyright (C), 2015-2019, XXX有限公司
 * FileName: sprintFactory
 * Author:   Administrator
 * Date:     2019/5/30 0030 下午 5:04
 * Description: 雪碧工厂
 
 */
package moshi;

public class sprintFactory implements  inteFactory {
    @Override
    public spriteDrinke creatDrink() {
        return new spriteDrinke();
    }
}


/**
 * Copyright (C), 2015-2019, XXX有限公司
 * FileName: cokeFactory
 * Author:   Administrator
 * Date:     2019/5/30 0030 下午 5:03
 * Description: 可口可乐工厂
 */
package moshi;

public class cokeFactory implements  inteFactory {
    @Override
    public cokeDrinke creatDrink() {
        return new cokeDrinke();
    }
}

测试类 ：

/**
 * Copyright (C), 2015-2019, XXX有限公司
 * FileName: mainTest
 * Author:   Administrator
 * Date:     2019/5/30 0030 下午 12:06
 */
package moshi;

public class mainTest {
 
public static void main(String[] args) {
   cokeFactory cf = new cokeFactory();
   sprintFactory sf = new sprintFactory();

   //  我想要一个 可乐
    Drink cd = cf.creatDrink();
    cd.say();
    //  我想要一个 雪碧
    Drink sp = sf.creatDrink();
    sp.say();
}
}

2.简单工厂模式:

/**
 * Copyright (C), 2015-2019, XXX有限公司
 * FileName: drinkSimpleFactory
 * Author:   Administrator
 * Date:     2019/5/30 0030 下午 6:15
 * Description: 简单工厂模式
 
 */
package moshi;

public class drinkSimpleFactory  {

    public  static cokeDrinke  createCokeDrink(){
        return new cokeDrinke();
    }
    public  static spriteDrinke  createspriteDrinke(){
        return new spriteDrinke();
    }
}

从demo里我们看到，或许这只是单纯的把new 对象这个功能简单的封装到了工厂类里，从代码两种没有看到啥特别的优点，但是 其实个人理解，工厂模式作为创建模式的一种，他更好的将我们的降低耦合，隐藏了创建过程的复杂度，我们专注的是做好我们的业务逻辑功能的实现，其他的我们可以不做的就尽量交给其他处理，而现实中实际接触到的，比较典型的用例就是 spring 的控制反转。

 3. 抽象工厂模式

抽象工厂模式不同于以上两者的地方就是在于，每个工厂不在单纯的生产某一个产品，生产的是一类产品组，比如可乐工厂生产的有罐装的可乐，还有瓶装的可乐。是所有可乐这个大类下的所有产品族。

----

后话，没有任何一种模式是完美无缺的，当他降低耦合的时候，可能代码就多了；

然后在项目中，框架中我们肯定碰到这种模式，比如数据库的配置，我们通过一个简单的json配置文件的简单修改，然后框架可以通过xml对应的映射，然后改变数据库的连接和相关属性；那么这就是一种 配置文件 + 反射机制+ 工厂模式 搞定的。

 

~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~·华丽的分割线~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~

 水平有限，不足之处 还望不吝指出 感激感激在感激！