工厂模式方法

工厂模式方法

首先使用简单工厂模式实现一个计算器方法

import java.util.Scanner;

abstract class operation
{
	private double numberA=0;
	private double numberB=0;//两个number属性主要用于计算机的前后数
	boolean flag=true;
	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 getResult();
}
class operationAdd extends operation
{

	@Override
	public double getResult() {
		// TODO Auto-generated method stub
		double result=0;
		return getNumberA()+getNumberB();
	}
}
class operationSub extends operation
{

	@Override
	public double getResult() {
		// TODO Auto-generated method stub
		double result=0;
		return getNumberA()-getNumberB();
	}
}
class operationMul extends operation
{

	@Override
	public double getResult() {
		// TODO Auto-generated method stub
		double result=0;
		return getNumberA()*getNumberB();
	}
}
class operationDiv extends operation
{

	@Override
	public double getResult() {
		// TODO Auto-generated method stub
		double result=0;
		return getNumberA()/getNumberB();
	}
}
class operationfacotry
{
	public static operation creatoperation(char operate)
	{
		operation oper=null;
		switch(operate)
		{
		case '+': oper=new operationAdd();break;
		case '-': oper=new operationSub();break;
		case '*': oper=new operationMul();break;
		case '/': oper=new operationDiv();break;
		}
		return oper;
		/*简单工厂模式operationfacotry根据提供给他的数据（Operate）返回几个可能的类
		    operationAdd,operationSub,operationMul,operationDiv中的一个类的实例
		    它返回的类有一个公共的父类operation和一个公共的方法getSult（）
		   
		   如此一来如果我们需要增添复杂的运算，只需增加相应的运算子类和拓展工厂类就行。
          */
	}
}
public class main {
	public static void main(String[] args) {
		Scanner s = new Scanner(System.in);
		System.out.println("请输入数A:");
		String a=s.nextLine();
		System.out.println("请输入运算符:");
		String stropera=s.nextLine();
		System.out.println("请输入数B:");
		String b=s.nextLine();
		operation oper;
		oper=operationfacotry.creatoperation(stropera.charAt(0));
		oper.setNumberA(Double.parseDouble(a));
		oper.setNumberB(Double.parseDouble(b));
		System.out.println("结果是:"+oper.getResult());
	}
}

如果要添加一个负责的运算 如：M的N次方
只需要补充一个方法类继承运算类不需要改变用户类

class  operationMN extends operation
{

	@Override
	public double getResult() {
		// TODO Auto-generated method stub
		double r=1;
		double m=getNumberA();
		int n=(int)getNumberB();
		for(int i=1;i<n;i++)
		{
			r=r*m;
		}
		return r;
	}
}

此时修改工厂类

class operationfacotry
{
	public static operation creatoperation(char operate)
	{
		operation oper=null;
		switch(operate)
		{
		case '+': oper=new operationAdd();break;
		case '-': oper=new operationSub();break;
		case '*': oper=new operationMul();break;
		case '/': oper=new operationDiv();break;
		***case '^': oper=new operationMN();break;***
      //违背了开放-封闭原则
		}
		return oper;
		}
		}

于是对此进行优化采用工厂方法模式，根据依赖倒转原则，把工厂类抽象出一个接口，这个接口有一个创建抽象产品的工厂方法。所以的要生产具体类的工厂，就去实现这个接口，这样，一个简单工厂模式的工厂类，变成了一个工厂抽象接口和多个具体生成对象的工厂类。因此要增加功能时只需要增加此功能的运算类和相应的工厂类。

abstract class operation
{
	private double numberA=0;
	private double numberB=0;//两个number属性主要用于计算机的前后数
	boolean flag=true;
	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 getResult();
}
class operationAdd extends operation
{

	@Override
	public double getResult() {
		// TODO Auto-generated method stub
		double result=0;
		return getNumberA()+getNumberB();
	}
}
class operationSub extends operation
{

	@Override
	public double getResult() {
		// TODO Auto-generated method stub
		double result=0;
		return getNumberA()-getNumberB();
	}
}
class operationMul extends operation
{

	@Override
	public double getResult() {
		// TODO Auto-generated method stub
		double result=0;
		return getNumberA()*getNumberB();
	}
}
class operationDiv extends operation
{

	@Override
	public double getResult() {
		// TODO Auto-generated method stub
		double result=0;
		return getNumberA()/getNumberB();
	}
}
 interface IFactory
{
	operation createoperation();
}
class AddFactory implements IFactory
{

	@Override
	public operation createoperation() {
		// TODO Auto-generated method stub
		return new operationAdd();
	}
}
class SubFactory implements IFactory
{

	@Override
	public operation createoperation() {
		// TODO Auto-generated method stub
		return new operationSub();
	}
}
class MulFactory implements IFactory
{

	@Override
	public operation createoperation() {
		// TODO Auto-generated method stub
		return new operationMul();
	}
}
class DivFactory implements IFactory
{

	@Override
	public operation createoperation() {
		// TODO Auto-generated method stub
		return new operationDiv();
	}
}
//加减乘除各建立一个具体工厂去实现接口
public class main {
	public static void main(String[] args) {
		Scanner s = new Scanner(System.in);
		System.out.println("请输入数A:");
		String a=s.nextLine();
		System.out.println("请输入运算符:");
		String stropera=s.nextLine();
		System.out.println("请输入数B:");
		String b=s.nextLine();
		IFactory oper=null;
		switch(stropera.charAt(0))
		{
		case '+': oper=new AddFactory();break;
		case '-': oper=new SubFactory();break;
		case '*': oper=new MulFactory();break;
		case '/': oper=new DivFactory();break;
		}
		operation op=oper.createoperation();
		op.setNumberA(Double.parseDouble(a));
		op.setNumberB(Double.parseDouble(b));
		try
		{
		System.out.println("结果是:"+op.getResult());
		}catch(Exception e)
		{
			e.printStackTrace();
		}
	}
}

工厂方法模式是类的创建模式，其用意是定义一个创建产品对象的工厂接口，核心是工厂类不再负责所以产品的创建，而是将具体创建工作交给子类去做。
工厂模式可以允许系统在不修改工厂角色的情况下引进新产品。
但是工厂方法把简单工厂内部的逻辑判断移到客户端代码来进行。想要加功能需要修改客户端。