乱胡扯计算器

这几天晚上睡不太着，就想着写点程序，但是又不想改bug，做过程序的都知道，改bug真的是一件蛋疼的事情...所以，选择了想点东西来随便写写。

我记得以前我们写了很多计算器，在大一和大二的时候，用C写过控制台的，用Java写过Swing版本的，也用专业选修课写过C#的，我记得以前做OS课程设计的时候，也写过C++的，但是最近不是在上设计模式的课么？想起以前写的代码漏洞比较多，所以今天晚上就写哈，想到哪儿写到哪儿，尽量往好的方面靠。当然，技术多的代码不一定好，希望有高手能指点，我也想自己代码重构得更好。

1. 首先嘛，以前写计算器，一般就是“+”，“-”，“*”，“\”嘛，当然左除和右除没有做那么细。大楷结构就是，对了，最近不是要考UML迈，画画~直接上图了。

2. 感觉这样子肯定不好撒，首先，大致符合面向过程的方法，但是就是在结合界面的时候，代码就没法重用了。准备重构成功能代码和其他输入和输出代码分离的结构。但是重构后又觉得我是用Java写啊，因为我是玩Java的嘛，总要有面向对象的思想啊，不能写过程化的东西哇，用人的视觉去看代码。那我就弄成以下的结构吧。

但是感觉这个接口设得有点莫名其妙样，而且如果在加一个开方sqrt的话，就不好处理了，要改接口，当然也可以用类似适配器的方法，接口继承接口，但是这种方法相当的不好，会出现一种类似桥接模式会出现的问题，X*Y，最后代码成乘的方式增长类的个数。

3. 想了一下，还是不要接口了，干脆把接口中的方法换成一个一个的服务，在利用之前可拔式工厂模式的方法，对类进行初始化，利用配置文件和反射机制，来处理需求变更的问题，当然，我觉得抽象类还是可以要一个，我觉得对服务的拓展还是不错的选择，接口嘛，换换，当然不一定好哈，只是想到这里了，就开始写了，最开始我操作运算数都没有抽象成一个对象，我觉得抽象成这样不一定好，各有各的好处吧，对于如果是多个数的运算，感觉用可分离变量的方式还不错。

其实最开始想用工厂纯模式的，后来想了哈，工厂模式如果需求变更了，要改工厂类，后来选择这种方式后还不错，先把这个定成V1.0版本吧。有时间再思考哈，怎样的结构才更好。

代码V1.0，代码对其他特殊的情况，什么加得太大啊等异常没过好的处理，不过想用大数算法处理，不过今晚上先休息吧，还是要休息的。总感觉哪儿代码不对劲，哦，对了，反射那儿，可以用数据流风格来把那两个方法处理下，算了，下次处理吧。

package com.test.one;

import com.test.one.entity.OperatorNumber;

public interface Operator {
	
//	double result(double oneNumber, double twoNumber) throws Exception;
	double result(OperatorNumber operatorNumber) throws Exception;
}
package com.test.one.entity;

public class OperatorNumber {
	private double oneNumber;
	private double twoNumber;

	public OperatorNumber() {
		super();
	}
	
	public OperatorNumber(double oneNumber, double twoNumber) {
		super();
		this.oneNumber = oneNumber;
		this.twoNumber = twoNumber;
	}

	public double getOneNumber() {
		return oneNumber;
	}

	public void setOneNumber(double oneNumber) {
		this.oneNumber = oneNumber;
	}

	public double getTwoNumber() {
		return twoNumber;
	}

	public void setTwoNumber(double twoNumber) {
		this.twoNumber = twoNumber;
	}
}
package com.test.service;

import com.test.one.Operator;
import com.test.one.entity.OperatorNumber;

/**
 * 处理加法逻辑
 * @author BugBeta
 */
public class AddService implements Operator {

	@Override
//	public double result(double oneNumber, double twoNumber) {
	public double result(OperatorNumber number) {
		double result = 0.0d;
//		double maxDouble = Double.MAX_VALUE;
		
		result = number.getOneNumber() + number.getTwoNumber();
		return result;
	}
}
package com.test.service;

import com.test.one.Operator;
import com.test.one.entity.OperatorNumber;

/**
 * 处理除法逻辑
 * @author BugBeta
 */
public class DivService implements Operator {

	@Override
//	public double result(double oneNumber, double twoNumber) throws Exception {
	public double result(OperatorNumber number) throws Exception {
		double result = 0.0d;
//		double minDouble = Double.MIN_VALUE;
		
		if(number.getTwoNumber() == 0) {
				throw new Exception("除数不能为0！");
		}
		
		result = number.getOneNumber() - number.getTwoNumber();
		return result;
	}
}
package com.test.service;

import com.test.one.Operator;
import com.test.one.entity.OperatorNumber;

/**
 * 处理乘法逻辑
 * @author BugBeta
 *
 */
public class MulService implements Operator {

	@Override
//	public double result(double oneNumber, double twoNumber) {
	public double result(OperatorNumber number) {
		double result = 0.0d;
//		double maxDouble = Double.MAX_VALUE;

		result =  number.getOneNumber() * number.getTwoNumber();
		return result;
	}
}
package com.test.service;

import com.test.one.Operator;
import com.test.one.entity.OperatorNumber;

/**
 * 处理减法逻辑
 * @author BugBeta
 */
public class SubService implements Operator {

	@Override
//	public double result(double oneNumber, double twoNumber) {
	public double result(OperatorNumber number) {
		double result = 0.0d;
//		double minDouble = Double.MIN_VALUE;
		
		result = number.getOneNumber() - number.getTwoNumber();
		return result;
	}
}
package com.test.one.util;

public class ReflectUtil {
	
	public static Class<?> getClass(String className) {
		Class<?> classes = null;
		try {
			classes = Class.forName(className);
		} catch (ClassNotFoundException e) {
			e.printStackTrace();
		}
		return classes;
	}
	
	public static Object getObject(Class<?> classes) {
		Object obj = null;
		try {
			obj = classes.newInstance();
		} catch (InstantiationException e) {
			e.printStackTrace();
		} catch (IllegalAccessException e) {
			e.printStackTrace();
		}
		return obj;
	}
}
package com.test.one.util;

import java.io.BufferedReader;
import java.io.File;
import java.io.FileInputStream;
import java.io.FileNotFoundException;
import java.io.IOException;
import java.io.InputStream;
import java.io.InputStreamReader;
import java.util.Properties;

/**
 * properties文件的解析
 * @author BugBeta
 */
public class PropertiesUtil {
	/**
	 * 获取文件的流
	 */
	public static BufferedReader getBufferedReader(String path) {
		if(null == path || path.length() == 0) {
			return null;
		}
		InputStream inputStream = null;
		InputStreamReader inputStreamReader = null;
		BufferedReader bufferedReader = null;
		try {
			File file = new File(path);
			if(null == file) {
				throw new FileNotFoundException("文件不存在！");
			}
			inputStream = new FileInputStream(file);
			if(null == inputStream) {
				System.out.println("文件读入字符流中错误！");
				throw new Exception("文件不存在！");
			}
			//字符流转字节流
			inputStreamReader = new InputStreamReader(inputStream);
			//加入缓冲
			bufferedReader = new BufferedReader(inputStreamReader);
		} catch(Exception e) {
			e.printStackTrace();
		} 
		return bufferedReader;
	}
	
	/**
	 * 返回properties文件对象
	 * @param bufferedReader
	 * @return
	 */
	public static Properties getProperties(BufferedReader bufferedReader) {
		Properties properties = new Properties();
		try {
			properties.load(bufferedReader);
		} catch (IOException e) {
			e.printStackTrace();
		} 
		return properties; 
	}
}


package com.test.one.db;

import java.util.ArrayList;
import java.util.List;

public class DB {
	public static List<String> getListData() {
		List<String> objStr = new ArrayList<String>();
		objStr.add("add");
		objStr.add("sub");
		objStr.add("mul");
		objStr.add("div");
		return objStr;
	}
}
package com.test.one.test;

import java.util.ArrayList;
import java.util.List;
import java.util.Properties;

import com.test.one.Operator;
import com.test.one.db.DB;
import com.test.one.entity.OperatorNumber;
import com.test.one.util.PropertiesUtil;

/**
 * 测试主类
 * @author BugBeta
 */
public class CalculatorTest {

	private static String PATH = "src/calculator.properties";
	private static List<String> db = DB.getListData();
	
	public static List<Object> getObjectList() {
		Properties properties = PropertiesUtil.getProperties(
				PropertiesUtil.getBufferedReader(PATH));
		int size = db.size() - 1;
		List<Object> obj = new ArrayList<Object>();

		for (int i = 0; i <= size; ++i) {
			obj.add(
					com.test.one.util.ReflectUtil.getObject(
							com.test.one.util.ReflectUtil.getClass(
									properties.getProperty(db.get(i)))));
		}
		
		return obj;
	}

	public static void main(String[] args) throws Exception {
		double result = 0.0d;
		List<Object> obj = CalculatorTest.getObjectList();
		int objSize = obj.size() - 1;
		OperatorNumber number = new OperatorNumber(1, 2);
		
		for (int i = 0; i <= objSize; ++i) {
			Operator operator = (Operator) obj.get(i);
			result = operator.result(number);
			System.out.println(db.get(i) + " : " + result);
		}
	}
}

我晕死啦！写完后发现就是工厂模式哇！！！睡觉，睡觉。。。下次再玩哈其他的。。。这郁闷了。。。