设计模式(Java)----工厂方法模式FactoryMethod

如果想对两个数进行算数运算，应该怎样写代码呢？
1.简单工厂模式

**工厂类角色Creator:**工厂类在客户端的直接控制下(Create方法)创建产品对象。
**抽象产品角色Product:**定义简单工厂创建的对象的父类或它们共同拥有的接口可以是一个类、抽象类或接口。
**具体产品角色ConcreteProduct:**定义工厂具体加工出的对象。

import java.util.*;

abstract class Operation{
	private double numberA=0;
	private double numberB=0;
	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();
	}
	
}
/*增加求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 OperationFactory{
	public static Operation createOperation(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;
		/*增加m的n次方*/
		case'^':oper=new OperationMN();break;
		}/*对修改开放，违背了开放-封闭原则*/
		return oper;
		
	}
}
/*如此一来，如果我们需要增加各种复杂运算，比如平方根、立方根、自然对数等，只需要增加相应的运算子类和扩展工厂类就可以了*/
public class Main{
	public static void main(String[] args) {
		Scanner scanner=new Scanner(System.in);
		System.out.println("请输入数字A：");
		String strNumberA=scanner.nextLine();
		System.out.println("请选择运算符号（+、-、*、/）：");
		String strOperator=scanner.nextLine();
		System.out.println("请输入数字B：");
		String strNumberB=scanner.nextLine();
		Operation oper;
		oper=OperationFactory.createOperation(strOperator.charAt(0));
		oper.setNumberA(Double.parseDouble(strNumberA));
		oper.setNumberB(Double.parseDouble(strNumberB));
		System.out.println("结果是："+oper.getResult());

	}
	
}

优点：
工厂类中包含了必要的逻辑判断，根据客户端的选择条件动态实例化相关类，对于客户来说，去除了与具体产品的依赖。
缺点：
①在某种程度上违背了开放-封闭原则：系统扩展困难，一旦添加新产品就得修改工厂类。
②对工厂类过于依赖：工厂类集中了所有产品创建逻辑，一旦不能正常工作，整个系统都会受到影响。
2.工厂方法模式
核心的工厂类不再负责所有产品的创建，而是将具体的创建工作交给子类去做。允许系统在不修改工厂角色的情况下引进新产品。
**

**抽象工厂(Creator)角色：**是工厂方法模式的核心，与应用程序无关。任何在模式中创建的对象的工厂类必须实现这个接口。
**具体工厂(ConcreteCreator)角色:**这是实现抽象工厂接口的具体工厂类，包含与应用程序密切相关的逻辑并且受到应用程序调用以创建产品对象。
**抽象产品(Product) 角色:**工厂方法模式所创建的对象的超类型，也就是产品对象的共同父类或共同拥有的接口。
**具体产品(Concrete Product)角色:**这个角色实现了抽象产品角色所定义的接口。某具体产品有专门的具体工厂创建，它们之间往往一一对应。

**

import java.util.*;

abstract class Operation{
	private double numberA=0;
	private double numberB=0;
	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();
	}
	
}
/*增加求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;
	}
	
}*/
interface IFactory{
	Operation createOperation();
}
class AddFactory implements IFactory{
	public Operation createOperation() {
		return new OperationAdd();
	}
}
class SubFactory implements IFactory{
	public Operation createOperation() {
		return new OperationSub();
	}
}
class MulFactory implements IFactory{
	public Operation createOperation() {
		return new OperationMul();
	}
}
class DivFactory implements IFactory{
	public Operation createOperation() {
		return new OperationDiv();
	}
}

/*简单运算工厂类*/
class OperationFactory{
	public static Operation createOperation(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;
		/*增加m的n次方*/
		/*case'^':oper=new OperationMN();break;*/
		}对修改开放，违背了开放-封闭原则
		return oper;
		
	}
}
如此一来，如果我们需要增加各种复杂运算，比如平方根、立方根、自然对数等，只需要增加相应的运算子类和扩展工厂类就可以了
public class Main{
	public static void main(String[] args) {
		Scanner scanner=new Scanner(System.in);
		System.out.println("请输入数字A：");
		String strNumberA=scanner.nextLine();
		System.out.println("请选择运算符号（+、-、*、/）：");
		String strOperator=scanner.nextLine();
		System.out.println("请输入数字B：");
		String strNumberB=scanner.nextLine();
		IFactory operFactory=null;
		switch(strOperator.charAt(0))
		{
		case'+':operFactory=new AddFactory();break;
		case'-':operFactory=new SubFactory();break;
		case'*':operFactory=new MulFactory();break;
		case'/':operFactory=new DivFactory();break;
		}
		Operation oper=operFactory.createOperation();
		oper.setNumberA(Double.parseDouble(strNumberA));
		oper.setNumberB(Double.parseDouble(strNumberB));
		try {
			double result=oper.getResult();
			System.out.println("结果是："+result);
		}catch(Exception e) {
			e.printStackTrace();
		}
	}
	
}

优点
1.更符合开-闭原则
工厂方法模式：新增一种产品时，只需要增加相应的具体产品类和相应的工厂子类即可。
简单工厂模式：需要修改工厂类的判断逻辑。
2.符合单一职责原则
工厂方法模式：每个具体工厂类只负责创建对应的产品。
简单工厂模式：工厂类存在复杂的if分支逻辑判断。
3.工厂方法模式：不使用静态工厂方法，可以形成基于继承的等级结构。
简单工厂模式：工厂类使用静态工厂方法。