用面向概念实现 a [+-*/] b 运算

代码如下:

新建类 test.calcu.Drive.java, copy下面代码到Eclipse中执行(jdk 1.5)

 

 

package test.calcu;

import java.util.HashMap;
import java.util.Map;
import java.util.Scanner;

//面向概念编程demo--a op b

/*=========================*\
  step 1 : 提出概念  a 运算  b
\*=========================*/

interface A_Op_B_Concept {
	/**
	 * a运算b
	 * @return a运算b的值
	 * @throws Exception 
	 */
	void a_op_b() throws Exception;
	
	/**
	 * 处理异常
	 * @param e 
	 */
	void dealException(Exception e);
}

/*==============================*\
	step 2 构造实体 ---具体化概念
	
	一般包含两个实体：视图和模型
	2.1, 模型实体
	2.2, 视图实体
	
\*==============================*/


/**
 *模型实体
 */
abstract class A_Op_B_Model implements A_Op_B_Concept {

	String operatorSymbol;
	
	public String getOperatorSymbol() {
		return operatorSymbol;
	}

	public void setOperatorSymbol(String operatorSymbol) {
		this.operatorSymbol = operatorSymbol;
	}

	int a;
	int b;
	int result;
	
	String exceptionMessage;

	public void setExceptionMessage(String exceptionMessage) {
		this.exceptionMessage = exceptionMessage;
	}

	public String getExceptionMessage() {
		return this.exceptionMessage;
	}

	public int getResult() {
		return result;
	}

	public void setResult(int result) {
		this.result = result;
	}
	
	public int getA() {
		return a;
	}

	public int getB() {
		return b;
	}

	public void setA(int a) {
		this.a = a;
	}

	public void setB(int b) {
		this.b = b;
	}

	public abstract void a_op_b() throws Exception;
}

//加模型
class A_Add_B_Model extends A_Op_B_Model {

	A_Add_B_Model() {
		this.operatorSymbol = "+";
	}

	public void a_op_b() {
		result = a + b;
	}

	public void dealException(Exception e) {
		this.exceptionMessage = "不可能发生";
	}
}	
//减模型
class A_Subtract_B_Model extends A_Op_B_Model {

	A_Subtract_B_Model() {
		this.operatorSymbol = "-";
	}
	public void a_op_b() {
		result = a - b;
	}

	public void dealException(Exception e) {
		this.exceptionMessage = "不可能发生";
	}
	
}
//乘模型
class A_Multiply_B_Model extends A_Op_B_Model {
	A_Multiply_B_Model() {
		this.operatorSymbol = "*";
	}
	public void a_op_b() {
		result = a * b;
	}

	public void dealException(Exception e) {
		this.exceptionMessage = "不可能发生";
	}
	
};
//除模型
class A_Divide_B_Model extends A_Op_B_Model {

	A_Divide_B_Model() {
		this.operatorSymbol = "/";
	}
	public void a_op_b() throws Exception {
		if (a % b != 0) {
			throw new Exception("不能整除");
		}
		result = a / b;
	}

	public void dealException(Exception e) {
		this.exceptionMessage = e.getMessage();
	}
	
}

class A_Op_B_View implements A_Op_B_Concept {

	/**
	 * 视图可选用的实体模型 +、-、*、/
	 */
	Map<String, A_Op_B_Model> opMap = new HashMap<String, A_Op_B_Model>();

	{
		A_Op_B_Model[] models = new A_Op_B_Model[]{
				new A_Add_B_Model(),
				new A_Subtract_B_Model(),
				new A_Multiply_B_Model(),
				new A_Divide_B_Model()
		};
		for (int i = 0; i < models.length; i++) {
			opMap.put(models[i].getOperatorSymbol(), models[i]);
		}
	}

	
	A_Op_B_Model model; //视图使用一个模型
	
	public void readA() {
		int num = Util.readInt("a = ");
		model.setA(num);
	}

	public void readB() {
		int num = Util.readInt("b = ");
		model.setB(num);
	}

	public void readOp() throws Exception {
		String op = Util.readString("op = ");
		model = opMap.get(op);
		if (model == null) {
			throw new Exception("不识别的运算符[" + op + "]， 可以的运算符如下： " + opMap.keySet());
		}
	}
	
	/**
	 * 视图的计算， 依赖于模型的计算
	 * @throws Exception 
	 */
	public void a_op_b() throws Exception {
		readOp();
		
		readA();
		readB();
		
		try {
			model.a_op_b();
			showResult();
		} catch (Exception e) {
			dealException(e);
		}
	}
	
	public void showResult() {
		System.out.println("a " + model.getOperatorSymbol() + " b = " +
			"" + model.getA() + " " + model.getOperatorSymbol() + " " + model.getB() + " = " +
			"" + model.getResult());
	}

	public A_Op_B_Model getModel() {
		return model;
	}

	public void setModel(A_Op_B_Model model) {
		this.model = model;
	}

	public void showExceptionMessage() {
		System.out.println("*************ERROR************");
		System.out.println(this.model.getExceptionMessage());
		System.out.println("******************************");
	}
	
	public void dealException(Exception e) {
		model.dealException(e);
		showExceptionMessage();
	}
}

/*=========================================*\
	step 3 安装驱动 ---驱动实体在计算机上运行
	
	把实体组织起来执行
\*=========================================*/
public class Drive {

	A_Op_B_View view = new A_Op_B_View();

	public void drive() {
		for (int i=0; ; i++) {
			System.out.println("=============================");
			try{	
				view.a_op_b();
			} catch (Exception e) {
				System.out.println(e.getMessage());
				continue;
			}
		}
	}
	
	public static void main(String[] args) {
		Drive drive = new Drive();
		drive.drive();
	}
}


/**
 * 工具类
 * @author yanchangyou
 *
 */
class Util {
	public static int readInt(String msg) {
		System.out.print(msg);
		int result = -1;
		Scanner scanner = new Scanner(System.in);
		try {
			result = scanner.nextInt();
		} catch (Exception e) {
			System.out.println("输入整数错误，重写输入");
			result = readInt(msg);
		}
		return result;
	}

	public static String readString(String msg) {
		System.out.print(msg);
		String result = null;
		Scanner scanner = new Scanner(System.in);
		result = scanner.nextLine();
		return result;
	}
}