设计模式—创建型—简单工厂(又叫静态工厂方法，不属于GOF23中设计模式)

创建性模式有五种：

1.工厂模式
    ①简单工厂模式（经常被用到,不属于GoF23种设计模式）
    ②工厂方法模式
    ③抽象工厂模式
2.建造者模式
3.原型模式
4.单例模式

简单工厂

       简单工厂模式属于类的创新型模式，又叫静态工厂方法模式,是通过专门定义一个类来负责创建其他类的实例，被创建的实例通常都具有共同的父类。它不属于GOF的23种设计模式，但现实中却经常会用到。

角色

工厂角色：简单工厂模式的核心，它负责实现创建所有实例的内部逻辑。工厂类的创建产品类的方法可以被外界直接调用，创建所需的产品对象。
抽象产品角色：简单工厂模式所创建的所有对象的父类，它负责描述所有实例所共有的公共接口。
具体产品角色：是简单工厂模式的创建目标，所有创建的对象都是充当这个角色的某个具体类的实例。

优缺点

• 优点

工厂类是整个模式的关键.包含了必要的逻辑判断,根据外界给定的信息,决定究竟应该创建哪个具体类的对象.通过使用工厂类,外界可以从直接创建具体产品对象的尴尬局面摆脱出来,仅仅需要负责“消费”对象就可以了。而不必管这些对象究竟如何创建及如何组织的．明确了各自的职责和权利。

• 缺点

  由于工厂类集中了所有实例的创建逻辑，违反了高内聚责任分配原则，将全部创建逻辑集中到了一个工厂类中；它所能创建的类只能是事先考虑到的，如果需要添加新的类，则就需要改变工厂类了。
当系统中的具体产品类不断增多时候，可能会出现要求工厂类根据不同条件创建不同实例的需求．这种对条件的判断和对具体产品类型的判断交错在一起，很难避免模块功能的蔓延，对系统的维护和扩展非常不利

 

类图

java 代码实现

 

/**
 * 抽象产品角色
 * @author work
 *
 */
public abstract class Operaction {
	
	protected Double numberA;
	protected Double numberB;

	public Double getNumberA() {
		return numberA;
	}

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

	public Double getNumberB() {
		return numberB;
	}

	public void setNumberB(Double numberB) {
		this.numberB = numberB;
	}
	
	public abstract Double operacte();
	
}

package com.sun.staticfactory;
/**
 * 具体产品角色add
 * @author work
 *
 */
public class AddOperaction  extends Operaction{

	@Override
	public Double operacte() {
		// TODO Auto-generated method stub
		return numberA+numberB;
	}

}

 

package com.sun.staticfactory;
/**
 * 具体产品角色
 * @author work
 *
 */
public class SubstractOperaction extends Operaction{

	@Override
	public Double operacte() {
		// TODO Auto-generated method stub
		return numberA-numberB;
	}
	
}

 

package com.sun.staticfactory;
/**
 * 工厂
 * @author work
 *
 */
public class OperactionFactory {
	
	public static Operaction createOperaction(String oper) {
		Operaction operaction = null;
		switch (oper) {
		case "+":
			operaction = new AddOperaction();
			break;
		case "-":
			operaction = new SubstractOperaction();
			break;
		default:
			break;
		}
		return operaction;
	}
	
	public static void main(String[] args) {
		Operaction operaction = createOperaction("+");
		operaction.setNumberA(11d);
		operaction.setNumberB(12d);
		System.out.println(operaction.operacte());
		Operaction operactionj = createOperaction("-");
		operactionj.setNumberA(11d);
		operactionj.setNumberB(12d);
		System.out.println(operactionj.operacte());
	}
}

       总结一下，尽管简单工厂模式的代码实现中，存在大量的分支判断逻辑，增加一种operaction，就需要在switch处增加一个case判断，违背开闭原则，但权衡扩展性和可读性，这样的代码实现在大多数情况下（比如，不需要频繁地添加 operaction）是没有问题的。

       在上面代码中我们每次调用createOperaction函数都会创建一个新的operaction，如果operaction可以复用，我们也可以将operaction缓存起来，以节省内存和对象创建的时间，当调用 createOperaction函数的时候，我们从缓存中取出operaction对象直接使用。这有点类似单例模式和简单工厂模式的结合

public class OperactionFactory {

    private static final Map<String,Operaction> cachedOperaction = new HashMap<String,Operaction>();
    
    static {
        cachedOperaction.put("+",new AddOperaction());
        cachedOperaction.put("-",new SubstractOperaction());
    }
    public static Operaction createOperaction(String oper) {
        if (oper == null || oper.isEmpty()) { 
            return null;
        }
        return cachedOperaction.get(oper);
    }

    public static void main(String[] args) {
        Operaction operaction = createOperaction("+");
        operaction.setNumberA(11d);
        operaction.setNumberB(12d);
        System.out.println(operaction.operacte());
        Operaction operactionj = createOperaction("-");
        operactionj.setNumberA(11d);
        operactionj.setNumberB(12d);
        System.out.println(operactionj.operacte());
    }
}