设计模式（三）之 工厂模式

一、简单工厂模式

  1. 简单工厂模式又称静态工厂方法模式。它存在的目的很简单：将对象的创建过程封装进一个类。

  2. 先来看看它的组成：

  1. 抽象产品类或接口：
public interface Shape {
    void draw();
}
  1. 具体产品类（实现抽象产品接口）
//圆形
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");
    }

}
  1. 工厂类（创建具体产品对象的类）
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 可以得到不同的形状对象，这个就是简单工厂核心的地方了。

  1. 在 Client 中使用
// 画圆形
Shape shape = ShapeFactory.getShape("circle");  //获得产品
 shape.draw(); //使用产品
 
// 画正方形
Shape shape= ShapeFactory.getShape("rect");
shape.draw();

这就是简单工厂模式（静态工厂模式）。

二、工厂方法模式

工厂方法模式是简单工厂的进一步深化， 在工厂方法模式中，我们不再提供一个统一的工厂类来创建所有的对象，而是抽象出一个工厂创建产品的抽象类，让具体的工厂子类继承工厂抽象类，实现抽象的创建方法，决定要实例化哪些产品。

工厂方法模式和抽象工厂模式的区别在于：工厂方法用继承的方式来让具体的子类实现创建产品的过程，抽象工厂通过对象组合的方式来实现。

工厂方法模式

定义一个用于创建对象的接口，让子类决定将哪一个产品类实例化。工厂方法模式让一个类的实例化延迟到其子类。这个是关键的思想。

举个栗子：

现在需要设计一个这样的图片加载类，它具有多个图片加载器，用来加载
jpg，png，gif 格式的图片，每个加载器都有一个 load（）方法，用于读取图片。下面我们完成这个图片加载类。

  1. 抽象产品共同的功能
public interface Loader {
    void load();
}

每种图片加载器都有一个 load() 方法。

  1. 各种实现了产品接口的具体产品——图片加载器
  • 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");
    }
}
  1. 抽象出一个建立产品的工厂接口 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() 方法返回各自的图片加载器对象（产品）。

  1. 在 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.缺点：

  • 扩展性差：产品族难扩展，产品等级易扩展。

参考资料

工厂模式——看这一篇就够了
23种设计模式（2）：工厂方法模式

最后编辑于 ：
©著作权归作者所有,转载或内容合作请联系作者
平台声明：文章内容（如有图片或视频亦包括在内）由作者上传并发布，文章内容仅代表作者本人观点，简书系信息发布平台，仅提供信息存储服务。

推荐阅读更多精彩内容

  • 重学设计模式之工厂模式
    工厂模式是最常用的一类创建型设计模式，之前一直以为工厂模式只是23中设计模式中的一种，重新了解才知道这个模式还要细...
    晨鸣code阅读 5,049评论 0赞 6
  • 设计模式汇总
    设计模式汇总 一、基础知识 1. 设计模式概述 定义：设计模式（Design Pattern）是一套被反复使用、多...
    MinoyJet阅读 9,379评论 1赞 15
  • 设计模式之工厂模式总结
    1. 工厂方法模式 使用场景 工厂方法模式是new一个对象的替代品，所以在所有需要生成对象的地方都可以使用，到那时...
    niaoge2016阅读 2,744评论 0赞 1
  • 设计模式之工厂模式
    “工厂”这种设计模式可能是最广为人知的模式之一了。其看起来最为简单，读起来也是郎朗上口。每次面试，让应聘者讲几种设...
    月落蝶殇阅读 3,418评论 1赞 0
  • 设计模式之工厂模式
    客户需求 程序设计 1、PizzaStore是用来给客户下订单买pizza的，所以每个PizzaStore都会有一...
    BlainPeng阅读 3,590评论 0赞 2