今天说说工厂模式吧，以前就想写下的，但是懒啊，也怪不得自己对自己技术失望了，哎。
工厂模式呢，简单的说工厂模式不是一个模式，而是一系列模式，它相当于是一个统称吧，工厂模式包括：工厂方法模式、简单工厂模式、抽象工厂模式。不过这个也不是绝对的吧，因为有些把简单工厂模式规划到工厂方法模式里面了，因为它是工厂方法模式的一个弱化版本，简单工厂模式也有的称为静态工厂模式。
先举个例子来说明三者的大致区别的，具体看后面的具体分析：
假设我现在需要生产汽车（妈的，怎么都是汽车，好多人讲设计模式都是用汽车！我也没法啊~情不自禁啊，谁让汽车是大家都想要的啊，泡妹和装逼的神器啊，咳，正事，主要是汽车的分类好理解些，所以都用汽车）
1.假设生产汽车，我们只生产兰博基尼，所以我们只需要一个工厂就行了，这就是简单工厂模式；
2.现在需要生产两种汽车：兰博基尼和法拉利，假设两种汽车生产所需零件都一样，那么此时就只需要两个工厂，也就是多工厂方法模式，跟简单工厂的区别就是简单工厂只有一个工厂，所以也有说法把简单工厂划为工厂方法模式，因为它是一个工厂方法模式的弱化版，单工厂版；
3.那么问题来了，如果兰博基尼和法拉利生产所需零件不一样，轮胎啊，引擎啊之类不一样，那么此时我们就需要多分出一层了（零件层），因为之前兰博基尼和法拉利生产零件一样，所以不需要分直接一套生产就行，那么现在我们需要生产不同的零件，然后不同的零件合成不同的汽车，不同的汽车又要不同的工厂，这就是抽象工厂模式。
上述工厂模式需要三个模块：
1.抽象产品类；（抽象汽车）
2.具体产品类；（具体汽车类：兰博基尼和法拉利）
3.抽象工厂类；（抽象工厂）
4.具体工厂类；（具体工厂类：兰博基尼工厂和法拉利工厂）
首先来举例说明工厂方法模式（包括简单工厂模式）：
抽象产品类：
package FactoryPattern;
/**
* 抽象产品类
*/
public abstract class Product {
//抽象方法，生产零件组成汽车
public abstract void createProduct();
}具体产品类：
/**
* 产品A，兰博基尼
*/
public class ProductA extends Product{
@Override
public void createProduct() {
// TODO Auto-generated method stub
System.out.println("生产组装成兰博基尼");
}
/**
* 产品B，法拉利
*/
public class ProductB extends Product{
@Override
public void createProduct() {
// TODO Auto-generated method stub
System.out.println("生产组装成法拉利");
}
}抽象工厂类：
/**
*抽象工厂类
*/
public abstract class Factory {
public abstract Product createProduct();
}具体工厂类：
/**
* 工厂类A，具体工厂，生产兰博基尼的工厂
*/
public class FactoryA extends Factory{
@Override
public Product createProduct() {
// TODO Auto-generated method stub
return new ProductA(); //生产兰博基尼
}
}
/**
* 工厂类B，具体工厂，生产法拉利的工厂
*/
public class FactoryB extends Factory{
@Override
public Product createProduct() {
// TODO Auto-generated method stub
return new ProductB(); //生产法拉利
}
}生产汽车：
public class CreateProduct {
public static void main(String[] args){
//构造工厂对象生产汽车
Factory facA = new FactoryA();
facA.createProduct();
Factory facB = new FactoryB();
facB.createProduct();
}
}上述我们构造了两种工厂生产两种汽车，这就是多工厂方法模式，可以看到我们具体化了两种工厂。如果觉得多个工厂写起来麻烦，那么可以用反射来获取类来获取对应的工厂，如下（更改抽象工厂类和具体工厂类）：
/**
*抽象工厂类
*/
public abstract class Factory {
public abstract <T extends Product>T createProduct(Class<T> cl);
}
//具体工厂类，通过传入类型进行创建
public class MyFactory extends Factory{
@Override
public <T extends Product>T createProduct(Class<T> cl) {
// TODO Auto-generated method stub
Product p = null;
try {
p = (Product) Class.forName(cl.getName()).newInstance();
} catch (InstantiationException | IllegalAccessException| ClassNotFoundException e) {
// TODO Auto-generated catch block
e.printStackTrace();
}
return (T)p;
}
}
//生产汽车
public class CreateProduct {
public static void main(String[] args){
//构造工厂对象生产汽车
Factory fac = new MyFactory();
Product proA =fac.createProduct(ProductA.class);
Product proB =fac.createProduct(ProductB.class);
}
}上述都是两个工厂生产两种汽车，假设我们只需要一个工厂，生产一种汽车，那么我们就可以简化下了（不需要抽象工厂类，直接写工厂类生产产品）：
/**
* 省掉抽象工厂类，因为我们只需要一个工厂，写抽象工厂类是因为工厂会有多个而且不同，既然只有一个工厂就可以省略
*/
public class Factory {
public static Product createProduct(){
return new ProductA();
//return new ProductB();
}
}像上述这种方式只有一个工厂，省略了抽象工厂，这种就是所谓的简单工厂模式。
那些复杂的抽象工厂方法模式又是怎样的呢，之前的是因为兰博基尼和法拉利零件啥都一样，所以只需要一个抽象产品类就行了，那么假设兰博基尼和法拉利所用零件不一样咋办，那就需要用抽象工厂模式了。所以我们可以理解为：
工厂方法模式：单抽象产品；
抽象工厂方法模式：多抽象产品；
示例（假设兰博基尼需要普通轮胎+高级引擎，而法拉利需要高级轮胎+普通引擎）：
抽象产品类：
//抽象产品类A，轮胎
public abstract interface ProductA {
void createA();
}
//抽象产品类B，引擎
public abstract interface ProductB {
void createB();
}具体产品类：
//具体产品类，普通轮胎
public class ProAImpOne implements ProductA{
@Override
public void createA() {
// TODO Auto-generated method stub
}
}
//具体产品类，高级轮胎
public class ProAImpTwo implements ProductA{
@Override
public void createA() {
// TODO Auto-generated method stub
}
}
//具体产品类，普通引擎
public class ProBImpOne implements ProductB{
@Override
public void createB() {
// TODO Auto-generated method stub
}
}
//具体产品类，高级引擎
public class ProBImpTwo implements ProductB{
@Override
public void createB() {
// TODO Auto-generated method stub
}
}抽象工厂类：
//抽象工厂类，里面方法是制造用的零件：轮胎和引擎
public abstract interface Factory {
public abstract ProductA createA();
public abstract ProductB createB();
}具体工厂类：
//具体工厂类，法拉利
public class FacFL implements Factory{
@Override
public ProductA createA() { //高级轮胎
// TODO Auto-generated method stub
return null;
}
@Override
public ProductB createB() { //普通引擎
// TODO Auto-generated method stub
return null;
}
}
//具体工厂类，兰博基尼
public class FacLB implements Factory{
@Override
public ProductA createA() { //普通轮胎
// TODO Auto-generated method stub
return new ProAImpOne();
}
@Override
public ProductB createB() { //高级引擎
// TODO Auto-generated method stub
return new ProBImpTwo();
}
}如上所示：抽象产品类有多个，其他用法跟工厂方法模式类似，仅仅区别是在抽象产品不是单一的。可能我说的大家看得不是很明白，具体还得看例子，多看几遍就能明白其中的区别了，本人水平有限，不当之处还请指教哈~
