二十三种设计模式之简单工厂模式

JAVA的设计模式大体上分为三大类：

 

创建型模式（5种）：工厂方法模式，抽象工厂模式，单例模式，建造者模式，原型模式。

结构型模式（7种）：适配器模式，装饰器模式，代理模式，外观模式，桥接模式，组合模式，享元模式。

行为型模式（11种）：策略模式、模板方法模式、观察者模式、迭代子模式、责任链模式、命令模式、备忘录模式、状态模式、访问者模式、中介者模式、解释器模式。

设计模式遵循的原则有6个：

1、开闭原则（Open Close Principle）

        对扩展开放，对修改关闭。

2、里氏代换原则（Liskov Substitution Principle）

　　只有当衍生类可以替换掉基类，软件单位的功能不受到影响时，基类才能真正被复用，而衍生类也能够在基类的基础上增加新的行为。

3、依赖倒转原则（Dependence Inversion Principle）

　　这个是开闭原则的基础，对接口编程，依赖于抽象而不依赖于具体。

4、接口隔离原则（Interface Segregation Principle）

　　使用多个隔离的借口来降低耦合度。

5、迪米特法则（最少知道原则）（Demeter Principle）

　　一个实体应当尽量少的与其他实体之间发生相互作用，使得系统功能模块相对独立。

6、合成复用原则（Composite Reuse Principle）

　　原则是尽量使用合成/聚合的方式，而不是使用继承。继承实际上破坏了类的封装性，超类的方法可能会被子类修改。

 

今天首先要介绍的就是简单工厂模式（以实现一个简单计算功能为例）。

做法一：

package com.wmy.designpattern.FactoryMethodPattern;/** * 简单工厂模式 */public class Operation {    /**     * @Description:     * 使用此种方法时，如果后面还需要加一个运算方法就需要把之前的在编译一次，     * 还很有可能在修改的过程中影响到之前的运算方法。     * @Param: numberA     * @Param: numberB     * @Param: operate     * @return: Double     * @Author: wmy     * @Date: 2019/10/7 9:00     */    public static Double GetResult(Double numberA, Double numberB, String operate) {        Double result = 0d;        switch (operate) {            case "+":                result = numberA + numberB;                break;            case "-":                result = numberA - numberB;                break;            case "*":                result = numberA * numberB;                break;            case "/":                result = numberA / numberB;                break;        }        return result;    }​    public static void main(String[] args) {        double res = GetResult(2d, 6d, "-");        System.out.println("结果是：" + res);    }}

这种方法我们只使用了面向对象三大特性中的封装。如果使用这种方法，我们在增加一个新的运算就需要在Operation类中进行修改并让其他的运算都要在编译一次，也很可能会导致其他功能变化。

 

做法二：

我们先创建一个运算类

package com.wmy.designpattern.FactoryMethodPattern;import lombok.Data;/** * @program: 单独定义一个运算类，在针对不容的操作类型定义不同的操作类， * 这样实现了松耦合，各个操作之间互不影响 * @description: 运算类 * @author: wmy * @create: 2019-10-07 09:09 **/@Datapublic class Operate {    private Double numberA = 0d;    private Double numberB = 0d;    private Double result = 0d;    // 定义一个对外开发的获取运算结果的方法    public Double getResult() {        return this.result;    }}

在分别创建加减乘除类

package com.wmy.designpattern.FactoryMethodPattern;/** * @program: 继承父类 Operate ，重写父类中的getResult()实现具体的计算规则 * @description: 加法操作 * @author: wmy * @create: 2019-10-07 09:14 **/public class OperateAdd extends Operate {    /**     * @Description:  重写获取结果方法，对每种操作类型进行不同结果计算     * @return: Double     * @Author: wmy     * @Date: 2019/10/7 9:20     */    @Override    public Double getResult() {        return getNumberA() + getNumberB();    }}​​​​package com.wmy.designpattern.FactoryMethodPattern;/** * @program: design pattern * @description: 减法操作 * @author: wmy * @create: 2019-10-07 09:17 **/public class OperateSub extends Operate {    @Override    public Double getResult() {        return getNumberA() - getNumberB();    }}​​​​package com.wmy.designpattern.FactoryMethodPattern;/** * @program: design pattern * @description: 乘法操作 * @author: wmy * @create: 2019-10-07 09:18 **/public class OperateMul extends Operate {    @Override    public Double getResult() {        return getNumberA() * getNumberB();    }}​​​​package com.wmy.designpattern.FactoryMethodPattern;/** * @program: design pattern * @description: 除法操作 * @author: wmy * @create: 2019-10-07 09:19 **/public class OperateDiv extends Operate {    @Override    public Double getResult() {        if (getNumberB()==0)            throw new IllegalArgumentException("除数不能为0");        return getNumberA() / getNumberB();    }}

创建以上几个类之后，现在我们只需要关注如何来实例化这些对象，

这就需要我们来创建一个简单工厂运算类来实现这个实例化过程

package com.wmy.designpattern.FactoryMethodPattern;​/** * @program: design pattern * @description: 简单运算工厂类 * @author: wmy * @create: 2019-10-07 09:23 **/public class OperateFactory {    /**     * @Description: 现在是需要根据运算符实例化对应的对象，通过多态返回父类的方式获取计算结果     * 就算后面要增加其他的运算只需要增加相应的计算类在继承Operate父类就可以，不会影响其他的程序     * @Param:  operate     * @return:  Operate     * @Author: wmy     * @Date: 2019/10/7 9:26     */    public static Operate createOperate(String operate) {        Operate oper = null;        switch (operate) {            case "+":                oper = new OperateAdd();                break;            case "-":                oper = new OperateSub();                break;            case "*":                oper = new OperateMul();                break;            case "/":                oper = new OperateDiv();                break;        }        return oper;    }    public static void main(String[] args) {        // 我们只需要根据运算符号，工厂就会实例化对应的对象，通过多态返回        // 父类的方式实现计算结果        Operate operate = createOperate("*");        operate.setNumberA(2d);        operate.setNumberB(7d);        System.out.println(operate.getResult());    }}

通过以上的方式，即使我们后面需要修改计算规则只需要在对应的操作类中进行修改，互不影响。

​

对于简单工厂模式就介绍到这里，下期分享《二十三种设计模式之策略模式​》