java实现简易计算器（四则运算详细分析）

简易计算器（四则运算规律）

针对不同的需求，通过四则运算规律实现以下两种计算器：
1.main（）中自定义初始值，规定两个操作数和操作运算符（+、-、*、/）
2.自定义功能类（FourCalc.java）对于输入不同的操作运算符（+、-、x、/），在测试类（TestCalc.java）中输出结果
注意：在计算器的制作过程中，"+、-、*"三种运算符一般运算结果为整型数，而 "/"运算结果一般为小数，在以下范例中会将两种不同的操作结果给予显示

第一种：规定初始值类型计算器

（类型一）经过四种操作运算符，输出结果依然是浮点型

方法一：

在main（）中创建FourCalc对象，分别定义"+、-、*、/"四种运算符的输出，规定初始值，输出结果

package practise;

class FourCalc{
	//第一个操作数
	public double op1;
	//运算符
	public char sign;
	//第二个操作数
	public double op2;
	public double calc(){
		//声明返回变量
		double rtn=0;
		//根据运算符，计算
		switch (this.sign) {
		case '+':
			rtn=this.op1+this.op2;
			break;
		case '-':
			rtn=this.op1-this.op2;
			break;
		case '*':
			rtn=this.op1*this.op2;
			break;
		case '/':
			rtn=this.op1/this.op2;
			break;
		default:
			System.out.println("运算符有误！");
			break;
		}
		//返回
		return rtn;
	}
}
public class TestExercise03 {

	public static void main(String[] args) {
		//创建计算器
		FourCalc c1 = new FourCalc();
		//+ 1+2
		//设置op1
		c1.op1=1;
		//设置运算符
		c1.sign='+';
		//设置op2
		c1.op2=2;
		//计算并输出,char--->String:String.valueOf(c1.sign)
		System.out.println(c1.op1+"+"+c1.op2+"="+c1.calc());
		//+ 3-1
		//设置op1
		c1.op1=3;
		//设置运算符
		c1.sign='-';
		//设置op2
		c1.op2=1;
		//计算并输出
		System.out.println(c1.op1+"-"+c1.op2+"="+c1.calc());
		//+ 3*2
		//设置op1
		c1.op1=3;
		//设置运算符
		c1.sign='*';
		//设置op2
		c1.op2=2;
		//计算并输出
		System.out.println(c1.op1+"*"+c1.op2+"="+c1.calc());
		//+ 4/3
		//设置op1
		c1.op1=4;
		//设置运算符
		c1.sign='/';
		//设置op2
		c1.op2=3;
		//计算并输出
		System.out.println(c1.op1+"/"+c1.op2+"="+c1.calc());
	}
}

方法二：

与方法一的不同之处在于对于char类型的变量，sign变量没有通过手动输入"+、-、*、/"四种运算符，而是通过调用String.valueOf(c1.sign)
原型：valueOf(char c)
返回 char 参数的字符串表示形式。
可以将char类型的sign通过方法调用变成String类型输出

package practise;

class FourCalc{
	//第一个操作数
	public double op1;
	//运算符
	public char sign;
	//第二个操作数
	public double op2;
	public double calc(){
		//声明返回变量
		double rtn=0;
		//根据运算符，计算
		switch (this.sign) {
		case '+':
			rtn=this.op1+this.op2;
			break;
		case '-':
			rtn=this.op1-this.op2;
			break;
		case '*':
			rtn=this.op1*this.op2;
			break;
		case '/':
			rtn=this.op1/this.op2;
			break;
		default:
			System.out.println("运算符有误！");
			break;
		}
		//返回
		return rtn;
	}
}
public class TestExercise03 {

	public static void main(String[] args) {
		//创建计算器
		FourCalc c1 = new FourCalc();
		//+ 1+2
		//设置op1
		c1.op1=1;
		//设置运算符
		c1.sign='+';
		//设置op2
		c1.op2=2;
		//计算并输出,char--->String:String.valueOf(c1.sign)
		System.out.println(c1.op1+String.valueOf(c1.sign)+c1.op2+"="+c1.calc());
		//+ 3-1
		//设置op1
		c1.op1=3;
		//设置运算符
		c1.sign='-';
		//设置op2
		c1.op2=1;
		//计算并输出
		System.out.println(c1.op1+String.valueOf(c1.sign)+c1.op2+"="+c1.calc());
		//+ 3*2
		//设置op1
		c1.op1=3;
		//设置运算符
		c1.sign='*';
		//设置op2
		c1.op2=2;
		//计算并输出
		System.out.println(c1.op1+String.valueOf(c1.sign)+c1.op2+"="+c1.calc());
		//+ 4/3
		//设置op1
		c1.op1=4;
		//设置运算符
		c1.sign='/';
		//设置op2
		c1.op2=3;
		//计算并输出
		System.out.println(c1.op1+String.valueOf(c1.sign)+c1.op2+"="+c1.calc());
	}
}

效果如下：

（类型二）"+、-、*、/“输出结果为整型数，”/"输出结果为浮点型

这类方法的核心在于返回值类型的转变
1.返回变量rtn的数据类型转变为int型时：（java.lang.Integer）
rtn=Integer.parseInt(String.valueOf(this.op1)+String.valueOf(this.op2));
原型：parseInt(String s)
将字符串参数作为有符号的十进制整数进行解析。
2.返回变量rtn的数据类型转变为double型时：（java.lang.Double）
rtn=Double.parseDouble(String.valueOf(this.op1)+String.valueOf(this.op2));
原型：parseDouble(String s)
返回一个新的 double 值，该值被初始化为用指定 String 表示的值，这与 Double 类的 valueOf 方法一样。
注意：如果这个方法的代码直接是拷贝于上面的方法二，则要将int、double的数据类型改成Object引用类型，来源于父类

package practise;

class FourCalcTwo{
	//第一个操作数
	public Object op1;
	//运算符
	public char sign;
	//第二个操作数
	public Object op2;
	public Object calc(){
		//声明返回变量
		Object rtn=0;
		//根据运算符，计算
		switch (this.sign) {
		case '+'://obj->String->int
			rtn=Integer.parseInt(String.valueOf(this.op1)+String.valueOf(this.op2));
			break;
		case '-':
			rtn=Integer.parseInt(String.valueOf(this.op1)+String.valueOf(this.op2));
			break;
		case '*':
			rtn=Integer.parseInt(String.valueOf(this.op1)+String.valueOf(this.op2));
			break;
		case '/'://obj->String->Double
			rtn=Double.parseDouble(String.valueOf(this.op1)+String.valueOf(this.op2));
			break;
		default:
			System.out.println("运算符有误！");
			break;
		}
		//返回
		return rtn;
	}
}
public class TestExercise03_v2 {

	public static void main(String[] args) {
		//创建计算器
		FourCalcTwo c1 = new FourCalcTwo();
		//+ 1+2
		//设置op1
		c1.op1=1;
		//设置运算符
		c1.sign='+';
		//设置op2
		c1.op2=2;
		//计算并输出,char--->String:String.valueOf(c1.sign)
		System.out.println(c1.op1+String.valueOf(c1.sign)+c1.op2+"="+c1.calc());
		//+ 3-1
		//设置op1
		c1.op1=3;
		//设置运算符
		c1.sign='-';
		//设置op2
		c1.op2=1;
		//计算并输出
		System.out.println(c1.op1+String.valueOf(c1.sign)+c1.op2+"="+c1.calc());
		//+ 3*2
		//设置op1
		c1.op1=3;
		//设置运算符
		c1.sign='*';
		//设置op2
		c1.op2=2;
		//计算并输出
		System.out.println(c1.op1+String.valueOf(c1.sign)+c1.op2+"="+c1.calc());
		//+ 4/3
		//设置op1
		c1.op1=4;
		//设置运算符
		c1.sign='/';
		//设置op2
		c1.op2=3;
		//计算并输出
		System.out.println(c1.op1+String.valueOf(c1.sign)+c1.op2+"="+c1.calc());
	}

}

效果如下：

第二种：从键盘输入初始值类型计算器

"+、-、*、/“输出结果为整型数，”/"输出结果为浮点型，并保留两位小数

方法如下：

/**
*FourCalc.java（功能类）
*/
package exercise;

import java.text.DecimalFormat;
import java.util.Scanner;
/**
 * 面向对象的思想求，求四则运算（）
 * @author Administrator
 *
 */
public class FourCalc {
	//第一个操作数
	public int op1;
	//符号运算符
	public char sgn = ' ';
	//第二个运算符
	public int op2;
	/**
	 * int 整型数（+、-、*）运算
	 * @return 运算结果
	 */
	public String calc(){
		//声明一个返回变量
		int rtn = 0;
		//判断
		switch (sgn) {
		case '+':
			rtn = op1+op2;
			System.out.println(op1+"+"+op2+"="+rtn);
			break;
		case '-':
			rtn = op1-op2;
			System.out.println(op1+"-"+op2+"="+rtn);
			break;
		case '*':
			rtn = op1*op2;
			System.out.println(op1+"*"+op2+"="+rtn);
			break;
		default:
			break;
		}
		return "当前的运算结果为："+rtn;
	}
	public String dCalc(){
		//声明一个返回变量
		double rtn = 0;
		//创建DecimalFormat对象，并指定格式化串
		DecimalFormat df = new DecimalFormat("#.##");
		//判断是否是除法
		if(sgn=='/'){
			rtn = (double)op1/op2;
			System.out.println(op1+"/"+op2+"="+df.format(rtn));
		}
		//返回
		return "当前的运算结果为："+df.format(rtn);
	}	
}

/**
*TestCalc.java（测试类）
*/
package exercise;

import java.util.Scanner;

public class TestCalc {

	public static void main(String[] args) {
		//创建一个FourCalc对象
		FourCalc c = new FourCalc();
		//输出
		//判断输出是整型数值还是浮点型数值
		//创建Scanner对象
		Scanner scan = new Scanner(System.in);
		//提示
		System.out.println("请输入第一个操作数:");
		c.op1 = scan.nextInt();
		System.out.println("请输入运算符号:");
		c.sgn = scan.next().charAt(0);
		System.out.println("请输入第二个操作数:");
		c.op2 = scan.nextInt();
		switch(c.sgn){
			case '+':
			case '-':
			case '*':
				System.out.println(c.calc());
				break;
			case '/':
				System.out.println(c.dCalc());
				break;
			default:
				break;
		}
	}
}

效果如下：