工厂模式—简单工厂模式(Simple Factory Pattern)

最新推荐文章于 2023-08-09 00:00:00 发布

LCore

最新推荐文章于 2023-08-09 00:00:00 发布

阅读量1.5k

点赞数

分类专栏：【设计模式】

本文链接：https://blog.youkuaiyun.com/lcore/article/details/8677940

版权

【设计模式】专栏收录该内容

19 篇文章

订阅专栏

同样以计算器程序为参考对象,上一篇文章中通过业务的封装将业务逻辑和界面逻辑分开

从而降低了他们的耦合度,使得扩展性和维护性提高.但是仅仅这样还不够.因为,Operation类中,加

法、减法、乘法、除法的运算是在一起的，如若需要加入一种新的运算方式（开根）就势必去修

原有的代码,不加注意就会造成问题.

因此,加减乘除运算有必要分离出来,降低各类运算之间的耦合度，这就要使用继承的方式

来实现。首先需要一个运算的基类,之后再继承该基类(并且重写方法)

Operation类

package com.kiritor;
/**
 * 运算基类*/
public class Operation {
    private double num1 = 0.0;
    private double num2 = 0.0;
	public double getNum1() {
		return num1;
	}
	public void setNum1(double num1) {
		this.num1 = num1;
	}
	public double getNum2() {
		return num2;
	}
	public void setNum2(double num2) {
		this.num2 = num2;
	}
    
	public double getResult(double numA ,double numB) throws Throwable
	{
		double result =0.0;
		return result;
	}
}

OperationAdd类

package com.kiritor;
/**
 * 加法运算*/
public class OperationAdd extends Operation{
    @Override
    public double getResult(double numA, double numB) {
    	double result = 0.0;
    	result = numA+numB;
    	return result;
    }
}

OperationSub类

package com.kiritor;
/**
 * 减法类*/
public class OperationSub extends Operation{
    @Override
    public double getResult(double numA, double numB) {
    	double result = 0.0;
    	result = numA-numB;
    	return result;
    }
}

OperationMul类

package com.kiritor;
/**
 * 乘法类*/
public class OperationMul extends Operation{
 
	@Override
	public double getResult(double numA, double numB) {
		double result = 0.0;
		result = numA * numB;
		return result;
	}
}

OperationDiv类

package com.kiritor;
/**
 * 除法类*/
public class OperationDiv extends Operation{
 
	 @Override
	public double getResult(double numA, double numB) throws Throwable {
		double result = 0.0;
		if(numB==0)
			throw new Exception("除数不能为零！");
		result = numA / numB ;
		return result ;
	}
}

这里通过继承与方法的重写使得各方法分开了，因此在修改某个方法的代码的

时候就不会接触到其他方法的代码。而且若有新的运算方式的时候，直接继承在重

写，减少了出错的可能，程序逻辑结构更加的清晰!

不过问题也来了，实际运用中我们如何知道应该调用何种方法呢？也就是如何

实例化对象的问题

可以使用“简单工厂模式”予以实现，用一个单独的类来创造实例的过程，也就是

工厂

OperationFactory类：

package com.kiritor;
/**
 * 生产运算类的工厂*/
public class OperationFactory {
   public static Operation bulidOperation(String opr)
   {
	   Operation operation = null;
	   switch (opr) {
	case "+":
		operation = new OperationAdd();
		break;
	case "-":
		operation = new OperationSub();
		break;
	case "*":
		operation = new OperationMul();
		break;
	case "/":
		operation = new OperationDiv();
		break;
	}
	   return operation;
   }
}

主类：

Operation operation =null;
		operation = OperationFactory.bulidOperation("+");
		try {
			System.out.println(operation.getResult(1.2, 2.1));
		} catch (Throwable e) {
			// TODO Auto-generated catch block
			e.printStackTrace();
		}

经过上述的变换，若果需要添加一个开根运算，只需要实现一个运算子类，之后再修改工厂就可以了

大大降低了程序的耦合度!

类图结构为：