java设计模式之简单工厂模式

该模式我们以计算器的计数算法为例子：

同样，如果我们不知道设计模式的话，我们要写一个加减乘除的计算器我们要怎么做？当然，这很简单

public static void main(String args[]) {
        Scanner scn = new Scanner(System.in);
        System.out.print("第一个数：");
        int a = scn.nextInt();
        System.out.print("操作(+,-,*,/)：");
        String option = scn.next();
        System.out.print("第二个数：");
        int b = scn.nextInt();
        int result = 0;
        if ("+".equals(option)) {
            result = a + b;
        }
        if ("-".equals(option)) {
            result = a - b;
        }
        if ("*".equals(option)) {
            result = a * b;
        }
        if ("/".equals(option)) {
            result = a / b;
        }
        System.out.println("结果：" + result);
}

可是呢，如果我们要增加计算器的算法功能，比如说加个开根号的算法，要怎么做，再加个判断条件吗，这样子的话就耦合度不高了。程序的设计原则不就是高内聚，低耦合吗。以及面向对象的的三大特点：封装、继承、多态。

知道了这些之后，我们再看看用简单工厂模式下，如何完成此操作：

/**
 * 计算器类
 * Created by HDL on 2016/11/30.
 */
public class Optioner {
    private int oNumFirst;//第一个数
    private int oNumSecond;//第二个数
    public int getoNumFirst() {
        return oNumFirst;
    }
    public void setoNumFirst(int oNumFirst) {
        this.oNumFirst = oNumFirst;
    }
    public int getoNumSecond() {
        return oNumSecond;
    }
    public void setoNumSecond(int oNumSecond) {
        this.oNumSecond = oNumSecond;
    }
    public Optioner() {
    }
    public Optioner(int oNumFirst, int oNumSecond) {
        this.oNumFirst = oNumFirst;
        this.oNumSecond = oNumSecond;
    }
    public int getReuslt() {
        return 0;
    }
}

/**
 * 加法运算
 * Created by HDL on 2016/11/30.
 */
public class AddOptioner extends Optioner {
    @Override
    public int getReuslt() {
        return getoNumFirst() + getoNumSecond();
    }
}
/**
 * 减法运算
 * Created by HDL on 2016/11/30.
 */
public class SubOptioner extends Optioner {
    @Override
    public int getReuslt() {
        return getoNumFirst() - getoNumSecond();
    }
}
/**
 * 乘法运算
 * Created by HDL on 2016/11/30.
 */
public class MulOptioner extends Optioner {
    @Override
    public int getReuslt() {
        return getoNumFirst() * getoNumSecond();
    }
}
/**
 * 除法运算
 * Created by HDL on 2016/11/30.
 */
public class DivOptioner extends Optioner {
    @Override
    public int getReuslt() {
        if (getoNumSecond() == 0) {
            System.out.println("除数不能为0");
            return -1;
        } else {
            return getoNumFirst() / getoNumSecond();
        }
    }
}

/**
 * optioner工厂类
 * Created by HDL on 2016/11/30.
 */
public class OptionerFactory {
    public static Optioner createOptioner(String opt) {
        Optioner optioner = null;
        switch (opt) {
            case "+":
                optioner = new AddOptioner();
                break;
            case "-":
                optioner = new SubOptioner();
                break;
            case "*":
                optioner = new MulOptioner();
                break;
            case "/":
                optioner = new DivOptioner();
                break;
        }
        return optioner;
    }
}

public static void main(String args[]) {
        Scanner scn = new Scanner(System.in);
        System.out.print("请输入第一个数:");
        int oNumFirst = scn.nextInt();
        System.out.print("请输入操作方式(+,-,*,/):");
        String opt = scn.next();
        System.out.print("请输入第二个数:");
        int oNumSecond = scn.nextInt();
        Optioner optioner = OptionerFactory.createOptioner(opt);
        optioner.setoNumFirst(oNumFirst);
        optioner.setoNumSecond(oNumSecond);
        System.out.println("结果为：" + optioner.getReuslt());
    }

对于添加开根号功能，直接增加开根号的类并继承Optioner类，在工厂类加上分支判断即可，业务的增加不会影响视图层的功能，大大降低了代码之间的耦合性。 简单工厂模式是属于创建型模式，又叫做静态工厂方法（Static Factory Method）模式，但不属于23种GOF设计模式之一。简单工厂模式是由一个工厂对象决定创建出哪一种产品类的实例。简单工厂模式是工厂模式家族中最简单实用的模式，可以理解为是不同工厂模式的一个特殊实现。