java乘除
Ⅰ java程序，用图形实现乘除运算
简易的计算器代码如下，请参照：
importjava.awt.BorderLayout;
importjava.awt.GridLayout;
importjava.awt.event.ActionEvent;
importjava.awt.event.ActionListener;
importjava.awt.event.KeyAdapter;
importjava.awt.event.KeyEvent;
importjavax.swing.JButton;
importjavax.swing.JFrame;
importjavax.swing.JPanel;
importjavax.swing.JTextField;
/**
*计算器类
*
*@authorAdministrator
*
*/
{
=3868243398506940702L;
//文本框
privateJTextFieldresult;
//按钮数组
privateJButton[]buttons;
//按钮文本
privatefinalString[]characters={"7","8","9","/","4","5","6",
"*","1","2","3","-","0",".","=","+"};
//是否为第一个输入的数字
privatebooleanisFirstDigit=true;
//运算结果
privatedoubleresultNum=0.0;
//运算符
privateStringoperator="=";
publicCalculator(Stringtitle){
//设置标题栏
super(title);
//初始化各组件
init();
//注册各组件监听器
registerListener();
//显示窗体
setVisible(true);
}
/**
*初始化各组件
*/
privatevoidinit(){
//常用属性初始化
setSize(220,200);
setResizable(false);
setLocationRelativeTo(null);
setDefaultCloseOperation(EXIT_ON_CLOSE);
/*文本框对象初始化*/
result=newJTextField("0");
//文本右对齐
result.setHorizontalAlignment(JTextField.RIGHT);
//设置是否可编辑
result.setEditable(false);
/*按钮初始化*/
buttons=newJButton[characters.length];
for(inti=0;i<buttons.length;i++){
buttons[i]=newJButton(characters[i]);
buttons[i].setFocusable(false);//不允许按钮定位焦点
}
/*将文本框与按钮添加到窗体中*/
add(result,BorderLayout.NORTH);
JPanelpnl=newJPanel(newGridLayout(4,4,5,5));
for(JButtonjButton:buttons){
pnl.add(jButton);
}
add(pnl);
this.getContentPane().setFocusable(true);
}
/**
*注册监听器
*/
privatevoidregisterListener(){
for(JButtonjButton:buttons){
jButton.addActionListener(this);
}
//注册键盘事件
this.getContentPane().addKeyListener(newKeyAdapter(){
@Override
publicvoidkeyPressed(KeyEvente){
Stringtext=String.valueOf(e.getKeyChar());
if(Character.isDigit(text.charAt(0))||".".equals(text)){//数字或小数点
handleNumber(text);
}elseif("+-*/=".indexOf(text)!=-1){//运算符
handleOperator(text);
}elseif(e.getKeyCode()==8){//退格键
Stringtmp=result.getText().trim();
if(tmp.length()==1){
result.setText("0");
isFirstDigit=true;
}else{
result.setText(tmp.substring(0,tmp.length()-1));
}
}
}
});
}
@Override
publicvoidactionPerformed(ActionEvente){
JButtonbtn=(JButton)e.getSource();
Stringtext=btn.getText().trim();
if(Character.isDigit(text.charAt(0))||".".equals(text)){//处理数字和小数点
handleNumber(text);
}else{//处理运算符
handleOperator(text);
}
}
/**
*处理数字和小数点
*
*@paramtext
*/
privatevoidhandleNumber(Stringtext){
if(isFirstDigit){//第一次输入
if(".".equals(text)){
this.result.setText("0.");
}else{
this.result.setText(text);
}
}elseif("0".equals(text)&&"0".equals(this.result.getText())){
isFirstDigit=true;
return;
}elseif(".".equals(text)&&this.result.getText().indexOf(".")==-1){
this.result.setText(this.result.getText()+".");
}elseif(!".".equals(text)){
this.result.setText(this.result.getText()+text);
}
isFirstDigit=false;
}
/**
*处理运算符
*
*@paramtext
*/
privatevoidhandleOperator(Stringtext){
switch(operator){//处理各项运算适用于JDK1.7版本的
case"+":
resultNum+=Double.parseDouble(this.result.getText());
break;
case"-":
resultNum-=Double.parseDouble(this.result.getText());
break;
case"*":
resultNum*=Double.parseDouble(this.result.getText());
break;
case"/":
resultNum/=Double.parseDouble(this.result.getText());
break;
case"=":
resultNum=Double.parseDouble(this.result.getText());
break;
}
//将文本框的值修改为运算结果
this.result.setText(String.valueOf(resultNum));
//将点击的运算符放入operator保存
operator=text;
//下一个数字第一次点击
isFirstDigit=true;
}
publicstaticvoidmain(String[]args){
newCalculator("MyCalculator");
}
}
运行结果如下：
Ⅱ 加减乘除运算（Java)
实际上这相当于javascript的eval方法，以下是该方法的java实现：
//Eval.java
import java.util.ArrayList;
import java.util.List;
import java.util.Stack;
public class Eval {
public int eval(String exp){
List<String> list = infixExpToPostExp(exp);//转化成后缀表达式
return doEval(list);//真正求值
}
//遇到操作符压栈，遇到表达式从后缀表达式中弹出两个数，计算出结果，压入堆栈
private int doEval(List<String> list) {
Stack<String> stack = new Stack<String>();
String element;
int n1,n2,result;
try{
for(int i = 0; i < list.size();i++){
element = list.get(i);
if(isOperator(element)){
n1 = Integer.parseInt(stack.pop());
n2 = Integer.parseInt(stack.pop());
result = doOperate(n1,n2,element);
stack.push(new Integer(result).toString());
}else{
stack.push(element);
}
}
return Integer.parseInt(stack.pop());
}catch(RuntimeException e){
throw new IllegalExpressionException(e.getMessage());
}
}
private int doOperate(int n1, int n2, String operator) {
if(operator.equals("+"))
return n1 + n2;
else if(operator.equals("-"))
return n1 - n2;
else if(operator.equals("*"))
return n1 * n2;
else
return n1 / n2;
}
private boolean isOperator(String str){
return str.equals("+") || str.equals("-") || str.equals("*") || str.equals("/");
}
private List<String> infixExpToPostExp(String exp){//将中缀表达式转化成为后缀表达式
List<String> postExp = new ArrayList<String>();//存放转化的后缀表达式的链表
StringBuffer numBuffer = new StringBuffer();//用来保存一个数的
Stack<Character> opStack = new Stack<Character>();//操作符栈
char ch,preChar;
opStack.push('#');
try{
for(int i = 0; i < exp.length();){
ch = exp.charAt(i);
switch(ch){
case '+':
case '-':
case '*':
case '/':
preChar = opStack.peek();
// 如果栈里面的操作符优先级比当前的大，则把栈中优先级大的都添加到后缀表达式列表中
while(priority(preChar) >= priority(ch)){
postExp.add(""+preChar);
opStack.pop();
preChar = opStack.peek();
}
opStack.push(ch);
i++;
break;
case '(':
// 左括号直接压栈
opStack.push(ch);
i++;
break;
case ')':
// 右括号则直接把栈中左括号前面的弹出，并加入后缀表达式链表中
char c = opStack.pop();
while(c != '('){
postExp.add("" + c);
c = opStack.pop();
}
i++;
break;
// #号，代表表达式结束，可以直接把操作符栈中剩余的操作符全部弹出，并加入后缀表达式链表中
case '#':
char c1;
while(!opStack.isEmpty()){
c1 = opStack.pop();
if(c1 != '#')
postExp.add("" + c1);
}
i++;
break;
//过滤空白符
case ' ':
case '\t':
i++;
break;
// 数字则凑成一个整数，加入后缀表达式链表中
default:
if(Character.isDigit(ch)){
while(Character.isDigit(ch)){
numBuffer.append(ch);
ch = exp.charAt(++i);
}
postExp.add(numBuffer.toString());
numBuffer = new StringBuffer();
}else{
throw new IllegalExpressionException("illegal operator");
}
}
}
}catch(RuntimeException e){
throw new IllegalExpressionException(e.getMessage());
}
return postExp;
}
private int priority(char op){//定义优先级
switch(op){
case'+':
case'-':
return 1;
case'*':
case'/':
return 2;
case'(':
case'#':
return 0;
}
throw new IllegalExpressionException("Illegal operator");
}
}
Main.java 主函数所在类
public class Main
{
public static void main(String[] args) {
try {
InputStreamReader isr=new InputStreamReader(System.in);
BufferedReader br=new BufferedReader(isr);
String exp=br.readLine();
int result = eval.eval(exp);
System.out.println(result);
}
} catch (IOException e) {
// TODO Auto-generated catch block
e.printStackTrace();
}
}
}
IllegalExpressionException异常类
public class IllegalExpressionException extends RuntimeException{
public IllegalExpressionException(){
}
public IllegalExpressionException(String info){
super(info);
}
}
Ⅲ 如何利用Java中的BigDecimal实现加减乘除功能
仅做参考：
importjava.math.BigDecimal;
/**
*由于Java的简单类型不能够精确的对浮点数进行运算，这个工具类提供精
*确的浮点数运算，包括加减乘除和四舍五入。
*/
publicclassArith{//默认除法运算精度
privatestaticfinalintDEF_DIV_SCALE=10;//这个类不能实例化
privateArith(){
}
/**
*提供精确的加法运算。
*@paramv1被加数
*@paramv2加数
*@return两个参数的和
*/
publicstaticdoubleadd(doublev1,doublev2){
BigDecimalb1=newBigDecimal(Double.toString(v1));
BigDecimalb2=newBigDecimal(Double.toString(v2));
returnb1.add(b2).doubleValue();
}
/**
*提供精确的减法运算。
*@paramv1被减数
*@paramv2减数
*@return两个参数的差
*/
publicstaticdoublesub(doublev1,doublev2){
BigDecimalb1=newBigDecimal(Double.toString(v1));
BigDecimalb2=newBigDecimal(Double.toString(v2));
returnb1.subtract(b2).doubleValue();
}
/**
*提供精确的乘法运算。
*@paramv1被乘数
*@paramv2乘数
*@return两个参数的积
*/
publicstaticdoublemul(doublev1,doublev2){
BigDecimalb1=newBigDecimal(Double.toString(v1));
BigDecimalb2=newBigDecimal(Double.toString(v2));
returnb1.multiply(b2).doubleValue();
}
/**
*提供（相对）精确的除法运算，当发生除不尽的情况时，精确到
*小数点以后10位，以后的数字四舍五入。
*@paramv1被除数
*@paramv2除数
*@return两个参数的商
*/
publicstaticdoublediv(doublev1,doublev2){
returndiv(v1,v2,DEF_DIV_SCALE);
}
/**
*提供（相对）精确的除法运算。当发生除不尽的情况时，由scale参数指
*定精度，以后的数字四舍五入。
*@paramv1被除数
*@paramv2除数
*@paramscale表示表示需要精确到小数点以后几位。
*@return两个参数的商
*/
publicstaticdoublediv(doublev1,doublev2,intscale){
if(scale<0){
(
"");
}
BigDecimalb1=newBigDecimal(Double.toString(v1));
BigDecimalb2=newBigDecimal(Double.toString(v2));
returnb1.divide(b2,scale,BigDecimal.ROUND_HALF_UP).doubleValue();
}
/**
*提供精确的小数位四舍五入处理。
*@paramv需要四舍五入的数字
*@paramscale小数点后保留几位
*@return四舍五入后的结果
*/
publicstaticdoubleround(doublev,intscale){
if(scale<0){
("");
}
BigDecimalb=newBigDecimal(Double.toString(v));
BigDecimalone=newBigDecimal("1");
returnb.divide(one,scale,BigDecimal.ROUND_HALF_UP).doubleValue();
}
};
Ⅳ 用java怎样编写加减乘除，从键盘输入，例如：1+2按回车之后可以运算，小数整数都可以
public static void main(String[] args){
Scanner sc=new Scanner(System.in);
System.out.println("请输入第一个数:");
double n1 = sc.nextDouble();
System.out.println("请输入运算符:");
String s = sc.next();
System.out.println("请输入第二个数:");
double n2 = sc.nextDouble();
if(s.equals("+")){
System.out.print(n1+"+"+n2+" = "+(n1+n2));
}else if(s.equals("-")){
System.out.print(n1+"+"+n2+" = "+(n1-n2));
}else if(s.equals("*")){
System.out.print(n1+"*"+n2+" = "+(n1*n2));
}else if(s.equals("/")){
if(n2==0){
System.out.println("除数不能等于0");
}else{
System.out.print(n1+"/"+n2+" = "+(n1/n2));
}
}else{
System.out.println("运算符输入错误,请重新输入。");
}
}
Ⅳ 如何使用java实现加减乘除运算
java有内置的运算符
+ - * /
int a=1,b=2;
a+b;
a-b;
a*b;
a/b;
Ⅵ java加减乘除是什么类
java中实现加减乘除的类是java.math.BigDecimal类. BigDecimal 类提供以下操作：算术、标度操作、舍入、比较、哈希算法和格式转换。
加法运算：调用BigDecimal类的add方法即可
BigDecimalb1=newBigDecimal("1");
BigDecimalb2=newBigDecimal("2");
BigDecimalresult=b1.add(b2);//加法
System.out.println(result);减法运算：调用BigDecimal类的subtract方法即可
BigDecimalb1=newBigDecimal(3.2);
BigDecimalb2=newBigDecimal(1.6);
BigDecimalresult=b1.subtract(b2);//减法
System.out.println(result);
乘法运算：调用BigDecimal类的multiply方法即可
BigDecimalb1=newBigDecimal(9);
BigDecimalb2=newBigDecimal(8.2);
BigDecimalresult=b1.multiply(b2);//乘法
System.out.println(result);
除法运算：调用BigDecimal类的divide方法即可。
注意: 除法运算存在除不尽的情况,比如1.0/3=0.333333.. 我们需要指定小数点后面的长度,以及有效的舍入模式(例如四舍五入模式).
BigDecimalb1=newBigDecimal("1");
BigDecimalb2=newBigDecimal("3");
intscale=5;//scale指定小数点后面的位数为5位
doubleresult=b1.divide(b2,scale,BigDecimal.ROUND_HALF_UP).doubleValue();//除法
//BigDecimal.ROUND_HALF_UP表示四舍五入
System.out.println(result);备注：
1：BigDecimal的构造参数有很多，但浮点类型建议转换成字符串类型, 避免精度的丢失.
doubled1=0.001;//浮点类型
Strings1=Double.toString(d1);//转成字符串
BigDecimalb1=newBigDecimal(s1);//使用字符串作为构造参数
2：BigDecimal类, 内存占用比基本类型多,并且为了计算的精度,速度比double慢一点.所以,只有在需要精确计算的情况下,才使用BigDecimal类进行. 普通运算,还是多使用+-*/运算符,位运算符等.
Ⅶ 怎么用java编程，实现分数的加减乘除运算
1、打开eclipse，创建一个Java工程，在此工程里新建一个类；
2、在新建的类中，添加4个运算类；
3、在主方法中调用对应的方法即可完成分数的加减乘除运算了。
具体实现代码如下：
public class Demo {
public static void main(String[] args) {
System.out.println(jia(1, 2));
System.out.println(jian(1, 2));
System.out.println(cheng(1, 2));
System.out.println(chu(1, 2));
}
//加法运算
private static float jia(float x,float y) {
return x + y;
}
//减法运算
private static float jian(float x,float y) {
return x - y;
}
//乘法运算
private static float cheng(float x,float y) {
return x * y;
}
//除法运算
private static float chu(float x,float y) {
return x / y;
}
}
Ⅷ java如何实现3个 个位数的加减乘除运算
publicclassParamDemo{
publicstaticvoidmain(String[]args){
Map<String,Integer>map=newHashMap<>();
map.put("+",1);
map.put("-",1);
map.put("*",2);
map.put("/",2);
Scannerscanner=newScanner(System.in);
intnum1=scanner.nextInt();
intnum2=scanner.nextInt();
intnum3=scanner.nextInt();
Stringop1=scanner.next();
Stringop2=scanner.next();
//此时证明第一个操作符优先级大于第二个操作符
if(map.get(op1)-map.get(op2)>=0){
inttmpNumber=operateNum(op1,num1,num2);
System.out.println(operateNum(op2,tmpNumber,num3));
}else{
inttmpNumber=operateNum(op2,num2,num3);
System.out.println(operateNum(op1,num1,tmpNumber));
}
scanner.close();
}
privatestaticintoperateNum(Stringoperator,intnum1,intnum2){
switch(operator){
case"+":
returnnum1+num2;
case"-":
returnnum1-num2;
case"*":
returnnum1*num2;
case"/":
returnnum1/num2;
default:
return0;
}
}
}
Ⅸ Java的加减乘除问题
//JAVA编程:四则运算(接收用户输入的2个操作数，和运算符)，计算之后，输出结果~~~~
import java.util.Scanner;
public class 四则运算 {
public static void main(String[] args) {
Scanner sc = new Scanner(System.in);
System.out.print("请输入第一个数字：");
int a = sc.nextInt();
System.out.print("请输入运算符号：");
String str = sc.next();
char ch = str.charAt(0);
System.out.print("请输入第二个数字：");
int b = sc.nextInt();
switch(ch)
{
case '+':
System.out.println(a+"+"+ b + "="+(a+b));
break;
case '-':
System.out.println(a+"-"+ b+ "="+(a-b));
break;
case '*':
System.out.println(a+"*"+ b+ "="+(a*b));
break;
case '/':
if(b==0){
System.out.println("被除数为零，运算无意义!");
break;
}
else {
System.out.println(a+"/"+ b+ " = "+(a/b));
break;
}
default:
System.out.println("运算符是无意义字符！");
break;
}
}
}
望采纳~~~~~~~~
Ⅹ java的加减乘除运算
使用BigDecimal并且一定要用String来够造。
实现方法如下：
import java.math.BigDecimal;
/**
* 由于Java的简单类型不能够精确的对浮点数进行运算，这个工具类提供精
* 确的浮点数运算，包括加减乘除和四舍五入。
*/
public class Arith{
//默认除法运算精度
private static final int DEF_DIV_SCALE = 10;
//这个类不能实例化
private Arith(){
}
/**
* 提供精确的加法运算。
* @param v1 被加数
* @param v2 加数
* @return 两个参数的和
*/
public static double add(double v1,double v2){
BigDecimal b1 = new BigDecimal(Double.toString(v1));
BigDecimal b2 = new BigDecimal(Double.toString(v2));
return b1.add(b2).doubleValue();
}
/**
* 提供精确的减法运算。
* @param v1 被减数
* @param v2 减数
* @return 两个参数的差
*/
public static double sub(double v1,double v2){
BigDecimal b1 = new BigDecimal(Double.toString(v1));
BigDecimal b2 = new BigDecimal(Double.toString(v2));
return b1.subtract(b2).doubleValue();
}
/**
* 提供精确的乘法运算。
* @param v1 被乘数
* @param v2 乘数
* @return 两个参数的积
*/
public static double mul(double v1,double v2){
BigDecimal b1 = new BigDecimal(Double.toString(v1));
BigDecimal b2 = new BigDecimal(Double.toString(v2));
return b1.multiply(b2).doubleValue();
}
/**
* 提供（相对）精确的除法运算，当发生除不尽的情况时，精确到
* 小数点以后10位，以后的数字四舍五入。
* @param v1 被除数
* @param v2 除数
* @return 两个参数的商
*/
public static double div(double v1,double v2){
return div(v1,v2,DEF_DIV_SCALE);
}
/**
* 提供（相对）精确的除法运算。当发生除不尽的情况时，由scale参数指
* 定精度，以后的数字四舍五入。
* @param v1 被除数
* @param v2 除数
* @param scale 表示表示需要精确到小数点以后几位。
* @return 两个参数的商
*/
public static double div(double v1,double v2,int scale){
if(scale<0){
throw new IllegalArgumentException(
"The scale must be a positive integer or zero");
}
BigDecimal b1 = new BigDecimal(Double.toString(v1));
BigDecimal b2 = new BigDecimal(Double.toString(v2));
return b1.divide(b2,scale,BigDecimal.ROUND_HALF_UP).doubleValue();
}
/**
* 提供精确的小数位四舍五入处理。
* @param v 需要四舍五入的数字
* @param scale 小数点后保留几位
* @return 四舍五入后的结果
*/
public static double round(double v,int scale){
if(scale<0){
throw new IllegalArgumentException(
"The scale must be a positive integer or zero");
}
BigDecimal b = new BigDecimal(Double.toString(v));
BigDecimal one = new BigDecimal("1");
return b.divide(one,scale,BigDecimal.ROUND_HALF_UP).doubleValue();
}
};