设计模式——简单工厂 VS 工厂方法

 简单工厂模式：

它最大优点在于工厂类中包含了必要的逻辑判断，根据客户端的选择条件动态的实例化相关的类， 对于客户端来说，去除了与具体产品的依赖。

 

使用了封装、继承、多态面向对象的三大特性，能做到灵活的修改和扩展，如要修改加法运算，或添加开根号运算，只需添加一个开根号运算的类，并在工厂中的switch case加一分支即可

 

工厂方法模式：

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

 

工厂方法模式实现时，客户端需要决定实例化那个工厂来实现运算类，选择判断的问题还是存在的，也就是说，工厂方法把简单工厂的内部逻辑判断移到了客户端代码来进行。想要加功能，本来是改工厂类的，而现在是修改客户端。

 

工厂方法模式是简单工厂的进一步抽象和推广，由于使用了多态性，工厂方法模式保持了简单工厂模式的优点，而且克服了它的缺点。但缺点是由于每加一个产品都需要加一个产品工厂类，增加了额外的开发量。

 

实例

实现加减乘除运算

Operation类：

package cn.edu.tju.simpleFactoryPattern;

public class Operation {
	
	protected double a = 0;
	protected double b = 0;
	
	public double getA() {
		return a;
	}

	public void setA(double a) {
		this.a = a;
	}

	public double getB() {
		return b;
	}

	public void setB(double b) {
		this.b = b;
	}

	public double getResult() throws Exception{
		return 0;
	}
}

 

继承Operation类，覆盖getResult方法

加法：

package cn.edu.tju.simpleFactoryPattern;

public class AddOperation extends Operation{
	
	public double getResult(){
		
		return a + b;
		
	}

}

 减法：

package cn.edu.tju.simpleFactoryPattern;

public class SubtractOperation extends Operation{
	
	public double getResult(){
		return a - b;
	}

}

 乘法：

package cn.edu.tju.simpleFactoryPatern;

public class MultiplyOperation extends Operation{
	
	public double getResult(){
		return a * b;
	}
}

 除法：

package cn.edu.tju.simpleFactoryPattern;

public class DivideOperation extends Operation{
	
	public double getResult() throws Exception{
		if (b == 0){
			throw new Exception("b can not be zero!");
		}
		return a / b;
	}
}

 工厂类，包含必要的逻辑判断

package cn.edu.tju.simpleFactoryPattern;

public class OperationFactory {
	
	public static Operation createOperation(char type){
		Operation oper = null;
		switch(type){
		case '+':
			oper = new AddOperation();
			break;
		case '-':
			oper = new SubtractOperation();
			break;
		case '*':
			oper = new MultiplyOperation();
			break;
		case '/':
			oper = new DivideOperation();
			break;
		}
		return oper;
	}

}

 测试类

package cn.edu.tju.simpleFactoryPattern;

import java.util.Scanner;

/*
 * 简单工厂模式的最大优点在于工厂类中包含了必要的逻辑判断，根据客户端的选择条件动态的实例化相关的类，
 * 对于客户端来说，去除了与具体产品的依赖。
 */
public class Test {

	public static void main(String[] args) throws Exception {

		Scanner scanner = new Scanner(System.in);
		while (System.in != null) {
			System.out.print("Please input the formula: ");
			double a = scanner.nextDouble();
			char o = scanner.next().toCharArray()[0];
			double b = scanner.nextDouble();

			Operation oper = OperationFactory.createOperation(o);
			oper.a = a;
			oper.b = b;
			double result = oper.getResult();
			System.out.println("The result is " + result);
		}
	}

}

 

工厂方法模式：

运算类不变，把工厂类改为接口，并实现不同的工厂，从而产生不同的产品

工厂接口：

package cn.edu.tju.factoryMethodPattern;

public interface OperationFactory {
	
	public Operation createOperation();

}

 加法工厂：

package cn.edu.tju.factoryMethodPattern;

public class AddOperationFactory implements OperationFactory{

	@Override
	public Operation createOperation() {
		// TODO Auto-generated method stub
		return new AddOperation();
	}

}

 加法工厂：

package cn.edu.tju.factoryMethodPattern;

public class SubtractOperationFactory implements OperationFactory{

	@Override
	public Operation createOperation() {
		// TODO Auto-generated method stub
		return new SubtractOperation();
	}

}

 乘法工厂：

package cn.edu.tju.factoryMethodPattern;

public class MultiplyOperationFactory implements OperationFactory {

	@Override
	public Operation createOperation() {
		// TODO Auto-generated method stub
		return new MultiplyOperation();
	}

}

 除法工厂

package cn.edu.tju.factoryMethodPattern;

public class DivideOperationFactory implements OperationFactory{

	@Override
	public Operation createOperation() {
		// TODO Auto-generated method stub
		return new DivideOperation();
	}
	

}

 修改测试类

package cn.edu.tju.factoryMethodPattern;

import java.util.Scanner;

/*
 * 工厂方法模式，定义一个用于创建对象的接口，让子类决定实例化哪一个类，使得一个类的实例化延迟到其子类。
 * 
 * 工厂方法模式实现时，客户端需要决定实例化那个工厂来实现运算类，选择判断的问题还是存在的，也就是说，
 * 工厂方法把简单工厂的内部逻辑判断移到了客户端代码来进行。想要加功能，本来是改工厂类的，而现在是修改客户端。
 * 
 * 工厂方法模式是简单工厂的进一步抽象和推广，由于使用了多态性，工厂方法模式保持了简单工厂模式的优点，而且克服
 * 了它的缺点。但缺点是由于每加一个产品都需要加一个产品工厂类，增加了额外的开发量。
 */
public class Test {

	public static void main(String[] args) throws Exception {

		Scanner scanner = new Scanner(System.in);
		while (System.in != null) {
			System.out.print("Please input the formula: ");
			double a = scanner.nextDouble();
			char o = scanner.next().toCharArray()[0];
			double b = scanner.nextDouble();
			OperationFactory operFactory = null;
			
			switch(o){
			case '+':
				operFactory = new AddOperationFactory();
				break;
			case '-':
				operFactory = new SubtractOperationFactory();
				break;
			case '*':
				operFactory = new MultiplyOperationFactory();
				break;
			case '/':
				operFactory = new DivideOperationFactory();
				break;
			}
			
			Operation oper = operFactory.createOperation();
			oper.a = a;
			oper.b = b;
			double result = oper.getResult();
			System.out.println("The result is " + result);
		}
	}

}