设计模式之 工厂模式的理解
工厂模式其实在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对应的映射，然后改变数据库的连接和相关属性；那么这就是一种 配置文件 + 反射机制+ 工厂模式 搞定的。
~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~·华丽的分割线~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
水平有限，不足之处 还望不吝指出 感激感激在感激！