工厂模式方法
首先使用简单工厂模式实现一个计算器方法
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();
}
}
}
工厂方法模式是类的创建模式,其用意是定义一个创建产品对象的工厂接口,核心是工厂类不再负责所以产品的创建,而是将具体创建工作交给子类去做。
工厂模式可以允许系统在不修改工厂角色的情况下引进新产品。
但是工厂方法把简单工厂内部的逻辑判断移到客户端代码来进行。想要加功能需要修改客户端。