设计模式之简单工厂模式（一）

设计模式之简单工厂模式（一）

通过本实例可以让读者认识到面向对象和设计模式的优美之处，本例通过简单的计算器来进行讲述，想必初学者都会这样编写程序

public class Main {
    public static void main(String[] args) {
        int numberA = 1;
        int numberB = 2;
        String operator = "+";
        int result = 0;

        switch (operator) {
        case "+":
            result = numberA + numberB;
            break;
        case "-":
            result = numberA - numberB;
            break;
        case "*":
            result = numberA * numberB;
            break;
        case "/":
            result = numberB == 0 ? 0 : numberA / numberB;
            break;
        }
        System.out.println(numberA + " " + operator + " " + numberB + " = " + result);
    }
}

可以看出上面的代码从运行的角度来看一点问题也没有，但是从代码的质量上看，没有体现的Java的面向对象的基本要素（封装、继承、多态），即无法体现重用性、扩展性。因此需要代码的重构、封装，将公共部分提炼出来。

public abstract class Operator {
    private int numberA;
    private int numberB;

    public Operator(int numberA, int numberB) {
        super();
        this.numberA = numberA;
        this.numberB = numberB;
    }

    public abstract int operatorResult();

    public int getNumberA() {
        return numberA;
    }

    public void setNumberA(int numberA) {
        this.numberA = numberA;
    }

    public int getNumberB() {
        return numberB;
    }

    public void setNumberB(int numberB) {
        this.numberB = numberB;
    }

}

操作的抽象类Operator将共同的属性numberA和numberB放在一起，并且提取他们的共同的方法，但由于各个操作不同，故此方法为abstract类型的方法，让具体的子类实现

public class PlusOperator extends Operator {

    public PlusOperator(int numberA, int numberB) {
        super(numberA, numberB);
    }

    @Override
    public int operatorResult() {
        return getNumberA() + getNumberB();
    }

}

public class SubtractOperator extends Operator {

    public SubtractOperator(int numberA, int numberB) {
        super(numberA, numberB);
    }

    @Override
    public int operatorResult() {
        return getNumberA() - getNumberB();
    }

}

public class MultiplyOperator extends Operator {

    public MultiplyOperator(int numberA, int numberB) {
        super(numberA, numberB);
    }

    @Override
    public int operatorResult() {
        return getNumberA() * getNumberB();
    }

}

public class DivideOperator extends Operator {

    public DivideOperator(int numberA, int numberB) {
        super(numberA, numberB);
    }

    @Override
    public int operatorResult() {
        return 0 == getNumberB() ? 0 : getNumberA() / getNumberB();
    }

}

以上是加减乘除的具体实现，这样就达到了代码的封装和继承及多态，但是对于客户端，我们要当他们是小白，所以客户单不需要知道是怎么实现的，只要调用我们的方法即可

    public class OperatorFactory {
    public static int getOperatorResult(int numberA, int numberB, String operatorSimbol) {
        Operator operator = null;
        switch (operatorSimbol) {
        case "+":
            operator = new PlusOperator(numberA, numberB);
            break;
        case "-":
            operator = new SubtractOperator(numberA, numberB);
            break;
        case "*":
            operator = new MultiplyOperator(numberA, numberB);
            break;
        case "/":
            operator = new DivideOperator(numberA, numberB);
            break;
        }
        return operator == null ? 0 : operator.operatorResult();
    }
}

这就使用了简单工厂模式，当增加新的需求时，只需要继承Operator类即可，并在OperatorFactory 中追加即可，而无需改变其他的实现类。

public class Main {
    public static void main(String[] args) {
        int result = OperatorFactory.getOperatorResult(22, 90, "*");
        System.out.println(result);
    }
}