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

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

需求：模拟一个计算器类

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

 1 package com.sun.FactoryMethod;
 2 
 3 public abstract class AbsOperation {
 4     protected Double _numberA = 0d;
 5     protected Double _numberB = 0d;
 6 
 7     public Double get_numberA() {
 8         return _numberA;
 9     }
10 
11     public void set_numberA(Double _numberA) {
12         this._numberA = _numberA;
13     }
14 
15     public Double get_numberB() {
16         return _numberB;
17     }
18 
19     public void set_numberB(Double _numberB) {
20         this._numberB = _numberB;
21     }
22 
23     protected abstract Double GetResult();
24 }

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

 1 package com.sun.FactoryMethod;
 2 
 3 public class OperationAdd extends AbsOperation {
 4 
 5     @Override
 6     protected Double GetResult() {
 7         Double result = 0d;
 8         result = _numberA + _numberB;
 9         return result;
10     }
11 }

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

 1 package com.sun.FactoryMethod;
 2 
 3 public class OperationSub extends AbsOperation {
 4 
 5     @Override
 6     protected Double GetResult() {
 7         Double result = 0d;
 8         result = _numberA - _numberB;
 9         return result;
10     }
11 }

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

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

 1 package com.sun.FactoryMethod;
 2 
 3 public class OperationFactory {
 4     public static AbsOperation createOperate(char operate) {
 5         AbsOperation operation = null;
 6         switch (operate) {
 7         case '+':
 8             operation = new OperationAdd();
 9             break;
10         case '-':
11             operation = new OperationSub();
12             break;
13         default:
14             operation = new OperationAdd();
15             break;
16         }
17 
18         return operation;
19     }
20 }

下面是测试类

 1 package com.sun.FactoryMethod;
 2 
 3 public class TestOperation {
 4 
 5     public static void main(String[] args) {
 6         AbsOperation operAdd;
 7         operAdd = OperationFactory.createOperate('+');
 8         operAdd._numberA = 1d;
 9         operAdd._numberB = 2d;
10         System.out.println(operAdd.GetResult()); //3.0
11         
12         AbsOperation operSub;
13         operSub = OperationFactory.createOperate('-');
14         operSub._numberA = 2d;
15         operSub._numberB = 4d;
16         System.out.println(operSub.GetResult());//-2.0
17     }
18 
19 }

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

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

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

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

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

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