精华内容
下载资源
问答
  • JAVA 编写计算器 要代码最简单
    2021-03-17 22:59:02

    //声明需要插入的包

    import java.awt.*;

    import java.lang.Object;

    import java.lang.String;

    import javax.swing.*;

    import java.awt.event.*;

    import java.awt.TextComponent;

    //声明一个主类jisuanqi,继续窗口类Frame

    public class jisuanqi extends Frame{

    //声明16个Button

    Button anjian1, anjian2, anjian3, anjian4, anjian5, anjian6, anjian7, anjian8, anjian9, anjian10, anjian11, anjian12, anjian13, anjian14,anjian15,anjian16;

    //声明文本框,用于接收数字和计算

    TextField numText;

    //声明面板容器,用于存放各种按钮

    Panel anjianPanel;

    //构造方法初始化按钮

    jisuanqi(String title){

    super(title);

    anjian1=new Button("0");

    anjian2=new Button("1");

    anjian3=new Button("2");

    anjian4=new Button("3");

    anjian5=new Button("4");

    anjian6=new Button("5");

    anjian7=new Button("6");

    anjian8=new Button("7");

    anjian9=new Button("8");

    anjian10=new Button("9");

    anjian11=new Button("+");

    anjian12=new Button("-");

    anjian13=new Button("*");

    anjian14=new Button("/");

    anjian15=new Button("=");

    anjian16=new Button("清空");

    //初始化文本框,将文本的值设置为“0”

    numText=new TextField("0");

    //实例化面板;

    anjianPanel=new Panel();

    //设置按钮

    anjianPanel.setLayout(new FlowLayout());

    //实例化按钮

    anjian1.addActionListener(new anjianAction());

    anjian2.addActionListener(new anjianAction());

    anjian3.addActionListener(new anjianAction());

    anjian4.addActionListener(new anjianAction());

    anjian5.addActionListener(new anjianAction());

    anjian6.addActionListener(new anjianAction());

    anjian7.addActionListener(new anjianAction());

    anjian8.addActionListener(new anjianAction());

    anjian9.addActionListener(new anjianAction());

    anjian10.addActionListener(new anjianAction());

    anjian11.addActionListener(new anjianAction());

    anjian12.addActionListener(new anjianAction());

    anjian13.addActionListener(new anjianAction());

    anjian14.addActionListener(new anjianAction());

    anjian15.addActionListener(new anjianAction());

    anjian16.addActionListener(new anjianAction());

    //将各个按钮添加到面板容器中

    anjianPanel.add(anjian1);

    anjianPanel.add(anjian2);

    anjianPanel.add(anjian3);

    anjianPanel.add(anjian4);

    anjianPanel.add(anjian5);

    anjianPanel.add(anjian6);

    anjianPanel.add(anjian7);

    anjianPanel.add(anjian8);

    anjianPanel.add(anjian9);

    anjianPanel.add(anjian10);

    anjianPanel.add(anjian11);

    anjianPanel.add(anjian12);

    anjianPanel.add(anjian13);

    anjianPanel.add(anjian14);

    anjianPanel.add(anjian15);

    anjianPanel.add(anjian16);

    //为文本框添加事件

    numText.addTextListener(new TextListener() {

    public void textValueChanged(TextEvent e) {

    if(numText.getText().indexOf("0",0)!=-1){

    numText.getText().replace("0","");

    }

    }

    });

    addWindowListener(new WindowAdapter() {

    public void windowClosing(WindowEvent e) {

    System.exit(0);

    }

    });

    //将文本框放置在顶部

    add(numText,BorderLayout.NORTH);

    //添加按钮

    add(anjianPanel,BorderLayout.CENTER);

    //设置文本框属性

    numText.setEditable(false);

    }

    //没有任何操作的值

    int num=0;

    //numStr是文本框的值

    String numStr=null;

    Boolean chinage=false;

    //设置按钮

    public int check(){

    numStr = numText.getText();

    if (numStr.indexOf("+") == 0) {

    numStr = numStr.replace('+', '0');

    num = num + Integer.parseInt(numStr);

    return num;

    }else

    if (numStr.indexOf("-") != -1) {

    numStr = numStr.replace("-", "0");

    num = num - Integer.parseInt(numStr);

    return num;

    }

    else

    if(numStr.indexOf("*")!=-1){

    numStr=numStr.replace('*','0');

    num = num * Integer.parseInt(numStr);

    return num;

    }

    else

    if(numStr.indexOf("/")!=-1){

    numStr=numStr.replace('/','0');

    try{

    num = num / Integer.parseInt(numStr);

    return num;

    }catch(ArithmeticException e){

    JOptionPane.showMessageDialog(null,"除数不能为空!","消息!",1);

    return num;}}

    else

    return num=Integer.parseInt(numStr);}

    //创建事件

    private class anjianAction implements ActionListener{

    public void actionPerformed(ActionEvent event){

    if(event.getActionCommand()=="0"){

    if(!numText.getText().equals("0"))

    numText.setText(numText.getText()+0);}

    if(event.getActionCommand()=="1")

    numText.setText(numText.getText()+1);

    if(event.getActionCommand()=="2")

    numText.setText(numText.getText()+2);

    if(event.getActionCommand()=="3")

    numText.setText(numText.getText()+3);

    if(event.getActionCommand()=="4")

    numText.setText(numText.getText()+4);

    if(event.getActionCommand()=="5")

    numText.setText(numText.getText()+5);

    if(event.getActionCommand()=="6")

    numText.setText(numText.getText()+6);

    if(event.getActionCommand()=="7")

    numText.setText(numText.getText()+7);

    if(event.getActionCommand()=="8")

    numText.setText(numText.getText()+8);

    if(event.getActionCommand()=="9")

    numText.setText(numText.getText()+9);

    if(event.getActionCommand()=="清空"){

    numText.setText("0");

    num=0;}

    if(event.getActionCommand()=="+"){

    //调用check();方法

    check();

    numText.setText("+");}

    if(event.getActionCommand()=="-"){

    check();

    numText.setText("-");}

    if(event.getActionCommand()=="*"){

    check();

    numText.setText("*");}

    if(event.getActionCommand()=="/"){

    if(numStr=="/0"){

    JOptionPane.showMessageDialog(null,"除数不能为空!","消息!",1);}

    check();

    numText.setText("/");}

    if(event.getActionCommand()=="="){

    check();

    numText.setText(""+num);}}}

    public static void main(String[] args){

    jisuanqi jisuanqi=new jisuanqi("计数器");

    jisuanqi.setSize(300,280);

    //设置窗口大小

    jisuanqi.setLocation(550,350);

    //设置界面属性

    jisuanqi.setVisible(true);

    }}

    如有疑问请继续追问,我将竭尽全力为您解答

    我要评论

    更多相关内容
  • 供小白,新手学习的java-swing编写的小桌面程序,工程最好以eclipse打开
  • javaswing实现的一个简单计算器:一些swing的基础应用。 注释里有详解,直接上代码:package 简易计算器;import java.awt.BorderLayout;import java.awt.GridLayout;import java.awt.event.ActionEvent;import ...

    用java swing实现的一个简单的计算器:一些swing的基础应用。

    1e9ab1ee9df52de634ec04ffda105e61.png

    注释里有详解,直接上代码:

    package 简易计算器;

    import java.awt.BorderLayout;

    import java.awt.GridLayout;

    import java.awt.event.ActionEvent;

    import java.awt.event.ActionListener;

    import javax.swing.JButton;

    import javax.swing.JFrame;

    import javax.swing.JPanel;

    import javax.swing.JTextField;

    public class 简易计算器 {

    public static void main(String[] args) {

    myFrame frame = new myFrame();

    frame.setDefaultCloseOperation(JFrame.EXIT_ON_CLOSE);//关闭窗口

    frame.setVisible(true);

    }

    }

    class myFrame extends JFrame {

    public myFrame() {

    setTitle("计算器");

    add(new myPanel());

    pack();

    }

    }

    class myPanel extends JPanel {

    //显示计算器按钮的值和计算后的值

    JTextField display;

    JPanel panel1;//面板1

    JPanel panel2;//面板2

    String nowButton;//当前按下的

    public myPanel() {

    setLayout(new BorderLayout());

    //把文本框加在上面north里

    display = new JTextField("");

    display.setEnabled(true);

    add(display, BorderLayout.NORTH);

    //监听操作按钮

    ActionListener command = new commandAction();

    //panel1是中间16个按钮的布局,放到布局管理器的center里

    panel1 = new JPanel();

    panel1.setLayout(new GridLayout(4, 4));

    addButton1("7", command);

    addButton1("8", command);

    addButton1("9", command);

    addButton1("+", command);

    addButton1("4", command);

    addButton1("5", command);

    addButton1("6", command);

    addButton1("-", command);

    addButton1("1", command);

    addButton1("2", command);

    addButton1("3", command);

    addButton1("*", command);

    addButton1(".", command);

    addButton1("0", command);

    addButton1("=", command);

    addButton1("/", command);

    add(panel1, BorderLayout.CENTER);

    //panel2是下面的backspace和c的2个的布局,放到布局管理器的south里

    panel2 = new JPanel();

    panel2.setLayout(new GridLayout(1, 2));

    addButton2("BackSace", command);

    addButton2("C", command);

    add(panel2, BorderLayout.SOUTH);

    }

    //注册事件监听器方法(panel1的)

    public void addButton1(String label ,ActionListener listener) {

    JButton button = new JButton(label);

    button.addActionListener(listener);

    panel1.add(button);

    }

    //注册监听器方法(panel2的)

    private void addButton2(String label, ActionListener listener) {

    // TODO 自动生成的方法存根

    JButton button = new JButton(label);

    button.addActionListener(listener);

    panel2.add(button);

    }

    //单击按钮执行命令的监听器

    class commandAction implements ActionListener {

    @Override

    public void actionPerformed(ActionEvent event) {

    // TODO 自动生成的方法存根

    nowButton = event.getActionCommand();

    if (nowButton != "BackSace" && nowButton != "=") {

    //如果是回退和=就不打印这个了

    display.setText(display.getText() + nowButton);

    }

    if (nowButton.equals("=")) {

    //如果是等于号,就计算结果

    display.setText(jisuan1(display.getText()));

    }

    if (nowButton.equals("BackSace")) {

    //回退一个字符

    StringBuffer sb = new StringBuffer(display.getText());

    display.setText(sb.substring(0, sb.length()-1));

    }

    if (nowButton.equals("C")) {

    //清空

    display.setText("");

    }

    }

    }

    //用来计算的方法

    public String jisuan1(String string) {

    StringBuffer sb = new StringBuffer(string);

    int commandCount = 0;//符号数量

    int j = 0;//计数器

    //计算有多少个运算符,就有n+1个数字

    for (j = 0; j < sb.length(); j++) {

    if (sb.charAt(j) <= '9' && sb.charAt(j) >= '0' || sb.charAt(j) == '.') {

    continue;

    }else {

    commandCount++;

    }

    }

    //初始化符号数组

    char[] command = new char[commandCount];

    //初始化数字数组(用字符串表示)

    String[] num = new String[commandCount+1];

    for (j = 0; j < num.length; j++) {

    num[j] = "";

    }

    //遍历一遍,吧每个数字存进数字数组,每个符号存进符号数组

    int k = 0;

    for (j = 0; j < sb.length(); j++) {

    if (sb.charAt(j) <= '9' && sb.charAt(j) >= '0' || sb.charAt(j) == '.') {

    num[k] += sb.charAt(j);

    continue;

    }else {

    command[k] = sb.charAt(j);

    k++;

    }

    }

    //计算结果

    double result = 0;

    for (int i = 0; i < commandCount; i++) {

    //取前两个数,和第一个操作符,运算

    double num1 = Double.parseDouble(num[i]);

    double num2 = Double.parseDouble(num[i+1]);

    char cc = command[i];

    //计算

    switch (cc) {

    case '+':

    result = num1 + num2;

    break;

    case '-':

    result = num1 - num2;

    break;

    case '*':

    result = num1 * num2;

    break;

    case '/':

    result = num1 / num2;

    break;

    default:

    break;

    }

    num[i+1] = String.valueOf(result);

    }

    return String.valueOf(result);

    }

    }

    展开全文
  • 首先声明一下,这是我学java写的第一个东西(准确是2.0版本),所以比较简陋。大家凑合凑合。之后,这个版本功能很少,仅仅支持一些小的操作,就和那种十块钱一个的计算器功能差不多。不支持括号,括号版本请见我下个...

    2019.6.24更新    ----加了注释

    其实这玩意儿是我之前写的东西了。今天写android的卡在了sin,cos的处理上。。。实在无聊便更了一下。

    首先声明一下,这是我学java写的第一个东西(准确是2.0版本),所以比较简陋。大家凑合凑合。

    之后,这个版本功能很少,仅仅支持一些小的操作,就和那种十块钱一个的计算器功能差不多。不支持括号,括号版本请见我下个安卓计算器。代码中加了大量注释,大家应该看得懂。有任何不懂得,欢迎留言~(虽然从来没有过= =)

    最后GUI和数据处理我写在了一起,这个并不推荐,会感觉代码比较乱,且不适合找bug。。。

    贴两张截图

    3bcce98fbf3f3f9428715920d442f30d.png

    153a6a81c219af03e963a341b7ba6814.png

    /** 简单计算器

    * 注意事项:1.目前仅做到小数点后八位的输入(输出不止)

    * 2.MOD功能仅限整数。

    * 3.如需使用根号功能,请先打根号再打数据,如根号3的值需要键入 “3” “根号”

    * 4.纠错目前没做,数据不支持删除功能。

    * 5.如遇到任何bug,欢迎指正。

    * Time:2018/5/5

    * **/

    package jisuan;

    import java.awt.*;

    import java.awt.event.*;

    import javax.lang.model.type.PrimitiveType;

    import javax.swing.*;

    import java.awt.Dimension;

    import java.math.*;

    import java.nio.file.attribute.FileOwnerAttributeView;

    public class mine extends JFrame implements ActionListener {

    /**

    * 当时命名太随意了,解释一下。

    * f代表第几个操作数,f==0是第一个数,f==1第二个

    * fd代表是否有小数点       1是0非

    * a,b就是操作数了,a是第一个,b是第二个

    * t是我用来迭代浮点数的。这个下面写一段注释解释一下

    * 最后this关键字指代的是当前对象,因为只有一个对象,所以加不加是一回事,全部删了讲道理亦可以跑

    * **/

    int f = 0, fd = 0;

    double a = 0, b = 0;

    double t = 10.0;

    JPanel pan1 = new JPanel();

    JPanel pan2 = new JPanel(new GridLayout(5, 5, 8, 8));

    JTextField tf = new JTextField();

    // private MyPanel1 qq;

    JButton bu0 = new JButton("0"); //定义设置按钮

    JButton bu1 = new JButton("1");

    JButton bu2 = new JButton("2");

    JButton bu3 = new JButton("3");

    JButton bu4 = new JButton("4");

    JButton bu5 = new JButton("5");

    JButton bu6 = new JButton("6");

    JButton bu7 = new JButton("7");

    JButton bu8 = new JButton("8");

    JButton bu9 = new JButton("9");

    JButton bu_jia = new JButton("+");

    JButton bu_jian = new JButton("-");

    JButton bu_cheng = new JButton("x");

    JButton bu_chu = new JButton("/");

    JButton bu_cifang = new JButton("次方");

    JButton bu_dengyu = new JButton("=");

    JButton bu_MOD = new JButton("MOD");

    JButton bu_root = new JButton("√");

    JButton bu_dian = new JButton(".");

    JButton bu_clean = new JButton("clean");

    JButton bu_sin = new JButton("sin");

    JButton bu_cos = new JButton("cos");

    JButton bu_tan = new JButton("tan");

    JButton bu_lg = new JButton("lg");

    JButton bu_pi = new JButton("π");

    public mine() {

    /*

    * MyPanel1 qq=new MyPanel1(); this.addKeyListener(qq);

    */

    tf.setEditable(false);

    bu0.setActionCommand("0");

    bu1.setActionCommand("1");

    bu2.setActionCommand("2");

    bu3.setActionCommand("3");

    bu4.setActionCommand("4");

    bu5.setActionCommand("5");

    bu6.setActionCommand("6");

    bu7.setActionCommand("7");

    bu8.setActionCommand("8");

    bu9.setActionCommand("9");

    bu_jia.setActionCommand("+");

    bu_jian.setActionCommand("-");

    bu_cheng.setActionCommand("x");

    bu_chu.setActionCommand("/");

    bu_cifang.setActionCommand("次方");

    bu_dengyu.setActionCommand("=");

    bu_MOD.setActionCommand("MOD");

    bu_root.setActionCommand("root");

    bu_dian.setActionCommand(".");

    bu_clean.setActionCommand("clean");

    bu_sin.setActionCommand("sin");

    bu_cos.setActionCommand("cos");

    bu_tan.setActionCommand("tan");

    bu_lg.setActionCommand("lg");

    bu_pi.setActionCommand("π");

    bu0.addActionListener(this);

    bu1.addActionListener(this);

    bu2.addActionListener(this);

    bu3.addActionListener(this); //加监听

    bu4.addActionListener(this);

    bu5.addActionListener(this);

    bu6.addActionListener(this);

    bu7.addActionListener(this);

    bu8.addActionListener(this);

    bu9.addActionListener(this);

    bu_jia.addActionListener(this);

    bu_jian.addActionListener(this);

    bu_cheng.addActionListener(this);

    bu_chu.addActionListener(this);

    bu_cifang.addActionListener(this);

    bu_dengyu.addActionListener(this);

    bu_MOD.addActionListener(this);

    bu_root.addActionListener(this);

    bu_dian.addActionListener(this);

    bu_clean.addActionListener(this);

    bu_sin.addActionListener(this);

    bu_cos.addActionListener(this);

    bu_tan.addActionListener(this);

    bu_lg.addActionListener(this);

    bu_pi.addActionListener(this);

    tf.setPreferredSize(new Dimension(465, 40));

    tf.setFont(new Font("宋体", Font.PLAIN, 28));

    Font f = new Font("仿宋", Font.BOLD, 25);// 根据指定字体名称、样式和磅值大小,创建一个新 Font。

    Font F = new Font("仿宋", Font.BOLD, 31);

    Font ff = new Font("仿宋", Font.BOLD, 21);

    bu0.setFont(f);

    bu1.setFont(f);

    bu2.setFont(f);

    bu3.setFont(f);

    bu4.setFont(f);

    bu5.setFont(f);

    bu6.setFont(f);

    bu7.setFont(f);

    bu8.setFont(f); //做样式,就是为了好看。

    bu9.setFont(f);

    bu0.setFont(f);

    bu_jia.setFont(f);

    bu_jian.setFont(f);

    bu_cheng.setFont(f);

    bu_chu.setFont(f);

    bu_root.setFont(f);

    bu_MOD.setFont(f);

    bu_clean.setFont(ff);

    bu_dengyu.setFont(f);

    bu_dian.setFont(f);

    bu_cifang.setFont(ff);

    bu_sin.setFont(f);

    bu_cos.setFont(f);

    bu_tan.setFont(f);

    bu_lg.setFont(f);

    bu_pi.setFont(F); //

    pan1.add(tf);

    this.add(pan1, BorderLayout.NORTH);

    pan2.add(bu_sin);

    pan2.add(bu_root);

    pan2.add(bu_MOD);

    pan2.add(bu_clean);

    pan2.add(bu_jia);

    pan2.add(bu_cos); //这儿是网格布局,这里就是按照顺序加入按钮

    pan2.add(bu1);

    pan2.add(bu2);

    pan2.add(bu3);

    pan2.add(bu_jian);

    pan2.add(bu_tan);

    pan2.add(bu4);

    pan2.add(bu5);

    pan2.add(bu6);

    pan2.add(bu_cheng);

    pan2.add(bu_lg);

    pan2.add(bu7);

    pan2.add(bu8);

    pan2.add(bu9);

    pan2.add(bu_chu);

    pan2.add(bu_pi);

    pan2.add(bu_cifang);

    pan2.add(bu0);

    pan2.add(bu_dian);

    pan2.add(bu_dengyu);

    this.setTitle("王俊谦最帅!"); // 王俊谦是我室友。哈哈哈哈`

    this.add(pan2, BorderLayout.CENTER);

    this.setSize(500, 350);

    this.setLocationRelativeTo(null); // 居中

    this.setVisible(true);

    this.setResizable(false);

    this.setDefaultCloseOperation(JFrame.EXIT_ON_CLOSE);

    }

    @Override

    public void actionPerformed(ActionEvent e) { //操作处理

    if (e.getActionCommand().equals("1")) {

    opt(1);

    } else if (e.getActionCommand().equals("2")) {

    opt(2);

    } else if (e.getActionCommand().equals("3")) {

    opt(3);

    } else if (e.getActionCommand().equals("4")) {

    opt(4);

    } else if (e.getActionCommand().equals("5")) {

    opt(5);

    } else if (e.getActionCommand().equals("6")) {

    opt(6);

    } else if (e.getActionCommand().equals("7")) {

    opt(7);

    } else if (e.getActionCommand().equals("8")) {

    opt(8);

    } else if (e.getActionCommand().equals("9")) {

    opt(9);

    } else if (e.getActionCommand().equals("0")) {

    opt(0);

    } else if (e.getActionCommand().equals("+")) {

    this.f = 1;

    tf.setText("");

    fd = 0;

    this.t = 10.0;

    } else if (e.getActionCommand().equals("-")) {

    this.f = 2;

    tf.setText("");

    fd = 0;

    this.t = 10.0;

    } else if (e.getActionCommand().equals("x")) {

    this.f = 3;

    tf.setText("");

    fd = 0;

    this.t = 10.0;

    } else if (e.getActionCommand().equals("/")) {

    this.f = 4;

    tf.setText("");

    fd = 0;

    this.t = 10.0;

    } else if (e.getActionCommand().equals("MOD")) {

    this.f = 5;

    tf.setText("");

    // fd=0;

    } else if (e.getActionCommand().equals("次方")) {

    this.f = 6;

    tf.setText("");

    fd = 0;

    this.t = 10.0;

    } else if (e.getActionCommand().equals("=")) {

    calcu(this.a, this.b, this.f);

    // this.a = 0;

    this.b = 0;

    this.f = 0;

    this.t = 10;

    fd = 0;

    } else if (e.getActionCommand().equals("clean")) {

    tf.setText("");

    this.a = 0;

    this.b = 0;

    this.f = 0;

    t = 10;

    fd = 0;

    } else if (e.getActionCommand().equals("root")) {

    this.a = Math.sqrt(this.a);

    tf.setText(String.valueOf(a));

    } else if (e.getActionCommand().equals("sin")) {

    this.a = Math.sin(this.a);

    tf.setText(String.valueOf(a));

    } else if (e.getActionCommand().equals("cos")) {

    this.a = Math.cos(this.a);

    tf.setText(String.valueOf(a));

    } else if (e.getActionCommand().equals("tan")) {

    this.a = Math.tan(this.a);

    tf.setText(String.valueOf(a));

    } else if (e.getActionCommand().equals("lg")) {

    this.a = Math.log10(this.a);

    tf.setText(String.valueOf(a));

    } else if (e.getActionCommand().equals("π")) {

    this.a = Math.PI;

    tf.setText(String.valueOf(a));

    }

    else if (e.getActionCommand().equals(".")) {

    fd = 1;

    }

    }

    public void opt(int number) { //具体操作

    if (this.f == 0) // the first number

    {

    if (fd == 0) // 梅小数点

    {

    this.a = this.a * 10 + number;

    tf.setText(String.valueOf((int) this.a));

    } else {// 有小数点

    double dnumber;

    dnumber = (double) number / t;

    t = t * 10.0;

    this.a += dnumber;

    BigDecimal BB = new BigDecimal(this.a); // 四舍五入取值

    double dd = BB.setScale(8, BigDecimal.ROUND_HALF_DOWN).doubleValue();

    tf.setText(String.valueOf(dd));

    }

    } // this second number

    else {

    // t=10;

    if (fd == 0) // 梅小数点

    {

    this.b = this.b * 10 + number;

    tf.setText(String.valueOf((int) this.b));

    } else {

    double dnumber;

    dnumber = (double) number / t;

    t = t * 10.0;

    this.b += dnumber;

    BigDecimal BB = new BigDecimal(this.b);

    double dd = BB.setScale(8, BigDecimal.ROUND_HALF_DOWN).doubleValue();

    tf.setText(String.valueOf(dd));

    }

    }

    }

    public void calcu(double a, double b, int f) {

    double sum = 789;

    switch (f) {

    case 0: //无操作直接按等于

    case 1: // 加

    sum = a + b;

    break;

    case 2: // 减

    sum = a - b;

    break;

    case 3: // 乘

    sum = a * b;

    break;

    case 4: // 除

    sum = a / b;

    break;

    case 5: // 取MOD

    sum = (int) a % (int) b;

    break;

    case 6: // 取次方

    sum = Math.pow(a, b);

    break;

    }

    double Q = sum;

    int QQ = (int) Q;

    double QQQ = (double) QQ;

    if (QQQ == sum)

    tf.setText(String.valueOf(QQ));

    else

    tf.setText(String.valueOf(sum));

    this.a = sum;

    }

    public static void main(String[] args) {

    mine kk = new mine();

    }

    }

    展开全文
  • Java编写简单计算器--实现篇

    万次阅读 多人点赞 2020-12-06 10:56:39
    本文用Javaswing来实现一个简单计算器,主要内容为图形用户界面GUI的实现以及运算表达式核心算法的设计编写。 程序运行环境为Windows10 ,编译环境为MyEclipse 。 一、具体功能: 1、:输入,输出 1)、输入:...

    本文用Javaswing来实现一个简单计算器,主要内容为图形用户界面GUI的实现以及运算表达式核心算法的设计编写。

    程序运行环境为Windows10 ,编译环境为MyEclipse 。

    一、具体功能:

    1、:输入,输出

     输入:允许输入带有括号的完整计算式(例 8*(4-95)+5÷2*e-pi)
     输出:输出Double类型的结果
     输出:整个运算表达式并保存于历史记录中
    

    2、:功能

     基本的加,减,乘,除,四则运算
     平方运算
     开方运算
     求余运算
    

    最终界面如下图:
    在这里插入图片描述

    除了常规的数字按钮和运算符,还有两个常数e,pi(π),清空键AC,括号运算符(),平方(x^x)和开方(sqrt)运算符,输入显示框以及历史记录文本框,文本框的垂直滚动条和水平滚动条。

    二、主要思想:

    1:中缀表达式转为后缀表达式

    准备:

    ①后缀表达式队列:postQueue,用于存储逆波兰表达式(其实不用队列排序直接输出也行)
    ②操作符栈:opStack,对用户输入的操作符进行处理,用于存储运算符

    算法思想:

    从左向右依次读取算术表达式的元素X,分以下情况进行不同的处理:
    (1)如果X是操作数,直接入队
    (2)如果X是运算符,再分以下情况:
    a)如果栈为空,直接入栈。
    b)如果X==”(“,直接入栈。
    c)如果X==”)“,则将栈里的元素逐个出栈,并入队到后缀表达式队列中,直到第一个配对的”(”出栈。(注:“(”和“)”都不 入队)
    d)如果是其他操作符(+ - * /),则和栈顶元素进行比较优先级。 如果栈顶元素的优先级大于等于X,则出栈并把栈中弹出的元素入队,直到栈顶元素的优先级小于X或者栈为空。弹出完这些元素后,才将遇到的操作符压入到栈中。
    (3)最后将栈中剩余的操作符全部入队。

    示意图:
    在这里插入图片描述
    2、计算后缀表达式

    准备:

    需要用到一个结果栈Res_Stack :用于存放计算的中间过程的值和最终结果

    算法思想:

    1、从左开始向右遍历后缀表达式的元素。
    2、如果取到的元素是操作数,直接入栈Res_Stack,如果是运算符,从栈中弹出2个数进行运算,然后把运算结果入栈
    3、当遍历完后缀表达式时,计算结果就保存在栈里了。

    示意图:
    在这里插入图片描述
    三、结果测试
    在这里插入图片描述
    分析:

    1、可实现基本四则运算及平方、开方、求余运算。
    2、运算表达式可显示于输入界面并保存于历史记录栏
    3、输入界面和历史记录栏皆可实现不断字自动换行功能以及滚动条功能
    4、不足之处:进行平方和开方运算时其保存在历史记录中的表达式会出现两个等号及两个结果。

    四、完整源代码(每行代码已附有详细注释)

    import java.awt.*;
    import java.awt.event.ActionEvent;
    import java.awt.event.ActionListener;
    import java.util.Objects;
    
    import javax.swing.*;
    
    //Calculator类,继承JFrame框架,实现事件监听器接口
    public class Calculator extends JFrame implements ActionListener {
        private final String[] KEYS = { "7", "8", "9", "AC", "4", "5", "6", "-", "1", "2", "3", "+", "0", "e", "pi", "/", "sqrt",
                "%", "x*x", "*", "(", ")", ".", "=" };
        private JButton keys[] = new JButton[KEYS.length];
        private JTextArea resultText = new JTextArea("0.0");// 文本域组件TextArea可容纳多行文本;文本框内容初始值设为0.0
        private JTextArea History = new JTextArea();// 历史记录文本框初始值设为空
        private JPanel jp2=new JPanel();
        private JScrollPane gdt1=new JScrollPane(resultText);//给输入显示屏文本域新建一个垂直滚动滑条
        private JScrollPane gdt2=new JScrollPane(History);//给历史记录文本域新建一个垂直滚动滑条
        // private JScrollPane gdt3=new JScrollPane(History);//给历史记录文本域新建一个水平滚动滑条
        private JLabel label = new JLabel("历史记录");
        private String b = "";
    
        // 构造方法
        public Calculator() {
            super("Caculator");//“超”关键字,表示调用父类的构造函数,
            resultText.setBounds(20, 18, 255, 115);// 设置文本框大小
            resultText.setAlignmentX(RIGHT_ALIGNMENT);// 文本框内容右对齐
            resultText.setEditable(false);// 文本框不允许修改结果
            History.setBounds(290, 40, 250,370);// 设置文本框大小
            History.setAlignmentX(LEFT_ALIGNMENT);// 文本框内容右对齐
            History.setEditable(false);// 文本框不允许修改结果
            label.setBounds(300, 15, 100, 20);//设置标签位置及大小
            jp2.setBounds(290,40,250,370);//设置面板窗口位置及大小
            jp2.setLayout(new GridLayout());
            JPanel jp1 = new JPanel();
            jp1.setBounds(20,18,255,115);//设置面板窗口位置及大小
            jp1.setLayout(new GridLayout());
            resultText.setLineWrap(true);// 激活自动换行功能
            resultText.setWrapStyleWord(true);// 激活断行不断字功能
            resultText.setSelectedTextColor(Color.RED);
            History.setLineWrap(true);//自动换行
            History.setWrapStyleWord(true);
            History.setSelectedTextColor(Color.blue);
            gdt1.setViewportView(resultText);//使滚动条显示出来
            gdt2.setViewportView(History);
            gdt1.setVerticalScrollBarPolicy(JScrollPane.VERTICAL_SCROLLBAR_ALWAYS);//设置让垂直滚动条一直显示
            gdt2.setVerticalScrollBarPolicy(JScrollPane.VERTICAL_SCROLLBAR_ALWAYS);//设置让垂直滚动条一直显示
            gdt2.setHorizontalScrollBarPolicy(JScrollPane.HORIZONTAL_SCROLLBAR_ALWAYS);//设置让水平滚动条一直显示
            jp1.add(gdt1);//将滚动条添加入面板窗口中
            jp2.add(gdt2);
            this.add(jp1);//将面板添加到总窗体中
            this.add(jp2);//将面板添加到总窗体中
            this.setLayout(null);
            this.add(label);// 新建“历史记录”标签
            //this.add(resultText);// 新建文本框,该语句会添加进去一个新的JTextArea导致带有滚动条的文本无法显示或者发生覆盖
            //this.add(History);// 新建历史记录文本框,该语句会添加进去一个新的JTextArea导致带有滚动条的文本无法显示
    
            // 放置按钮
            int x = 20, y = 150;
            for (int i = 0; i < KEYS.length; i++)
            {
                keys[i] = new JButton();
                keys[i].setText(KEYS[i]);
                keys[i].setBounds(x, y, 60, 40);
                if (x < 215) {
                    x += 65;
                } else {
                    x = 20;
                    y += 45;
                }
                this.add(keys[i]);
            }
            for (int i = 0; i < KEYS.length; i++)// 每个按钮都注册事件监听器
            {
                keys[i].addActionListener(this);
            }
            this.setResizable(false);
            this.setBounds(500, 200, 567, 480);
            this.setDefaultCloseOperation(EXIT_ON_CLOSE);
            this.setVisible(true);
        }
    
        // 事件处理
        public void actionPerformed(ActionEvent e)
        {
            //History.setText(b);//使输入的表达式显示在历史记录文本框中
            String label=e.getActionCommand();//获得事件源的标签
            if(Objects.equals(label, "="))//
            {
                resultText.setText(this.b);
                History.setText(History.getText()+resultText.getText());
                if(label.equals("="))//调用计算方法,得出最终结果
                {
                    String[] s =houzhui(this.b);
                    String result=Result(s);
                    this.b=result+"";
                    //更新文本框,当前结果在字符串b中,并未删除,下一次输入接着此结果以实现连续运算
                    resultText.setText(this.b);
                    History.setText(History.getText()+"="+resultText.getText()+"\n");
                }
            }
            else if(Objects.equals(label, "AC"))//清空按钮,消除显示屏文本框前面所有的输入和结果
            {
                this.b="";
                resultText.setText("0");//更新文本域的显示,显示初始值;
            }
            else if(Objects.equals(label, "sqrt"))
            {
                String n=kfys(this.b);
                resultText.setText("sqrt"+"("+this.b+")"+"="+n);//使运算表达式显示在输入界面
                History.setText(History.getText()+"sqrt"+"("+this.b+")"+"=");//获取输入界面的运算表达式并使其显示在历史记录文本框
                this.b=n;
            }
            else if(Objects.equals(label, "x*x"))
            {
                String m=pfys(this.b);
                resultText.setText(this.b+"^2"+"="+m);//使运算表达式显示在输入界面
                History.setText(History.getText()+this.b+"^2"+"=");//获取输入界面的运算表达式并使其显示在历史记录文本框
                this.b=m;
            }
            else if(Objects.equals(label, "e") || Objects.equals(label, "pi"))
            {
                if(label.equals("e"))
                {
                    String m=String.valueOf(2.71828);//将e的值以字符串的形式传给m
                    this.b=this.b+m;//保留显示m之前输入的运算符或数字字符继续下一步运算
                    resultText.setText(this.b);
                    // History.setText(History.getText()+this.b);
                }
                if(label.equals("pi"))
                {
                    String m=String.valueOf(3.14159265);
                    this.b=this.b+m;
                    resultText.setText(this.b);
                    // History.setText(History.getText()+this.b);
                }
            }
            else
            {
                this.b=this.b+label;
                resultText.setText(this.b);
                // History.setText(History.getText()+this.b);
    
    
            }
            //History.setText(History.getText()+this.b);//使输入的表达式显示在历史记录文本框中
        }
        //将中缀表达式转换为后缀表达式
        private String[] houzhui(String str) {
            String s = "";// 用于承接多位数的字符串
            char[] opStack = new char[100];// 静态栈,对用户输入的操作符进行处理,用于存储运算符
            String[] postQueue = new String[100];// 后缀表达式字符串数组,为了将多位数存储为独立的字符串
            int top = -1, j = 0;// 静态指针top,控制变量j
            for (int i = 0; i < str.length(); i++)// 遍历中缀表达式
            // indexof函数,返回字串首次出现的位置;charAt函数返回index位置处的字符;
            {
                if ("0123456789.".indexOf(str.charAt(i)) >= 0) // 遇到数字字符的情况直接入队
                {
                    s = "";// 作为承接字符,每次开始时都要清空
                    for (; i < str.length() && "0123456789.".indexOf(str.charAt(i)) >= 0; i++) {
                        s = s + str.charAt(i);
                        //比如,中缀表达式:234+4*2,我们扫描这个字符串的时候,s的作用相当于用来存储长度为3个字符的操作数:234
                    }
                    i--;
                    postQueue[j] = s;// 数字字符直接加入后缀表达式
                    j++;
                }
                else if ("(".indexOf(str.charAt(i)) >= 0) {// 遇到左括号
                    top++;
                    opStack[top] = str.charAt(i);// 左括号入栈
                }
                else if (")".indexOf(str.charAt(i)) >= 0) {// 遇到右括号
                    for (;;)// 栈顶元素循环出栈,直到遇到左括号为止
                    {
                        if (opStack[top] != '(') {// 栈顶元素不是左括号
                            postQueue[j] = opStack[top] + "";// 栈顶元素出栈
                            j++;
                            top--;
                        } else { // 找到栈顶元素是左括号
                            top--;// 删除栈顶左括号
                            break;// 循环结束
                        }
                    }
                }
                else if ("*%/+-".indexOf(str.charAt(i)) >= 0)// 遇到运算符
                {
                    if (top == -1)
                     {// 若栈为空则直接入栈
                        top++;
                        opStack[top] = str.charAt(i);
                    }
                    else if ("*%/".indexOf(opStack[top]) >= 0)
                    {// 当栈顶元素为高优先级运算符时,让栈顶元素出栈进入后缀表达式后,当前运算符再入栈
                            postQueue[j] = opStack[top] + "";
                            j++;
                        opStack[top] = str.charAt(i);
                    }
                    else 
                    {
                        top++;
                        opStack[top] = str.charAt(i);// 当前元素入栈
                    }
                }
            }
            while (top != -1) {// 遍历结束后将栈中剩余元素依次出栈进入后缀表达式
                postQueue[j] = opStack[top] + "";
                j++;
                top--;
            }
            return postQueue;
        }
    
        //开方运算方法
        public String kfys(String str) {
            String result = "";
            double a = Double.parseDouble(str), b = 0;
            b = Math.sqrt(a);
            result = String.valueOf(b);//将运算结果转换为string类型并赋给string类型的变量result
            return result;
        }
    
        //平方运算方法
        public String pfys(String str) {
            String result = "";
            double a = Double.parseDouble(str), b = 0;
            b = Math.pow(a, 2);
            result = String.valueOf(b);
            return result;
        }
    
        // 计算后缀表达式,并返回最终结果
        public String Result(String[] str) {
            String[] Result = new String[100];// 顺序存储的栈,数据类型为字符串
            int Top = -1;// 静态指针Top
            for (int i = 0; str[i] != null; i++) {
                if ("+-*%/".indexOf(str[i]) < 0) {  //遇到数字,直接入栈
                    Top++;
                    Result[Top] = str[i];
                }
                if ("+-*%/".indexOf(str[i]) >= 0)// 遇到运算符字符,将栈顶两个元素出栈计算并将结果返回栈顶
                {
                    double x, y, n;
                    x = Double.parseDouble(Result[Top]);// 顺序出栈两个数字字符串,并转换为double类型
                    Top--;
                    y = Double.parseDouble(Result[Top]);
                    Top--;
                    if ("*".indexOf(str[i]) >= 0) {
                        n = y * x;
                        Top++;
                        Result[Top] = String.valueOf(n);// 将运算结果重新入栈
    
                    }
                    if ("/".indexOf(str[i]) >= 0)
                    {
                        if (x == 0)// 被除数不允许为0
                        {
                            String s = "error!";
                            return s;
                        } else {
                            n = y / x;
                            Top++;
                            Result[Top] = String.valueOf(n);// 将运算结果重新入栈
                        }
                    }
                    if ("%".indexOf(str[i]) >= 0)
                    {
                        if (x == 0)// 被除数不允许为0
                        {
                            String s = "error!";
                            return s;
                        } else {
                            n = y % x;
                            Top++;
                            Result[Top] = String.valueOf(n);// 将运算结果重新入栈
                        }
                    }
                    if ("-".indexOf(str[i]) >= 0) {
                        n = y - x;
                        Top++;
                        Result[Top] = String.valueOf(n);// 将运算结果重新入栈
                    }
                    if ("+".indexOf(str[i]) >= 0) {
                        n = y + x;
                        Top++;
                        Result[Top] = String.valueOf(n);// 将运算结果重新入栈
                    }
                }
            }
            return Result[Top];// 返回最终结果
        }
    
        // 主函数
        public static void main(String[] args) {
            Calculator a = new Calculator();
        }
    }
    
    

    另附:

    这是最初尚未修改的源代码,贴在这里备份,方便大家随时修改找bug。

    https://blog.csdn.net/weixin_50301255/article/details/121889662

    欢迎大家批评指正,分享问题解决方案。

    展开全文
  • Java实现简单计算器

    2022-03-30 10:13:05
    最近在复习着Java Swing的使用,在布局这块反复又看了很久,然后突然发现GirdLayout机器适合来做一个计算器简单样子,所以花了一点时间做了一下,最后没想到是在处理结果的算法这一块花的时间最多,这个简单的...
  • 模仿windows自带的计算器功能,设计一个简单计算器 至少要求实现整数和小数的加、减、乘、除、清零功能。 其他计算功能,请参考windows自带的计算器,尽可能多的实现。 代码实现 package sy3; import javax....
  • Java编写简易计算器

    千次阅读 2021-05-18 11:05:50
    //窗口大小 setTitle("计算器"); //窗口名称 setLayout(new BorderLayout()); //布局样式 LineBorder border = new LineBorder(Color.LIGHT_GRAY, 6, true);//文本区域边框设置 textArea = new JTextArea(2, 10); /...
  • 利用java swing编写一个简易的计算器背景效果图一、默认图二、计算三角函数三、阶乘运算四、常见的四则运算(实现了优先级)代码 本文借鉴了“初识Java,实现简易计算器(带括号)”这篇文章,在其基础上增加了“sin ...
  • Java编写简单计算器(附源代码)

    千次阅读 2021-03-03 11:34:34
    Java编写简单计算器(附源代码) 西安交通大学 《Java技术与应用》大作业 简单计算器编写 一、 选题理由 这个学期我选择《Java技术与应用》这门课(其实我的选修课已经修完了),完全是对java语言的兴趣和老师的个人...
  • java-swing-简单计算器界面的实现

    万次阅读 多人点赞 2019-06-22 01:35:34
    已经学习了一部分的swing知识,现在综合运用里面的部分知识来实现一个计算器的界面。 运用到的知识: 1.常用顶层容器 JFrame类 的使用 2.常用中间容器 JPanel类 的使用 3.单行文本框的实现类 JTextField类 的...
  • Java 实现简单计算器

    千次阅读 2021-02-12 09:25:23
    最后一次更新于2019/07/08效果演示图功能与流程要制作一个简易计算器,首先你要清楚GUI里要显示什么:结果显示框0~9的数字删除功能清楚功能搜寻历史记录功能计算结果的功能括号优先计算功能接下来通过流程图简单...
  • 使用Java编写一个简单计算器

    万次阅读 多人点赞 2019-03-17 11:31:11
    使用Java编写一个简单计算器 程序编写思路: 在编写这个计算器小程序时,首先需要对窗体和窗体中的组件有一个合理的布局,使编写出来的窗体看着美观简洁又实用.其次就是要注意对运算符和数字键的处理,为这些数字键和...
  • java 计算器

    2021-02-26 14:21:35
    packagecal;import javax.swing.*;import java.awt.*;importjava.awt.event.ActionEvent;importjava.awt.event.ActionListener;public classCalculator {JFrame frame;JPanel panel;JButton[][] ...
  • java实现一个简单计算器

    千次阅读 2021-05-14 15:37:24
    java实现一个简单计算器预览确定需求创建接口代码实现 预览 先来看下最终实现的效果图,如下: ![在这里插入图片描述](https://img-blog.csdnimg.cn/20210514153633937.png?x-oss-process=image/watermark,type_...
  • Java实现简单计算器

    万次阅读 多人点赞 2020-02-14 10:54:14
    实训题 8:简单计算器 一 项目说明 实训目的:掌握 Java GUI 开发中的布局管理和事件处理机制。 实训要求:(1)要使用 java 的 GUI 设计出计算器界面。(2)通过界面按钮,可以实现整数或浮点数的四则运算,并能将...
  • java编写简易计算器

    2021-01-11 16:21:16
    标题这里有应用到布局方面的代码,你可以自己默默地敲数字,当然啦,也可以用插件直接拉一个,看个人喜好喽~(我用的插件是repository,有兴趣的朋友可以看一下哦,当然java有很多插件,没有好用的,适合自己的才...
  • 使用java编程从0到1实现一个简单计算器学习编程语言重要的就是实践。很多小伙伴在学习完编程语言后,一直停留在基础阶段,只懂一大堆理论知识,而不懂得实践。那么,今天我们一起来动手做一个小计算器,回顾下学习...
  • 二、设计要求: 三、实现步骤: 四、程序源代码:   话不多说,先上图 一、测试截图: 四则混合运算测试     括号功能测试     输入合法性检查测试     二、设计要求: 主要用JAVA编写一个计算器,...
  • 实现一个最简单计算器,(能够实现四则运算),实现键盘监听、按钮监听 遇到的问题 组合键盘绑定事件,这个也是在写的时候遇到的问题,可以用用isShiftDown() 确定shift键按下,然后并上另一个键是否被按下,...
  • swing 制作简易计算器

    2019-11-08 12:36:20
    计算器最简单类型 姓名:彼岸花 */ import java.awt.*; import java.awt.event.*; import java.util.*; import javax.swing.*; import javax.swing.border.EmptyBorder; class CalculatorFrame { private ...
  • Java编写一个简单计算器

    千次阅读 2020-05-09 18:58:35
    import javax.swing.*; import java.awt.event.ActionEvent; import java.awt.event.ActionListener; import static java.lang.StrictMath.pow; import static java.lang.StrictMath.sqrt; public class Calculator...
  • 小项目-Java开发简单计算器

    万次阅读 多人点赞 2017-01-16 20:14:28
    本次实验制作一个可以进行简单的四则运算的计算器,会使用到 Java swing 进行开发。 1.1 知识点 Java Swing 界面编程计算器逻辑运算实现 1.2 实验环境介绍 本实验环境采用带桌面的 Ubuntu Linux 环
  • Java-GUI简单实现计算器

    千次阅读 2019-08-23 11:18:04
    java初学者,写了个简单计算器,分享一下,写文章也是提升技术的开端,有部分代码百度拿过来用的,初学者请谅解,我会努力的,不喜勿喷,有不足,请指点。 注意:小程序上的logo仅供学习使用,请勿商用,若有任何...
  • java实现一个简单计算器的加减乘除

    万次阅读 多人点赞 2019-05-30 23:04:30
    刚把计算器程序做出来,想迫不及待发表自己的感想,对我现在的水平来说做出一个计算器图形界面并且实现相应的加减乘除运算是一件让人是十分秃头的事情,其中我参考了这位博主的运算功能的实现,并在其代码上自己做了...
  • } 在同一个包下有koulanImage.java 综合起来就能扣蓝了 加法计算器的源程序如下 packagedsfa;import java.awt.*;importjava.awt.event.ActionEvent;importjava.awt.event.ActionListener;import javax.swing.*;...

空空如也

空空如也

1 2 3 4 5 ... 20
收藏数 1,126
精华内容 450
关键字:

最简单java计算器swing编写

java 订阅