java四则运算
Posted
tags:
篇首语：本文由小常识网(cha138.com)小编为大家整理，主要介绍了java四则运算相关的知识，希望对你有一定的参考价值。
老师出的题，题意是使用布局分方式做四则运算，做完之后我发现在事件监听上出了点问题，这方面还是没有搞懂
按“+”这个按钮就是把text1+text2，希望高手能指点一下，谢谢了。
两个text 1个label 输出结果用的，还有就是but + - * / 这四个按钮。
我写的代码如下
import javax.swing.*;
import java.awt.*;
import java.awt.event.*;
public class Buju extends JFrame
JTextField text1,text2;
JButton but1,but2,but3,but4;
JLabel lab1;
public Buju()
super("布局模式");
setBounds(20,20,500,400);
Container contentPane=getContentPane();
contentPane.setLayout(new BorderLayout(10,10));
setDefaultCloseOperation(JFrame.EXIT_ON_CLOSE);
JPanel jp1=new JPanel(new FlowLayout());
JPanel jp2=new JPanel(new FlowLayout());
text1=new JTextField(5);
jp2.add(text1);
text2=new JTextField(5);
jp2.add(text2);
lab1=new JLabel("输出结果");
jp2.add(lab1);
but1=new JButton("+");
jp1.add(but1);
but2=new JButton("-");
jp1.add(but2);
but3=new JButton("*");
jp1.add(but3);
but4=new JButton("/");
jp1.add(but4);
contentPane.add(jp2,BorderLayout.CENTER);
contentPane.add(jp1,BorderLayout.SOUTH);
private void but1ActionPerformed(java.awt.event.ActionEvent evt) //这里就不对劲了，也不知道该怎么写了。
double x,y,s;
String str;
x=Double.valueOf(text1.getText());
y=Double.valueOf(text2.getText());
s=x+y;
str=String.valueOf(s);
lab1.setText(str);
public static void main(String[] args)
Buju bj=new Buju();
bj.setVisible(true);
import java.awt.event.*;
import javax.swing.*;
public class calculator extends JFrame implements ActionListener
private boolean i=true,clickable = true ;//这里的clickabel 是用来判断小数点的 如果有小数点的话 clickable则为false就不对小数点进行添加了 i在下面有解释
private double value=0; //这个就是显示出来的值了
String operate = "="; //操作数 默认情况下是=号
JFrame jframe=new JFrame("计算机");
JTextField text1=new JTextField("0");
JButton back = new JButton("退格");
JButton daoshu = new JButton("1/x");
JButton remain = new JButton("%");
JButton PI = new JButton("PI"); //显示圆周率小数点后7位
JButton square = new JButton("x^2");
JButton cube = new JButton("x^3");
JButton plu=new JButton("+");
JButton min=new JButton("-");
JButton mul=new JButton("*");
JButton equ=new JButton("=");
JButton div=new JButton("/");
JButton code=new JButton("+/-");
JButton point=new JButton(".");
JButton num1=new JButton("1");
JButton num2=new JButton("2");
JButton num3=new JButton("3");
JButton num4=new JButton("4");
JButton num5=new JButton("5");
JButton num6=new JButton("6");
JButton num7=new JButton("7");
JButton num8=new JButton("8");
JButton num9=new JButton("9");
JButton num0=new JButton("0");
JButton num00=new JButton("00");
JButton clear=new JButton("C");
calculator()
jframe.setSize(400, 400);
jframe.setDefaultCloseOperation(JFrame.EXIT_ON_CLOSE);
JPanel p=new JPanel();
p.setBackground(Color.gray);
p.setLayout(new GridLayout(5, 5)); //采用的布局方式为网格布局
PI.addActionListener(this);
daoshu.addActionListener(this);
remain.addActionListener(this);
square.addActionListener(this);
cube.addActionListener(this);
plu.addActionListener(this);
equ.addActionListener(this);
num1.addActionListener(this);
num2.addActionListener(this);
clear.addActionListener(this);
num3.addActionListener(this);
num4.addActionListener(this);
num5.addActionListener(this);
num6.addActionListener(this);
num7.addActionListener(this);
num8.addActionListener(this);
num9.addActionListener(this);
num0.addActionListener(this);
num00.addActionListener(this);
min.addActionListener(this);
code.addActionListener(this);
div.addActionListener(this);
point.addActionListener(this);
mul.addActionListener(this);
back.addActionListener(this);
jframe.add(p);
p.add(PI);
p.add(code);
p.add(daoshu);
p.add(back);
p.add(clear);
p.add(num7);
p.add(num8);
p.add(num9);
p.add(plu);
p.add(remain);
p.add(num4);
p.add(num5);
p.add(num6);
p.add(min);
p.add(square);
p.add(num1);
p.add(num2);
p.add(num3);
p.add(mul);
p.add(cube);
p.add(num0);
p.add(num00);
p.add(point);
p.add(div);
p.add(equ);
jframe.add(text1,"North");
jframe.setLocation(300, 300);
jframe.setVisible(true);
public void actionPerformed(ActionEvent evt)
String str1,str2;
Object soc=evt.getSource();
String s = evt.getActionCommand(); //获取按钮的数据
if(soc==back) //进行退格操作
str1=text1.getText();
int n=str1.length();
text1.setText(str1.substring(0,n-1));
str2 = text1.getText();
else if (s.equals("x^2"))
str1=text1.getText();
double k = Double.parseDouble(str1);
k *=k;
text1.setText(String.valueOf(k));
else if (s.equals("x^3"))
str1=text1.getText();
double k = Double.parseDouble(str1);
k =k*k*k;
text1.setText(String.valueOf(k));
else if(s.equals("PI")) //显示圆周率
double Pi=3.1415926;
String pi=String.valueOf(Pi);
text1.setText(pi);
else if(s.equals("+/-")) //变换正负号
double a = 0;
str1=text1.getText();
a=Double.parseDouble(str1.trim());
a=-1*a;
str1=String.valueOf(a);
text1.setText(str1);
else if(s.equals("1/x")) //求倒
str1=text1.getText();
double i = 1/Double.parseDouble(str1.trim());
String k = String.valueOf(i);
text1.setText(k);
else if(s.equals(".")) //小数点
clickable=true;
for (int i = 0; i < text1.getText().length(); i++)
if ('.' == text1.getText().charAt(i))
clickable=false;
break;
//第一层判断是否里面含有小数点;
if(clickable==true) //第二层判断
text1.setText(text1.getText()+".");
i=false;
else if(s.equals("C")) //清零 所有的数据变回初始值
value = 0;
text1.setText("0");
i=true;
operate = "=" ;
else if ('0' <= s.charAt(0) && s.charAt(0) <= '9' ) //若输入的为数字以及小数点的时候执行下面
if (i) //判断获得的command是否为操作符
text1.setText(s);
else
text1.setText(text1.getText() + s);
i = false;
else //若输入运算操作符的话则执行下面的代码
count(Double.parseDouble(text1.getText().trim())); //这里一开始调用 count()方法的话首先执行的是operate.equals("=")
//执行上个操作符的运算
operate = s;
i = true;
private void count(double a) //计算区域
if (operate.equals("+"))
value += a;
else if (operate.equals("-"))
value -= a;
else if (operate.equals("*"))
value *= a;
else if (operate.equals("/"))
value /= a;
else if (operate.equals("%"))
value %= a;
else if (operate.equals("="))
value = a;
text1.setText(Double.toString(value));
public static void main(String[] arg)
calculator cal=new calculator();
这是例子 你可以参考下~监听的 部分追问
我就监听部分不太会，而且从win32一下转到swing界面不太适应，突然找不着调的感觉，我也找过很多监听的例子，但是还是没有明白。
追答你有监听函数 那你总要去监听谁吧 所以 你之前要有个addActionListener 你的代码没有这句吧 就是哪个按钮需要监听 你就对那个按钮加个监听 接着在函数里面实现你点击按钮的响应方法
追问我在 private void but1ActionPerformed(java.awt.event.ActionEvent evt)前面写了个but1.addActionListener() 然后把方法和里面要实现的代码放进去，但是报错了，不知道是怎么回事。
参考技术A 给你改了，1.你给没有实现 ActionListener 的类，这个就是处理按钮点下事件的。可以单独写类，也可以象下边这样实现。
2.没有给按钮添加侦听器。but1.addActionListener(this);
3.点击事件的方法不对。是public void actionPerformed(ActionEvent e) （在ActionListener 接口中定义的，也是必须实现的方法。） 不是private void but1ActionPerformed(java.awt.event.ActionEvent evt)
你这样写有点象net的感觉，按钮but1 点击方法是 but1_click(event)
java里不是这样用的。
--------------------------------------------------------------------------------
import java.awt.BorderLayout;
import java.awt.Container;
import java.awt.FlowLayout;
import java.awt.event.ActionEvent;
import java.awt.event.ActionListener;
import javax.swing.JButton;
import javax.swing.JFrame;
import javax.swing.JLabel;
import javax.swing.JPanel;
import javax.swing.JTextField;
public class Buju extends JFrame implements ActionListener
JTextField text1, text2;
JButton but1, but2, but3, but4;
JLabel lab1, result;
public Buju()
super("布局模式");
setBounds(20, 20, 500, 400);
Container contentPane = getContentPane();
contentPane.setLayout(new BorderLayout(10, 10));
setDefaultCloseOperation(JFrame.EXIT_ON_CLOSE);
JPanel jp1 = new JPanel(new FlowLayout());
JPanel jp2 = new JPanel(new FlowLayout());
text1 = new JTextField(5);
jp2.add(text1);
text2 = new JTextField(5);
jp2.add(text2);
lab1 = new JLabel("输出结果");
jp2.add(lab1);
result = new JLabel("");
jp2.add(result);
but1 = new JButton("+");
jp1.add(but1);
but2 = new JButton("-");
jp1.add(but2);
but3 = new JButton("*");
jp1.add(but3);
but4 = new JButton("/");
jp1.add(but4);
contentPane.add(jp2, BorderLayout.CENTER);
contentPane.add(jp1, BorderLayout.SOUTH);
but1.addActionListener(this);
but2.addActionListener(this);
but3.addActionListener(this);
but4.addActionListener(this);
private void but1ActionPerformed(java.awt.event.ActionEvent evt) // 这里就不对劲了，也不知道该怎么写了。
double x, y, s;
String str;
x = Double.valueOf(text1.getText());
y = Double.valueOf(text2.getText());
s = x + y;
str = String.valueOf(s);
lab1.setText(str);
public void actionPerformed(ActionEvent e)
JButton btn = (JButton) e.getSource();
double b1, b2;
try
b1 = Double.parseDouble(text1.getText());
b2 = Double.parseDouble(text2.getText());
catch (Exception ex)
return;
if ("+".equals(btn.getText()))
result.setText(b1 + b2 + "");
if ("-".equals(btn.getText()))
result.setText(b1 - b2 + "");
if ("*".equals(btn.getText()))
result.setText(b1 * b2 + "");
if ("/".equals(btn.getText()))
result.setText(b1 / b2 + "");
public static void main(String[] args)
Buju bj = new Buju();
bj.setVisible(true);
追问
有些代码没看懂
but1.addActionListener(this);//这里为什么要用this?
JButton btn = (JButton) e.getSource(); //这个没看懂什么意思.
if ("+".equals(btn.getText())) //这个为什么要这么写? 是语法就这个样么? 为什么不是 btn.getText("+");
1.为什么是this
this是当前类,当前类实现了ActionListener 接口,
2.JButton btn = (JButton) e.getSource();
ActionEvent e 的触发源是按钮.
3.btn.getText("+"); 这个你是从那里看的?
这个是取当前按下按钮的text 就是为了判断那个按钮按下了,因为四个按钮用了一个侦听类,
谢谢你们给我回答问题，我想把分给你和楼下的那位。你们的回答都挺好的，现在怎么办？
追答百度好象不能同时给两个人分,你选取一个吧.
我看了一下.楼下的,也是正确答案.你觉得我们两谁给你的帮助大,就选取谁.
只要有这个认真的态度就好.认真的看了回答者的回答,认真的对待了这个,没有浪费回答者的劳动,
那还是谢谢您的回答，楼下的代码我看懂了，分我就给他了，再次感谢您的帮助~
参考技术B 监听代码but1ActionPerformed 写的没错，只是没有与but1关联起来。but1.addActionListener(but1ActionPerformed); // 这是给but1加上事件监听，加到Buju构造函数中
其他的but2/3/4来同样处理，每个写一个监听函数，并在Buju构造函数中进行关联 参考技术C setBounds(20,20,500,400);
Container contentPane=getContentPane();
contentPane.setLayout(new BorderLayout(10,10));
setDefaultCloseOperation(JFrame.EXIT_ON_CLOSE);
JPanel jp1=new JPanel(new FlowLayout());
JPanel jp2=new JPanel(new FlowLayout());
jp2.add(text2);
lab1=new JLabel("输出结果");
jp2.add(lab1);
but1=new JButton("+");
jp1.add(but1);
but2=new JButton("-");
jp1.add(but2);
but3=new JButton("*");
jp1.add(but3);
but4=new JButton("/");
jp1.add(but4);
contentPane.add(jp2,BorderLayout.CENTER);
contentPane.add(jp1,BorderLayout.SOUTH 参考技术D 看我的
import javax.swing.*;
import java.awt.*;
import java.awt.event.*;
public class Buju extends JFrame implements ActionListener
private static final long serialVersionUID = 1L;
JTextField text1, text2;
JButton but1, but2, but3, but4;
JLabel lab1;
public Buju()
super("布局模式");
setBounds(20, 20, 500, 400);
Container contentPane = getContentPane();
contentPane.setLayout(new BorderLayout(10, 10));
setDefaultCloseOperation(JFrame.EXIT_ON_CLOSE);
JPanel jp1 = new JPanel(new FlowLayout());
JPanel jp2 = new JPanel(new FlowLayout());
text1 = new JTextField(5);
text2 = new JTextField(5);
lab1 = new JLabel("输出结果");
jp2.add(text1);
jp2.add(text2);
jp2.add(lab1);
but1 = new JButton("+");
but2 = new JButton("-");
but3 = new JButton("*");
but4 = new JButton("/");
but1.addActionListener(this);
but2.addActionListener(this);
but3.addActionListener(this);
but4.addActionListener(this);
jp1.add(but1);
jp1.add(but2);
jp1.add(but3);
jp1.add(but4);
contentPane.add(jp2, BorderLayout.CENTER);
contentPane.add(jp1, BorderLayout.SOUTH);
public void actionPerformed(java.awt.event.ActionEvent evt)
double x, y, s;
String str;
x = Double.valueOf(text1.getText());
y = Double.valueOf(text2.getText());
if(evt.getSource()==but1)
s = x + y;
str = String.valueOf(s);
lab1.setText(str);
if(evt.getSource()==but2)
s = x - y;
str = String.valueOf(s);
lab1.setText(str);
if(evt.getSource()==but3)
s = x * y;
str = String.valueOf(s);
lab1.setText(str);
if(evt.getSource()==but4)
s = x / y;
str = String.valueOf(s);
lab1.setText(str);
public static void main(String[] args)
Buju bj = new Buju();
bj.setVisible(true);
追问
but1.addActionListener(this);//这里为什么要用this?
可以帮我解释一下吗？关于this一直就是含含糊糊的，
这个到底该怎么用？
this是对象本身，实现(implements)ActionListener接口的类(需要写ActionPerformed方法)就可以作为一个监听器来使用,呵呵，“监听器”也太术语了，简单的说就是指专门处理事件的东西，
因为Buju implements ActionListener，所以Buju对象就是一个监听器。but1.addActionListener(this)就是but1的事件专门由“this"(Buju对象)监听器的actionPerformed方法来处理。
如果想用其它监听器来处理
class OtherClass implements ActionListener
public void actionPerformed(ActionEvent e)
....
but1.addActionListener(new OtherClass);
谢谢你们给我回答问题，我想把分给你和楼上的那位。你们的回答都挺好的，现在怎么办？
追答请看我的财富，我的财富值几乎为0了，毫无疑问属于“特困生”一类。
本回答被提问者采纳什么是Java运算？Java运算好学吗？
提到运算，你可能会立即想到加、减、乘、除四则运算以及“九九乘法表”。Java 语言中有很多进行数据运算的方式，比如：算术运算、比较运算、逻辑运算、赋值运算、三目运算等。每一种运算方式，又都包含了很多的运算符，小编把这些运算符形象的称为“十八般武艺”，学习 Java 中的运算，就是学习这些运算符的使用，也就是修炼这“十八般武艺”的过程。
public class Test
public static void main(String[] args)
int number = 1 + 2; // 使用加号（+）将常量1和2连接起来，构成了一个加法表达式，并把运算结果赋值给变量number
System.out.println(number); // 输出number的值
上面的式子就是使用运算符加号（+）将常量 1 和 2 连接起来，构成了一个加法表达式，并把运算结果赋值给变量 number，不出意外的话，打印结果应该是：
public class Test
public static void main(String[] args)
int number = 1 + 2; // 使用加号（+）将常量1和2连接起来，构成了一个加法表达式，并把运算结果赋值给变量number
System.out.println(number); // 输出number的值
int count = number + 10; // 变量和常量同时参与运算
System.out.println(count); // 输出计算结果
打印结果：
13除此之外，运算的方式也有很多，加法、减法、取余（取模）、比较运算等等，但它们都有一个共同的特点：每个表达式都会有一个运算结果。我们根据表达式运算结果的数据类型，将表达式的类型进行归纳分类，比如：
整型表达式：运算结果为整数。比如： 1 + 2、10 * 20、5 - 3，它们的运算结果都是整数
浮点型表达式：运算结果为浮点数。比如：3.14 * 2、0.618 + 0.382、3.0 / 1，它们的运算结果都是浮点数
布尔型表达式：运算结果为布尔类型的值。比如：2 > 1、(20-10) < 15，它们的运算结果都是布尔型：要么true、要么false。
练好了运算符、表达式的基本功，现在，我们可以开始学习真正的武艺了。算术运算
先来几个简单的招式，好好复习我们小学时期的算术运算。Java 中的算术运算符【大概、也许】有七种：
前面四个运算符还算常见：+、 -、 *、 / ，虽然乘号（*）和除号（/）跟我们以前见到的长得不一样，但并不难理解。百分号（%）在这里是“取余”、“取余”的意思，也就是说，使用百分号（%）可以得到数字 7 除以 3 之后的余数：1。而 ++ 和 -- 就比较陌生了，它们分别代表数据 “自增1” 和 “自减1”，这种运算是我们以前没见过的，接下来，我手把手教你每个招式——运算符的用法。
1、加、减、乘、除
四则运算的用法，代码如下：
public class Test
public static void main(String[] args)
int num1 = 3;
int num2 = 4;
int num3 = 5;
int num4 = 10;
// 1.加法运算
int add = num1 + num2;
// 2.减法运算
int subtract = num2 - num1;
// 3.乘法运算
int multiply = num2 * num3;
// 4.除法运算
int divide = num4 / num3;
// 分别输出运算结果
System.out.println(add); // 输出加法计算结果
System.out.println(subtract); // 输出减法计算结果
System.out.println(multiply); // 输出乘法计算结果
System.out.println(divide); // 输出除法计算结果
输出结果：
7
1
20
2除法运算有个细节要注意：如果相除的两个数进行运算，除不尽怎么办？猜想一下，下面这个行代码会得到什么结果：
System.out.println(7 / 3); // 即 7 / 3，结果是什么，2.333...还是2，还是1看结果：
public class Test
public static void main(String[] args)
System.out.println(7 / 3);
切记一点：除法运算符（ / ），得到两个数据相除的商，在 Java 语言中，整数除以整数结果还是整数，如果除不尽，会舍弃余数。也就是说，7 / 3 的商是2，余数为1，因为参与运算的被除数、除数都是整数（int类型），所以计算结果还是整数，舍弃了余数部分，结果是2。
是不是有一种恍然大悟的感觉。这是 Java 中的运算与我们以前的认知第一个不一样的地方。
2、取模、自增（++）和自减（--）
再教你三个进阶招式（%、 ++、 --）：
public class Test
public static void main(String[] args)
int num1 = 3;
int num2 = 4;
int num3 = 5;
int num4 = 10;
int remainder = num3 % num1; // 取模/取余运算，5对3取模，结果是？
System.out.println(remainder); // 输出取模运算结果
num2++; // num2自增1
num4--; // num4自减1
System.out.println(num2); // 输出自增之后的运算结果
System.out.println(num4); // 输出自减之后的运算结果
输出结果：
2
5
9百分号（%）是取模运算，也叫取余运算，是除法运算的一种扩展，只不过除法运算得到的结果是商，而取模运算得到的结果是余数。如果两个数进行取模运算，结果是0，意味着什么？没错，这就是整除的效果，所以，取模运算（%）可以用来判断两个数是否能够整除，也就是说，被除数是除数的倍数。
加加（++）和减减（--）运算是让变量进行自增或自减。这里要注意，不能将这两个运算符直接使用到常量上，比如下面的代码是错误的：
1++; // 不允许常量自增或自减思考一下，为什么？那是因为常量的概念，规定了它不能够被修改，所以，如果你想要获得2，那么直接使用字面值常量2就行了，完全不需要使用另一个常量进行运算。还有个细节，上面的代码，也可以把 ++ 和 -- 放到变量的前面，这样的运算结果是一样的（放在变量前、后的代码不能同时存在，否则数据会进行两次运算哦）：
来，我们试试把++和--写到前面
++num2; // num2自增1
--num4; // num4自减1
public class Test
public static void main(String[] args)
int num1 = 3;
int num2 = 4;
int num3 = 5;
int num4 = 10;
int remainder = num3 % num1; // 取模/取余运算，5对3取模，结果是？
System.out.println(remainder); // 输出取模运算结果
// num2++; // num2自增1
// num4--; // num4自减1
++num2; // num2自增1
--num4; // num4自减1
System.out.println(num2); // 输出自增之后的运算结果
System.out.println(num4); // 输出自减之后的运算结果
输出结果没有变化：
5
9当然，加加（++）和减减（--）也可以像别的运算符那样，把结果赋值给一个新的变量，就像这样：
public class Test
public static void main(String[] args)
int num1 = 3;
int num2 = 4;
int num3 = 5;
int num4 = 10;
int num5 = num2++; // 猜想：num2自增1，然后赋值给新变量num5
int num6 = num4--; // 猜想：num4自减1，然后赋值给新变量num6
System.out.println(num5); // 输出自增之后的运算结果
System.out.println(num6); // 输出自减之后的运算结果
输出结果：
4
10怎么还是原来的值？难道是没有发生运算？
看来我们的猜想不正确，原来
int num5 = num2++; // 结论：num2先赋值给新变量num5，然后才进行自增运算
int num6 = num4--; // 结论：num4先赋值给新变量num6，然后才进行自减运算我把加加（++）和减减（--）放到变量前面试试：
public class Test
public static void main(String[] args)
int num1 = 3;
int num2 = 4;
int num3 = 5;
int num4 = 10;
// int num5 = num2++; // 结论：num2先赋值给新变量num5，然后才进行自增运算
// int num6 = num4--; // 结论：num4先赋值给新变量num6，然后才进行自减运算
int num5 = ++num2; // 猜想：num2自增1，然后赋值给新变量num5
int num6 = --num4; // 猜想：num4自减1，然后赋值给新变量num6
System.out.println(num5); // 输出自增之后的运算结果
System.out.println(num6); // 输出自减之后的运算结果
输出结果：
5
9终于变成正确答案了：
int num5 = ++num2; // 结论：num2自增1，然后赋值给新变量num5
int num6 = --num4; // 结论：num4自减1，然后赋值给新变量num6但是，这是为什么呢？加加（++）和减减（--）放到变量前和放到变量后为什么结果不一样，到底数据有没有进行运算呢？剖析一下这两招：
单独使用：放在变量前或后结果一样
参与其它运算：
在变量前，先自增（自减） ，再进行其它运算
在变量后，先以原值进行其它运算，再自增（自减）
所以，第一次把 ++ 和 -- 放在变量后，是把变量原来的值赋值给新变量，而自增（或自减）的值被抛弃了，因此打印的是原来的值；第二次把 ++ 和 -- 放在变量前，是把运算之后的值赋值给新变量，因此打印的是计算之后的数据，这就是加加（++）和减减（--）这两个运算符的底层原理。 ++ 和 -- 是一种特殊的运算，这是再一次不同于我们以往认知的一个地方。
以上是关于java四则运算的主要内容，如果未能解决你的问题，请参考以下文章