一、简单工厂模式
简单工厂模式又称静态工厂方法模式。它存在的目的很简单：将对象的创建过程封装进一个类。
先来看看它的组成：
- 抽象产品类或接口：
public interface Shape {
void draw();
}
- 具体产品类（实现抽象产品接口）
//圆形
public class CircleShape implements Shape {
public CircleShape() {
System.out.println( "CircleShape: created");
}
@Override
public void draw() {
System.out.println( "draw: CircleShape");
}
}
//正方形
public class RectShape implements Shape {
public RectShape() {
System.out.println( "RectShape: created");
}
@Override
public void draw() {
System.out.println( "draw: RectShape");
}
}
//三角形
public class TriangleShape implements Shape {
public TriangleShape() {
System.out.println( "TriangleShape: created");
}
@Override
public void draw() {
System.out.println( "draw: TriangleShape");
}
}
- 工厂类（创建具体产品对象的类）
public class ShapeFactory {
public static final String TAG = "ShapeFactory";
public static Shape getShape(String type) {
Shape shape = null;
if (type.equalsIgnoreCase("circle")) {
shape = new CircleShape();
} else if (type.equalsIgnoreCase("rect")) {
shape = new RectShape();
} else if (type.equalsIgnoreCase("triangle")) {
shape = new TriangleShape();
}
return shape;
}
}
在这个工厂类中通过传入不同的 type 可以得到不同的形状对象，这个就是简单工厂核心的地方了。
- 在 Client 中使用
// 画圆形
Shape shape = ShapeFactory.getShape("circle"); //获得产品
shape.draw(); //使用产品
// 画正方形
Shape shape= ShapeFactory.getShape("rect");
shape.draw();
这就是简单工厂模式（静态工厂模式）。
二、工厂方法模式
工厂方法模式是简单工厂的进一步深化， 在工厂方法模式中，我们不再提供一个统一的工厂类来创建所有的对象，而是抽象出一个工厂创建产品的抽象类，让具体的工厂子类继承工厂抽象类，实现抽象的创建方法，决定要实例化哪些产品。
工厂方法模式和抽象工厂模式的区别在于：工厂方法用继承的方式来让具体的子类实现创建产品的过程，抽象工厂通过对象组合的方式来实现。
定义一个用于创建对象的接口，让子类决定将哪一个产品类实例化。工厂方法模式让一个类的实例化延迟到其子类。这个是关键的思想。
举个栗子：
现在需要设计一个这样的图片加载类，它具有多个图片加载器，用来加载
jpg，png，gif 格式的图片，每个加载器都有一个 load（）方法，用于读取图片。下面我们完成这个图片加载类。
- 抽象产品共同的功能
public interface Loader {
void load();
}
每种图片加载器都有一个 load() 方法。
- 各种实现了产品接口的具体产品——图片加载器
-
Jpg图片加载器
public class JpgLoader implements Loader {
@Override
public void load() {
System.out.print("load jpg");
}
}
-
Png图片加载器
public class PngLoader implements Loader {
@Override
public void load() {
System.out.print("load png");
}
}
-
Gif图片加载器
public class GifLoader implements Loader {
@Override
public void load() {
System.out.print("load gif");
}
}
- 抽象出一个建立产品的工厂接口
LoaderFactory
public interface LoaderFactory {
Loader getLoader();
}
-
4.建立各种具体的子工厂，由这些子工厂决定实现哪些产品
-
Jpg加载器工厂
-
public class JpgLoaderFactory implements LoaderFactory {
@Override
public Loader getLoader() {
return new JpgLoader();
}
}
-
Png加载器工厂
public class PngLoaderFactory implements LoaderFactory {
@Override
public Loader getLoader() {
return new PngLoader();
}
}
-
Gif加载器工厂
public class GifLoaderFactory implements LoaderFactory {
@Override
public Loader getLoader() {
return new GifLoader();
}
}
每个具体的工厂类重写 getLoader() 方法返回各自的图片加载器对象（产品）。
- 在 Client 中使用
- 加载
Jpg
LoaderFactory factory= new JpgLoaderFactory();
Loader loader=factory.getLoader();
loader.load();
- 加载
Png
LoaderFactory factory=new PngLoaderFactory();
Loader loader=factory.getLoader();
loader.load();
- 加载
Gif
LoaderFactory factory=new GifLoaderFactory();
Loader loader=factory.getLoader();
loader.load();
工厂方法模式和简单工厂最根本的区别在于：简单工厂只有一个统一的工厂类，而工厂方法是抽象出一个工厂类，让具体的子类工厂都实现了创建产品的抽象方法。
6.适用场景：
复杂对象的生成，代替 new 的方式来屏蔽产品类的创建过程：需要一种产品，而不想知道也不需要知道工厂是如何生产出来的，只需要知道具体对应的工厂就行。
产品的替换需要灵活、可扩展性高的场合。
测试驱动开发的框架中，往往通过工厂方法把对象虚拟出来（用得比较少）。
Android 中的
Bitmap就是通过工厂方法来创建的。
7.优点：
良好的封装性与解偶。利用工厂的工厂方法类去创建具体的产品对象，隐藏了具体产品对象的创建细节，只需要关心具体产品对应的具体工厂。高层模块只需要关心抽象产品类。
遵守开闭原则，扩展性好。加入新的产品类时，只需要同时加入工厂类就可以实现扩展，无需修改原来的代码。
8.缺点：
- 随着产品种类的数量的增长，工厂类也会随之增加，将不利于系统的维护，增加系统编译和运行的开销。
三、抽象工厂模式
为创建一组相关或相互依赖的对象提供一个接口，而且无须指定它们的具体类。
抽象工厂模式是工厂方法模式的升级版本，在有多个业务品种、业务分类时（产品族——两个互相影响的产品线），通过抽象工厂模式产生需要的对象是一种非常好的解决方式。
- 抽象工厂和工厂方法一样可以划分为4大部分：
Factory（抽象工厂）：声明了一组用于创建对象的方法。
ConcreteFactory（具体工厂）**：它实现了在抽象工厂中声明的创建对象的方法，生成一组具体对象。
Product（抽象产品）：各种抽象的产品接口。
ConcreteProduct（具体产品）：具体工厂生产的具体对象。
举个栗子
现在需要做一款跨部门使用的考核产品，需要兼容 A，B 两个部门(两个工厂)，该考核产品针对每个部门都设计了一套操作控制器 OperationController 和评分控制器 JudgeController（每个工厂需要生产的产品抽象），下面通过抽象工厂方式完成这款产品的架构设计。
- 1.抽象
OperationController接口
public interface OperationController {
void control();
}
- 2.抽象
JudgeController接口
public interface JudgeController {
void judge();
}
3.具体产品实现类
A 部门的具体实现的 2 个产品类
public class APartOperationController implements OperationController {
@Override
public void control() {
System.out.println("APartOperationController");
}
}
public class APartJudgeController implements JudgeController {
@Override
public void judge() {
System.out.println("APartJudgeController");
}
}
- B 部门的具体实现的 2 个产品类
public class BPartOperationController implements OperationController {
@Override
public void control() {
System.out.println("BPartOperationController");
}
}
public class BPartJudgeController implements JudgeController {
@Override
public void judge() {
System.out.println("BPartJudgeController");
}
}
- 4.抽象工厂接口
创建 OperationController 和 JudgeController （若干个产品对象）的方法。
public interface PartFactory {
public OperationController createOperationController();
public JudgeController createJudgeController();
}
5.具体工厂实现类
A 部门工厂
public class APartFactory implements PartFactory {
@Override
public OperationController createOperationController() {
return new APartOperationController();
}
@Override
public JudgeController createJudgeController() {
return new APartJudgeController();
}
}
- B 部门工厂
public class BPartFactory implements PartFactory {
@Override
public OperationController createOperationController() {
return new BPartOperationController();
}
@Override
public JudgeController createJudgeController() {
return new BPartJudgeController();
}
}
- 6.客户端调用
PartFactory mFactory;
JudgeController judgeController;
OperationController operationController;
//如果要使用A部门的功能，初始化 APart
mFactory=new APartFactory();
//如果要使用B部门的功能，初始化 BPart
// mFactory=new BPartFactory();
// 获取A部门的评分功能产品
judgeController = mFactory.createJudgeController();
// 获取A部门的操作功能产品
operationController=mFactory.createOperationController();
judgeController.judge();
operationController.control();
6.适用场景：
- 一个对象族(或是一组没有任何关系的对象)都有相同的约束，例如生成不同操作系统的程序，则可以使用抽象工厂模式。（相对来说用得比较少）
7.优点：
封装性：与工厂方法模式一样，高层模块无需关心产品的具体实现，只需要关心接口。
产品族内的约束为非公开状态，例如可以增加控制产品族之间的比例的功能。
8.缺点：
- 扩展性差：产品族难扩展，产品等级易扩展。
