设计模式之 Factory(工厂模式)通俗理解

1 工厂模式定义

提供创建对象的接口。

2 为什么工厂模式是如此常用？

因为工厂模式就相当于创建实例对象的 new，我们经常要根据类 Class 生成实例对象，如 A a=new A() 工厂模式也是用来创建实例对象的，所以以后new 时就要多个心眼，是否可以考虑实用工厂模式，虽然这样做，可能多做一些工作，但会给你系统带来更大的可扩展性和尽量少的修改量。

3 如何使用？

举例：公式运算，一个复杂的公式有加减乘除等等组成，根据需要不停的拓展，这时可以使用工厂类进行管理；最开始的做法是把公式实现写在一个工具类里面，但是调用时需要很多if判断，影响性能；工厂类可以有效解决此问题。

3.1 公式公用接口



import java.util.List;
/**
*同一的计算接口方便调用
*/
public interface ICalcMath {
	Double calcResut(List<Double> param);

}

3.2 公式实现



import java.util.List;

import org.slf4j.Logger;
import org.slf4j.LoggerFactory;

import com.sec.sedt.calc.utils.calc.ICalcMath;

/**
 * 求和
 * @author ml
 *
 */
public class Sum implements ICalcMath {
	 private static final Logger logger = LoggerFactory.getLogger(Sum.class);
	 
	@Override
	public Double calcResut(List<Double> param) {
		if(param==null||param.size()==0){
			return null;
		}
		Double[] array=param.toArray(new Double[param.size()]);
		return sum(array);
	}
	  /**
     * 求和
     * @return
     */
    public  Double sum(Double... array){
        if(array == null || array.length == 0){
            return null;
        }
        try {
            if (array.length == 1){
                return array[0];
            }else {
                Double sum = 0.0;
                for (Double d : array) {
                    if (d == null){
                        continue;
                    }
                    sum += d;
                }
                return sum;
            }
        } catch (Exception e) {
           
            logger.error("sum 报错{}",e.getMessage());
            return null;
        }
    }

}



import java.util.List;

import org.slf4j.Logger;
import org.slf4j.LoggerFactory;

import com.sec.sedt.calc.utils.calc.ICalcMath;

/**
 * 求减
 * @author ml
 *
 */
public class SubTraction implements ICalcMath {
	 private static final Logger logger = LoggerFactory.getLogger(SubTraction.class);
	 
	@Override
	public Double calcResut(List<Double> param) {
		if(param==null||param.size()==0){
			return null;
		}
		Double[] array=param.toArray(new Double[param.size()]);
		return subTraction(array);
	}
    /**
     * 减法
     * @return
     */
    public  Double subTraction(Double... array){
        if(array == null || array.length == 0){
            return null;
        }
        try {
            if (array.length == 1){
                return array[0];
            }else {
                Double sum =array[0];
                int f=0;
                for (Double d : array) {
                    if (d == null){
                        continue;
                    }
                    if(f==0){
                    	f++;
                    	continue;
                    }
                  
                    sum -= d;
                }
                return sum;
            }
        } catch (Exception e) {
        
            logger.error("SubTraction报错 {}",e.getMessage());
            return null;
        }
    }

}

3.3 工厂类



import java.util.HashMap;
import java.util.List;
import java.util.Map;

public class MathsFactory {
    
    private static Map<String,ICalcMath> mathsMap = new HashMap<String,ICalcMath>();
    
    private MathsFactory() {}
    
    private static final ICalcMath EMPTY = new EmptyCalcMath();
    
    //获取
    public static ICalcMath getMaths(String name) {
    	ICalcMath result = mathsMap.get(name);
        return result;
    }
    
    //将处罚对象注册到这里
    public static void registerMath(String name,ICalcMath math){

        mathsMap.put(name, math);
    }
    
    private static class EmptyCalcMath implements ICalcMath {

		public Double calcResut(List<Double> param) {
			// TODO Auto-generated method stub
			return null;
		}
     
    }
}

3.4 调用

使用时，先封装在工厂类，然后在直接调用需要的公式类即可。

           Sum sum=new Sum();
           MathsFactory.registerMath("Sum", sum);
	
	   SubTraction subTraction=new SubTraction();
	   MathsFactory.registerMath("SubTraction", subTraction);

           List<Double> params=new ArrayList<>();
	   params.add(34.5);
	   params.add(33.4);
	   double result =MathsFactory.getMaths("SUm").calcResut(params);