工厂设计模式分为3种：简单工厂、工厂方法、抽象工厂。
一. 什么是工厂设计模式
二.简单工厂
定义：一个工厂方法，依据传入的参数，生成对应的产品对象；
角色：
- 1、抽象产品
- 2、具体产品
- 3、具体工厂
- 4、产品使用者
使用说明：先将产品类抽象出来，比如，苹果和梨都属于水果，抽象出来一个水果类Fruit，苹果和梨就是具体的产品类，然后创建一个水果工厂，分别用来创建苹果和梨；代码如下：
水果接口
public interface Fruit {
void whatIm();
}
具体类 苹果
public class Apple implements Fruit {
@Override
public void whatIm() {
//苹果
}
}
具体类 梨
public class Pear implements Fruit {
@Override
public void whatIm() {
//梨
}
}
具体工厂 水果工厂
public class FruitFactory {
public Fruit createFruit(String type) {
if (type.equals("apple")) {//生产苹果
return new Apple();
} else if (type.equals("pear")) {//生产梨
return new Pear();
}
return null;
}
}
产品使用
FruitFactory mFactory = new FruitFactory();
Apple apple = (Apple) mFactory.createFruit("apple");//获得苹果
Pear pear = (Pear) mFactory.createFruit("pear");//获得梨
还可以进行改造，采用反射：
public Fruit createFruit(Class<? extends Fruit>fruit){ try { if(fruit!=null){ return fruit.newInstance(); } } catch (Exception e) { e.printStackTrace(); } return null; }
就这样，一个非常简单的工厂设计模式就完成了，但是有没有发现什么问题呢？
对，那就是如果我想吃香蕉，想吃橘子呢，我万一什么都想吃呢？？所以，以上的这种方式，每当我想添加一种水果，就必然要修改工厂类，这显然违反了开闭原则，亦不可取；所以简单工厂只适合于产品对象较少，且产品固定的需求，对于产品变化无常的需求来说显然不合适；所以我们来看下一种方式；
note:开闭原则：开闭原则（OCP）是面向对象设计中“可复用设计”的基石，是面向对象设计中最重要的原则之一，其它很多的设计原则都是实现开闭原则的一种手段。对于扩展是开放的，对于修改是关闭的，这意味着模块的行为是可以扩展的。当应用的需求改变时，我们可以对模块进行扩展，使其具有满足那些改变的新行为。也就是说，我们可以改变模块的功能。对模块行为进行扩展时，不必改动模块的源代码或者二进制代码。模块的二进制可执行版本，无论是可链接的库、DLL或者.EXE文件，都无需改动。
三.工厂方法
定义：将工厂提取成一个接口或抽象类，具体生产什么产品由子类决定；
角色：
- 抽象产品类
- 具体产品类
- 抽象工厂类
- 具体工厂类（区别简单工厂）
使用说明：和上例中一样，产品类抽象出来，这次我们把工厂类也抽象出来，生产什么样的产品由子类来决定；
代码如下：
水果接口 苹果类和梨类 代码和上例一样
工厂接口
public interface FruitFactory {
Fruit createFruit();//生产水果
}
苹果工厂
public class AppleFactory implements FruitFactory {
@Override
public Fruit createFruit() {
return new Apple();
}
}
梨工厂
public class PearFactory implements FruitFactory {
@Override
public Fruit createFruit() {
return new Pear();
}
}
使用
AppleFactory appleFactory = new AppleFactory();
PearFactory pearFactory = new PearFactory();
Apple apple = (Apple) appleFactory.createFruit();//获得苹果
Pear pear = (Pear) pearFactory.createFruit();//获得梨
以上这种方式，虽然解耦了，也遵循了开闭原则，但是问题根本还是没有解决啊，换汤没换药，如果我需要的产品很多的话，需要创建非常多的工厂，所以这种方式的缺点也很明显；
四.抽象工厂
定义：为创建一组相关或者是相互依赖的对象提供的一个接口，而不需要指定它们的具体类。
角色：和工厂方法一样
抽象工厂和工厂方法的模式基本一样，区别在于，工厂方法是生产一个具体的产品，而抽象工厂可以用来生产一组相同，有相对关系的产品；重点在于一组，一批，一系列；
举个例子：
假设目前你的程序里面有两个对象，苹果(apple)和香蕉(banana),那么你使用工厂模式就已经足够了，因为她们属于同一个品类，都属于水果，如果在添加一个菠萝产品，也只需要把菠萝加入到你的
水果工厂里面就够了。
但是如果你程序里面有四个对象，苹果汁，苹果派，香蕉汁，香蕉派，这四个对象正好有明确的层级关系，可以抽象为两个层级，苹果，香蕉，或者果汁，派。这时候你怎么来创建这些对象呢？这时候工厂模式明显已经不适用了，因为工厂模式是对象都实现了同一个接口，这时候就可以使用抽象工厂模式了。
具体怎么做呢？
就是把对象抽象一下，把这四个对象抽象为两个接口，一个果汁接口，一个派的接口。
然后再设计一个抽象的工厂（抽象类）abstractFactory，里面生产抽象的对象（也就是接口）Juice，Pie，单看这个结构就是一个工厂模式，但是我们要用生产的是对象而不是接口。
所以我们还需要两个具体工厂：
一个AppleFactory继承abstractFactory，实现生成Pie的方法和生成Juice的方法，实际上就是生成对象AppleJuice和ApplePie，
一个BananaFactory继承abstractFactory，实现生成Pie的方法和生成Juice的方法，实际上就是生成对象BananaJuice和BananaPie，
这样的话，对于调用者来说，我在开发过程中，只需要知道我操作的对象是Pie或者是Juice就够了，这样降低了耦合。
下面看下代码，首先是调用点。
package abstractFactory; /** * Created by songjian on 3/30/2016. */ public class Test { public static void main(String args[]){ AbstractFactory factory1 = new AppleFactory(); factory1.createJuice().desc(); factory1.createPie().desc(); //假设我们之前需要的是applePie和appleJuice对象，现在需要换成bananaPie和BananaJuice对象 //我们只需要替换对应的实现工厂（把new AppleFactory换成new BananFactory就可以了，耦合比较低） AbstractFactory factory2 = new BananaFactory(); factory2.createJuice().desc(); factory2.createPie().desc(); } }
下面是抽象工厂，生产对象的抽象。
package abstractFactory; /** * Created by songjian on 3/29/2016. */ public abstract class AbstractFactory { abstract Juice createJuice(); abstract Pie createPie(); }
下面是具体工厂两个
package abstractFactory; /** * Created by songjian on 3/29/2016. */ public class AppleFactory extends AbstractFactory{ @Override Juice createJuice() { return new AppleJuice(); } @Override Pie createPie() { return new ApplePie(); } }
package abstractFactory; /** * Created by songjian on 3/29/2016. */ public class BananaFactory extends AbstractFactory{ @Override Juice createJuice() { return new BananaJuice(); } @Override Pie createPie() { return new BananaPie(); } }
下面是对象抽象出来的接口两个
package abstractFactory; /** * Created by songjian on 3/29/2016. */ public interface Juice { public void desc(); }
package abstractFactory; /** * Created by songjian on 3/29/2016. */ public interface Pie { public void desc(); }
package abstractFactory; /** * Created by ken on 1/29/2016. */ public class AppleJuice implements Juice { @Override public void desc() { System.out.println("苹果汁."); } }
package abstractFactory; /** * Created by ken on 1/29/2016. */ public class ApplePie implements Pie { @Override public void desc() { System.out.println("苹果派"); } }
package abstractFactory; /** * Created by ken on 1/29/2016. */ public class BananaJuice implements Juice { @Override public void desc() { System.out.println("香蕉汁."); } }
package abstractFactory; /** * Created by ken on 1/29/2016. */ public class BananaPie implements Pie { @Override public void desc() { System.out.println("香蕉派"); } }
五. 总结对比
1、对于简单工厂和工厂方法来说，两者的使用方式实际上是一样的，如果对于产品的分类和名称是确定的，数量是相对固定的，推荐使用简单工厂模式；
2、抽象工厂用来解决相对复杂的问题，适用于一系列、大批量的对象生产；