静态工厂设计模式是创建型设计模式。
设计意图：实例化出我们须要的类对象。这些对象能够实现不同的功能，也可能仅仅实现一个功能！
类图关系：
通过类图关系我们能够看到静态工厂负责创建OperationFather类的对象。我们来看一下实例代码。
我们是想实现一个计算器，计算器的功能临时有加法、减法功能。以后可能随时添加新的功能如乘法、除法等。假设使用一般的做法，实际上我们写一个类就能够实现。
package com.factory.staticfactory;
/**
* @author gaoxu
* 实践出真知！
*/
public class Operation {
/**
* @author gaoxu
* @param args
*/
public static void main(String[] args) {
//定义变量
//获取传入的參数
//推断传入的计算类型
if("".equals("+")){
}else if("".equals("-")){
}
//输出计算结果
}
}
大家看一下这个实现，主要的功能肯定是实现了，可是好像扩展性非常差，假设我们须要加一个乘法，那仅仅能改动if语句添加条件，假设不断添加新的计算功能，那么这个类就不能维护了，什么样的方式才干让代码美丽，功能扩展灵活。维护方便呢？
面向对象编程能够实现，首先我们须要封装计算的实现、其次我们须要解耦数据获取设置与计算的逻辑、还要考虑添加功能方便快捷。这几点实现了，我们也就能够实现代码美丽。功能扩展灵活、代码维护方便的几个需求了。
首先我们把计算进行封装，我们把数据处理放到父类中把计算放到不同的子类中。
package com.factory.staticfactory;
/**
* @author gaoxu
* 实践出真知！
*/
public class OperationFather {
double numA = 0;
double numB = 0;
public double getNumA() {
return numA;
}
public void setNumA(double numA) {
this.numA = numA;
}
public double getNumB() {
return numB;
}
public void setNumB(double numB) {
this.numB = numB;
}
public double getResult() {
// TODO Auto-generated method stub
return 0;
}
}
package com.factory.staticfactory; /** * @author gaoxu * 实践出真知！加法 */ public class OperationAdd extends OperationFather{ @Override public double getResult(){ double result=0; result = numA +numB; return result; } }
package com.factory.staticfactory;
/**
* @author gaoxu
* 实践出真知。减法
*/
public class OperationSub extends OperationFather{
@Override
public double getResult(){
double result=0;
result = numA -numB;
return result;
}
}
我们看到上面三个类，有一个父类负责设置数据，并提供了计算的方法。
以下的两个子类一个加法类、一个减法类，它们各个实现自己的业务逻辑（重写了父类的方法），这样做的优点是，每添加一个功能点都不会改动到别的功能的代码。
我们如今做的就是要依据用户的须要创建出不同的功能产品来，这时能够使用静态工厂了，来看工厂类的实现。
package com.factory.staticfactory;
/**
* @author gaoxu
* 实践出真知！
*/
public class StaticFactory {
public static OperationFather getOperationByType(String type){
OperationFather operation = null;
if("+".equals(type)){
operation = new OperationAdd();
}else if("-".equals(type)){
operation = new OperationSub();
}
return operation;
}
}
大家看到了。我们把运行什么操作的推断挪到了工厂的方法里了。我们使用工厂封装了创建对象的过程，静态方法的功能就是依据传入的參数来创建不同功能的实例对象。
创建对象也实现了。那么再来看怎样调用吧！
package com.factory.staticfactory;
/**
* @author gaoxu
* 实践出真知。
*/
public class StaticFactoryClient {
public static void main(String[] para){
StaticFactory factory = new StaticFactory();
String operatType = "-";
OperationFather operate = factory.getOperationByType(operatType);
if(operate!=null){
operate.setNumA(1);
operate.setNumB(5);
System.out.println("两数相"+operatType+",结果例如以下："+operate.getResult());
}else{
System.out.println("操作类创建失败。");
}
}
}
我们能够看到client的代码也相当简洁，并且能够非常明白知道这个类要干什么，根本不用关心是由谁来干。
（这一点由功能来决定要哪个对象来干）
由以上代码我们能够看出：
client--工厂类--计算实现类
这三块的关系，各自有自己要做的业务，耦合性极低，功能扩展性增强，假设添加新的功能仅仅须要实现一个计算类。改动工厂静态方法的推断逻辑，由此我们实现了代码简洁、功能扩展灵活、维护方便的需求。
什么场景下适合使用工厂模式创建：
1：对象须要非常复杂的创建过程，在client创见过于负责。
2：不同的对象能够实现不同功能，须要有非常强的扩展需求时。
我们把对象的创建交给工厂类来实现。有例如以下长处（相对于不使用工厂的实现来说）：
1：创建产品的过程被封装起来，通过必要的逻辑推断实现动态实例化相关的类对象。精简client的代码，去除了client与详细产品的依赖。
2：能够有效解耦，client和详细实现功能的类之间没有直接的创建耦合关系。
3：能够非常好的复用功能，灵活的加入功能，加入产品仅仅须要改动工厂逻辑和加产品实现类。