简单工厂与工厂方法模式

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

 

1.简单工厂模式是属于创建型模式，又叫做静态工厂方法模式，但不属于23种GOF设计模式之一。
2.优点：工厂类是整个模式的关键.包含了必要的逻辑判断,根据外界给定的信息,决定究竟应该
  创建哪个具体类的对象.通过使用工厂类,外界可以从直接创建具体产品对象的尴尬局面摆脱出来,
  仅仅需要负责“消费”对象就可以了。而不必管这些对象究竟如何创建及如何组织的．明确了各自的
  职责和权利，有利于整个软件体系结构的优化。
3.缺点：由于工厂类集中了所有实例的创建逻辑，违反了高内聚责任分配原则，将全部创建逻辑集中到
  了一个工厂类中；它所能创建的类只能是事先考虑到的，如果需要添加新的类，则就需要改变工厂类了。
  可通过工厂方法模式克服该缺点。

/**
 * 算法操作基类
 */
public class Operation {
	
	// 数值A
	private double numberA;
	// 数值B
	private double numberB;
	
	public double getResult(){
		double result = 0;
		return result;
	}

	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 class OperationAdd extends Operation {

	@Override
	public double getResult() {

		double result = 0;
		result = getNumberA() + getNumberB();
		return result;
	}
}

 

/**
 * 实现减法的具体运算，继承运算类
 */
public class OperationSub extends Operation {

	@Override
	public double getResult() {

		double result = 0;
		result = getNumberA() - getNumberB();
		return result;
	}
}

 

/**
 * 实现乘法的具体运算，继承运算类
 */
public class OperationMul extends Operation {

	@Override
	public double getResult() {

		double result = 0;
		result = getNumberA() * getNumberB();
		return result;
	}
}

 

/**
 * 实现除法的具体运算，继承运算类
 */
public class OperationDiv extends Operation {

	@Override
	public double getResult(){

		double result = 0;
		if(getNumberB()==0){
			throw new RuntimeException("除数不能为0");
		}
		result = getNumberA() / getNumberB();
		return result;
	}
}

 

/**
 * 运算符操作符枚举类
 */
public enum OperateEnum {		
	Add,Div,Mul,Sub;		
}

 

/**
 * 简单运算工厂类
 */
public class OperationFactory {
	// 根据传入的运算符，创建具体的运算类
	public static Operation createOperate(OperateEnum operate){
		
		Operation oper = null;
		switch(operate){
			case Add:
				oper = new OperationAdd();
				break;
			case Mul:
				oper = new OperationMul();
			case Sub:
				oper = new OperationSub();
			case Div:
				oper = new OperationDiv();
		}		
		return oper;
	}
}

 

public class Main {

	public static void main(String[] args) {

		Operation oper = OperationFactory.createOperate(OperateEnum.Add);
		oper.setNumberA(10);
		oper.setNumberB(15);
		System.out.println(oper.getResult());
		
		oper = OperationFactory.createOperate(OperateEnum.Mul);
		oper.setNumberA(10);
		oper.setNumberB(15);
		System.out.println(oper.getResult());
	}
}

 

 

 

工厂方法模式：定义一个用于创建对象的接口，让子类决定实例化哪一个类。
                      工厂方法使一个类的实例化延迟到其子类。

 

与简单工厂模式的对比：
1.简单工厂模式的最大优点在于工厂类中包含了必要的逻辑判断，根据客户端的选择条件动态
  实例化相关的类，对于客户端来说，去除了与具体的产品的依赖。
  缺点是对扩展开放，对修改也开放，违背了开放-封闭原则。
2.工厂方法模式的优点是克服了简单工厂违背了开放-封闭原则的缺点，又保持了封装对象创建
  过程的优点，是简单工厂模式的进一步抽象和推广。
  缺点是每添加一个产品，就得添加一个产品工厂的类。    

 

 

工厂方法模式实例：

 

 

 

 

/**
 * 算法操作基类
 *
 */
public class Operation {
	
	// 数值A
	private double numberA;
	// 数值B
	private double numberB;
	
	public double getResult(){
		double result = 0;
		return result;
	}

	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 class OperationAdd extends Operation {

	@Override
	public double getResult() {

		double result = 0;
		result = getNumberA() + getNumberB();
		return result;
	}
}

 

/**
 * 实现减法的具体运算，继承运算类
 */
public class OperationSub extends Operation {

	@Override
	public double getResult() {

		double result = 0;
		result = getNumberA() - getNumberB();
		return result;
	}
}

 

/**
 * 实现乘法的具体运算，继承运算类
 */
public class OperationMul extends Operation {

	@Override
	public double getResult() {

		double result = 0;
		result = getNumberA() * getNumberB();
		return result;
	}
}

 

/**
 * 实现除法的具体运算，继承运算类
 */
public class OperationDiv extends Operation {

	@Override
	public double getResult(){

		double result = 0;
		if(getNumberB()==0){
			throw new RuntimeException("除数不能为0");
		}
		result = getNumberA() / getNumberB();
		return result;
	}
}

 

/**
 * 运算类工厂接口
 *
 */
public interface IFactory {
	
	public Operation createOperation();

}

 

/**
 * 加法类工厂
 *
 */
public class FactoryAdd implements IFactory {

	public Operation createOperation() {
		
		// 返回加法运算类实例
		return new OperationAdd();
	}
}

 

/**
 * 减法类工厂
 *
 */
public class FactorySub implements IFactory {

	public Operation createOperation() {
		
		// 返回减法运算类实例
		return new OperationSub();
	}
}

 

/**
 * 乘法类工厂
 *
 */
public class FactoryMul implements IFactory {

	public Operation createOperation() {
		
		// 返回乘法运算类实例
		return new OperationMul();
	}
}

 

/**
 * 除法类工厂
 *
 */
public class FactoryDiv implements IFactory {

	public Operation createOperation() {
		
		// 返回除法运算类实例
		return new OperationDiv();
	}
}

 

/**
 * 工厂方法实例（计算器工厂）
 *
 */
public class Main {

	public static void main(String[] args) {
		
		// 加法运算，取得加法工厂类
		IFactory factory = new FactoryAdd();
		Operation operation = factory.createOperation();
		operation.setNumberA(10);
		operation.setNumberB(30);
		System.out.println(operation.getResult());
		
		// 减法运算，取得减法工厂类
		factory = new FactorySub();
		operation = factory.createOperation();
		operation.setNumberA(10);
		operation.setNumberB(30);
		System.out.println(operation.getResult());
	}
}