1. 简单工厂设计模式

刺骨的言语ヽ痛彻心扉 2022-07-24 10:16 107阅读 0赞

# 设计模式之简单工厂设计模式 #

今天从图书馆借来了好久都没借到到《大话设计模式》这本书，据说这本书特别适合入门级别，讲课也是诙谐幽默，终于有机会来拜读，闲话不扯，直接开始干货。（本文均是以java语言实现）

简单工厂模式属于创建型模型；

以一个实际的例子为例：实现一个简单计算器的控制台程序，输入两个数据和一个运算符得到结果。

我估计作为一个从C语言过渡过来，OO思想并不完善的程序员来说，可能第一想法的代码就是如下所示：我的第一想法也是如此。

package com.simplefactory;
    
    import java.io.IOException;
    import java.util.Scanner;
    
    public class Testing {
    
    	public static void main(String[] args) throws IOException {
    		double A = 0.0;
    		double B = 0.0;
    		//输入A和B
    		Scanner scan = new Scanner(System.in);
    		String read = null;
    		if (scan.hasNextLine()){
    			 read = scan.nextLine();
    		}
    		A = Double.parseDouble(read);
    		System.out.println("A=" + A);
    		
    		if (scan.hasNextLine()){
    			 read = scan.nextLine();
    		}
    		B = Double.parseDouble(read);
    		System.out.println("B=" + B);
    		//输入操作符
    		System.out.println("请输入操作符：");
    		char op;
    		op = (char)System.in.read();
    		
    		//运算
    		double result= 0.0;
    		if(op == '+'){
    			result = A+B;
    		}else if (op == '-'){
    			result = A-B;
    		}else if (op == '*'){
    			result = A*B;
    		}else if (op == '/'){
    			if(B != 0.0)
    				result = A/B;
    			else {
    				try {
    					throw new Exception("除数不能为0");
    				} catch (Exception e) {
    					e.printStackTrace();
    				}
    			}
    		}
    		
    		System.out.println("结果是："+ result);
    	}
    }

这样的代码确实也可以实现功能，但是有一个问题，这样的代码可维护性和可扩展性太差，更加是不可复用。举个例子，如果我们当前代码的需求要我们添加求平方根的功能，求N次方的功能呢？这时我们之前的代码几乎没有用处了，我们必须得完全重新写代码，开发效率就十分低下了。

如何使我们的代码变得可扩展呢？这时就考虑到了面向对象的三大思想了：封装，继承，多态。具体我们应该考虑如下几个方面：

（1）我们将业务逻辑和界面 的显示分离，使业务逻辑的代码不仅可以用于控制台程序，也可以用于APP，服务器等等，达到可复用的目的。

（2）我们将业务逻辑封装到类里面。

（3）引入工厂设计模式

具体实现代码如下：

1. 我们先创建一个简单运算工厂类：

package com.simplefactory;
    
    /**
     * 运算类
     * @author Administrator
     *
     */
    public class Operation {
    
    	protected double numberA = 0.0;
    	protected double numberB = 0.0;
    	
    	public double getResult() {
    		double result = 0.0;
    		return result;
    	}
    }

2. 然后我们为每种运算都创建一个类，继承自基础运算类；并且在每个运算类中重写了计算方法，这样如果我们更改其中之一的运算方法，就不需要改变其余的代码，做到低耦合。

package com.simplefactory;
    
    public class OperationAdd extends Operation{
    
    	/**
    	 * 重写计算方法
    	 */
    	@Override
    	public double getResult() {
    		double result = 0.0;
    		result = numberA + numberB;
    		return result;
    	}
    }

package com.simplefactory;
    
    public class OperationSub extends Operation{
    
    	/**
    	 * 重写计算方法
    	 */
    	@Override
    	public double getResult() {
    		double result = 0.0;
    		result = numberA - numberB;
    		return result;
    	}
    	
    }

package com.simplefactory;
    
    public class OperationMul extends Operation{
    
    	/**
    	 * 重写计算方法
    	 */
    	@Override
    	public double getResult() {
    		double result = 0.0;
    		if (numberB == 0.0){
    				try {
    					throw new Exception("除数不能为0");
    				} catch (Exception e) {
    					e.printStackTrace();
    				}
    		}
    		result = numberA * numberB;
    		return result;
    	}
    }

package com.simplefactory;
    
    public class OperationDiv extends Operation{
    
    	/**
    	 * 重写计算方法
    	 */
    	@Override
    	public double getResult() {
    		double result = 0.0;
    		result = numberA / numberB;
    		return result;
    	}
    	
    }

3. 实现运算必须要有实例类，这时就引入了简单工厂设计模式，我们创建一个工厂类，根据我们的运算符来决定创建哪一个实例。

package com.simplefactory;
    
    /**
     * 简单工厂模式
     * @author Administrator
     */
    public class SimpleFactory {
    	
    	public static Operation createOperation(String operstr) {
    		Operation operation = null;
    		int value = 0;
    		
    		if(operstr.equals("+"))
    			value =1;
    		else if(operstr.equals("-"))
    			value = 2;
    		else if(operstr.equals("*"))
    			value = 3;
    		else if(operstr.equals("/"))
    			value = 4;
    		
    		switch (value) {
    			case 1:
    				operation = new OperationAdd();
    				break;
    			case 2:
    				operation = new OperationSub();
    				break;
    			case 3:
    				operation = new OperationMul();
    				break;
    			case 4:
    				operation = new OperationDiv();
    				break;
    			default:
    				break;
    		}//end of switch
    		
    		return operation;
    	}
    
    }

根据静态方法，只需要输入运算符就会创建对应的实例，通过多态，返回父类的方式实现了计算器的结果。

接下来就是客户端的程序了：

package com.simplefactory;
    
    /**
     * 客户端代码
     * @author Administrator
     *
     */
    public class Client {
    	
    	public static void main(String[] args) {
    
    		Operation operation = null;
    		operation = SimpleFactory.createOperation("-");
    		
    		operation.numberA = 1.1;
    		operation.numberB = 2.2;
    		
    		double result = operation.getResult();
    		System.out.println(result);
    	}
    
    }

完成的程序就完成了，这是一个最简答简单工厂设计模式示例。

当我们要修改加法运算，只需要该加法运算的类就行了，其余的都不需要改动。当我们需要增加运算时，只需要增加对应的类，并在运算类工厂中修改一下就行了。这时只需要改业务逻辑，界面代码不需要我们更改，实现了业务逻辑和视图分离的效果。