设计模式--简单工厂模式

简单工厂模式就是由一个工厂对象（Factory）决定创建出哪一种产品类的实例。

需求：模拟一个计算器类

首先定义一个抽象操作符类

package com.sun.FactoryMethod;

public abstract class AbsOperation {
    protected Double _numberA = 0d;
    protected Double _numberB = 0d;

    public Double get_numberA() {
        return _numberA;
    }

    public void set_numberA(Double _numberA) {
        this._numberA = _numberA;
    }

    public Double get_numberB() {
        return _numberB;
    }

    public void set_numberB(Double _numberB) {
        this._numberB = _numberB;
    }

    protected abstract Double GetResult();
}

继承抽象类 实现一个数字相加的抽象方法：

package com.sun.FactoryMethod;

public class OperationAdd extends AbsOperation {

    @Override
    protected Double GetResult() {
        Double result = 0d;
        result = _numberA + _numberB;
        return result;
    }
}

继承抽象类 实现一个数字相减的抽象方法：

package com.sun.FactoryMethod;

public class OperationSub extends AbsOperation {

    @Override
    protected Double GetResult() {
        Double result = 0d;
        result = _numberA - _numberB;
        return result;
    }
}

提供一个工厂类，根据操作符去实例化某个计算实例，这里得到的AbsOperation实际上是他子类的引用（java中子类能强制转换为父类，父类并不能强制转换为子类，除非

父类的引用是指向子类）：

package com.sun.FactoryMethod;

public class OperationFactory {
    public static AbsOperation createOperate(char operate) {
        AbsOperation operation = null;
        switch (operate) {
        case '+':
            operation = new OperationAdd();
            break;
        case '-':
            operation = new OperationSub();
            break;
        default:
            operation = new OperationAdd();
            break;
        }

        return operation;
    }
}

下面是测试类

package com.sun.FactoryMethod;

public class TestOperation {

    public static void main(String[] args) {
        AbsOperation operAdd;
        operAdd = OperationFactory.createOperate('+');
        operAdd._numberA = 1d;
        operAdd._numberB = 2d;
        System.out.println(operAdd.GetResult()); //3.0
        
        AbsOperation operSub;
        operSub = OperationFactory.createOperate('-');
        operSub._numberA = 2d;
        operSub._numberB = 4d;
        System.out.println(operSub.GetResult());//-2.0
    }

}

这里要顺便说一个switch case 语句 这里注意的是switch()的参数在jdk1.7之前是不支持字符串（String）的，现在支持了；

那么如果我在switch case 某一项的时候并没有写break；会发生什么呢？

如果我们的 case '+' 并没有写break，那么他会一直找有break的下一个方法返回；那test返回的结果就是 -1，-2了；

如果是我们的 case '-' 没有break呢，那么他会一直找有break的下一个方法返回；那么他会走到Default：这里如果case '-' 后面再有一个'*'的话，那他就会实例化'*'这一项

的结果，当然我们得保证'*'有break；

那Default呢，他是不需要break的；