一、简单工厂模式
简单工厂模式又称静态工厂方法模式。它存在的目的很简单:将对象的创建过程封装进一个类。
先来看看它的组成:
- 抽象产品类或接口:
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.缺点:
- 扩展性差:产品族难扩展,产品等级易扩展。