如何用java实现以下的简易计算器？

一个小程序，正在学习中。就是类似于这个图片：需要做到以下的这种图片样式：谢谢大家！

img

img


import java.awt.GridBagConstraints;
import java.awt.GridBagLayout;
import java.awt.Insets;
import java.awt.event.ActionEvent;
import java.awt.event.ActionListener;

import javax.swing.*;
import javax.swing.JButton;
import javax.swing.JFrame;
import javax.swing.JLabel;
import javax.swing.JPanel;
import javax.swing.JTextField;

import javax.swing.border.Border;


public class dome extends JFrame implements ActionListener {
    private JTextField num1Field; // 第一个数的输入框
    private JTextField num2Field; // 第二个数的输入框
    private JLabel exprLabel; // 显示计算表达式的标签
    private JTextField resultField; // 添加一个文本框用于显示计算结果
    private JButton plusBtn; // 加号按钮
    private JButton minusBtn; // 减号按钮
    private JButton clearBtn; // 清除按钮

    // 构造方法，用于初始化计算器的界面元素
    public dome() {
        super("简单加减法计算器"); 

        // 初始化界面元素
        num1Field = new JTextField(5); // 创建一个长度为 5 的文本框，用于输入第一个数
        num2Field = new JTextField(5); // 创建一个长度为 5 的文本框，用于输入第二个数
        exprLabel = new JLabel(); // 创建一个用于显示表达式的标签
        resultField = new JTextField(10);
        plusBtn = new JButton("+"); 
        minusBtn = new JButton("-"); 
        clearBtn = new JButton("clear"); 

        // 使用 GridBagLayout 布局
        JPanel panel = new JPanel(new GridBagLayout());
        Border border = BorderFactory.createEmptyBorder(10, 10, 10, 10); // 创建一个空边框，用于设置面板的边距
        panel.setBorder(border); // 将空边框设置为面板的边距
        GridBagConstraints c = new GridBagConstraints(); // 创建一个 GridBagConstraints 对象，用于设置组件的位置和大小
        c.gridx = 0;
        c.gridy = 0; 
        c.anchor = GridBagConstraints.LINE_START; // 组件在其网格内的对齐方式
        c.insets = new Insets(5, 0, 0, 0); // 组件和其周围的留白距离
        panel.add(num1Field, c); // 将 num1Field 组件添加到面板中

        c.gridx = 1;
        c.insets = new Insets(5, 5, 0, 0);
        panel.add(num2Field, c);

        c.gridx = 0;
        c.gridy = 1;
        c.gridwidth = 3; // 组件宽度占据的网格数
        c.insets = new Insets(10, 10, 5, 0);
        panel.add(plusBtn, c);

        c.gridx = 1;
        c.gridwidth = GridBagConstraints.REMAINDER; // 指定组件占据剩余的所有网格
        c.insets = new Insets(10, 0, 5, 10);
        panel.add(minusBtn, c);

        c.gridx = 2;
        c.gridy = 1;
        c.gridwidth = GridBagConstraints.REMAINDER;
        c.insets = new Insets(10, 10, 5, 10);
        panel.add(clearBtn, c);

        c.gridx = 0;
        c.gridy = 3;
        c.gridwidth = GridBagConstraints.REMAINDER;
        c.insets = new Insets(10, 0, 10, 10);
        c.anchor = GridBagConstraints.LAST_LINE_START;
        panel.add(resultField, c); // 将 resultField 组件添加到面板中

        // 给按钮添加事件监听器
        plusBtn.addActionListener(this); 
        minusBtn.addActionListener(this);
        clearBtn.addActionListener(this); 

        // 将面板添加到窗口中
        setContentPane(panel);

        // 设置窗口大小，让界面可以自动缩放
        pack();

        // 设置窗口关闭方式等属性
        setDefaultCloseOperation(JFrame.EXIT_ON_CLOSE); // 设置窗口关闭时退出程序
        setLocationRelativeTo(null); // 居中显示窗口
        setVisible(true); // 显示窗口
    }

    // 事件处理方法，用于实现加减法计算
    @Override
    public void actionPerformed(ActionEvent e) {
        try {
            int num1 = Integer.parseInt(num1Field.getText()); // 获取第一个数的值，并转换为整型
            int num2 = Integer.parseInt(num2Field.getText()); // 获取第二个数的值，并转换为整型
            int result = 0; 
            if (e.getSource() == plusBtn) { // 如果是加号按钮被点击
                result = num1 + num2; 
                exprLabel.setText(num1 + " + " + num2 + " = " + result); 
                resultField.setText(num1 + "+" + num2 + "=" + result); 
            } else if (e.getSource() == minusBtn) { // 如果是减号按钮被点击
                result = num1 - num2; 
                exprLabel.setText(num1 + " - " + num2 + " = " + result); 
                resultField.setText(num1 + "-" + num2 + "=" + result); 
            } else if (e.getSource() == clearBtn) { /
                num1Field.setText(""); // 将第一个输入框清空
                num2Field.setText(""); // 将第二个输入框清空
                exprLabel.setText(""); // 将表达式标签清空
                resultField.setText(""); // 将结果文本框清空
                return;
            }
        } catch (NumberFormatException ex) { // 捕获可能出现的输入格式错误
            exprLabel.setText("输入不合法！");
        }
    }


    public static void main(String[] args) {
        new dome();
    }
}

参考链接：https://www.cnblogs.com/qzyouli/p/15810418.html

可以参考这个很全面，也很详细，你只需要把加、减、清除这几个功能拆出来就能用。
具体文章地址：https://blog.csdn.net/weixin_50301255/article/details/110731387

以下是一个简单的实现思路，该回答通过自己思路及引用到GPTᴼᴾᴱᴺᴬᴵ搜索,得到内容具体如下：
以下是一个用Java实现简易计算器的示例代码：

import java.util.Scanner;

public class Calculator {
    public static void main(String[] args) {
        Scanner scanner = new Scanner(System.in);
        double num1, num2, result;
        char operator;

        System.out.println("欢迎使用简易计算器");
        System.out.print("请输入第一个数：");
        num1 = scanner.nextDouble();
        System.out.print("请输入运算符（+、-、*、/）：");
        operator = scanner.next().charAt(0);
        System.out.print("请输入第二个数：");
        num2 = scanner.nextDouble();

        switch (operator) {
            case '+':
                result = num1 + num2;
                System.out.printf("%.2f + %.2f = %.2f", num1, num2, result);
                break;
            case '-':
                result = num1 - num2;
                System.out.printf("%.2f - %.2f = %.2f", num1, num2, result);
                break;
            case '*':
                result = num1 * num2;
                System.out.printf("%.2f * %.2f = %.2f", num1, num2, result);
                break;
            case '/':
                if (num2 == 0) {
                    System.out.println("除数不能为0");
                    return;
                }
                result = num1 / num2;
                System.out.printf("%.2f / %.2f = %.2f", num1, num2, result);
                break;
            default:
                System.out.println("运算符输入错误");
        }
    }
}

这个程序使用了Java的标准输入输出和基本的控制流语句，能够实现两个数字的加、减、乘、除四种基本运算。您可以根据需要对代码进行修改和扩展，以实现更多功能。

如果以上回答对您有所帮助，点击一下采纳该答案～谢谢

该回答引用chatgpt:

img



import javax.swing.*;
import java.awt.*;
import java.awt.event.ActionEvent;
import java.awt.event.ActionListener;

public class SimpleCalculator extends JFrame implements ActionListener {
    private JTextField numField1;
    private JTextField numField2;
    private JButton addButton;
    private JButton subtractButton;
    private JButton clearButton;
    private JLabel resultLabel;

    public SimpleCalculator() {
        setTitle("简易计算器");
        setSize(300, 150);
        setDefaultCloseOperation(JFrame.EXIT_ON_CLOSE);

        // 创建面板
        JPanel panel = new JPanel();
        panel.setLayout(new GridLayout(2, 2));

        // 第一行：两个输入框
        numField1 = new JTextField();
        numField2 = new JTextField();
        panel.add(numField1);
        panel.add(numField2);

        // 第二行：加减按钮和clear按钮
        JPanel buttonPanel = new JPanel();
        addButton = new JButton("+");
        addButton.addActionListener(this);
        subtractButton = new JButton("-");
        subtractButton.addActionListener(this);
        clearButton = new JButton("Clear");
        clearButton.addActionListener(this);
        buttonPanel.add(addButton);
        buttonPanel.add(subtractButton);
        buttonPanel.add(clearButton);

        // 第三行：结果显示
        resultLabel = new JLabel("结果:");
        panel.add(resultLabel);

        add(panel, BorderLayout.CENTER);
        add(buttonPanel, BorderLayout.SOUTH);
        setVisible(true);
    }

    @Override
    public void actionPerformed(ActionEvent e) {
        if (e.getSource() == addButton) {
            performCalculation('+');
        } else if (e.getSource() == subtractButton) {
            performCalculation('-');
        } else if (e.getSource() == clearButton) {
            numField1.setText("");
            numField2.setText("");
            resultLabel.setText("结果:");
        }
    }

    private void performCalculation(char operator) {
        String num1Str = numField1.getText();
        String num2Str = numField2.getText();

        if (num1Str.isEmpty() || num2Str.isEmpty()) {
            resultLabel.setText("请输入有效数字");
            return;
        }

        double num1 = Double.parseDouble(num1Str);
        double num2 = Double.parseDouble(num2Str);
        double result;

        if (operator == '+') {
            result = num1 + num2;
        } else {
            result = num1 - num2;
        }

        resultLabel.setText("结果: " + result);
    }

    public static void main(String[] args) {
        SwingUtilities.invokeLater(new Runnable() {
            public void run() {
                new SimpleCalculator();
            }
        });
    }
}

我使用 JavaFX：

package app.app;

import javafx.application.Application;
import javafx.scene.Node;
import javafx.scene.Scene;
import javafx.scene.control.Button;
import javafx.scene.control.Control;
import javafx.scene.control.TextField;
import javafx.scene.layout.HBox;
import javafx.scene.layout.Priority;
import javafx.scene.layout.VBox;
import javafx.stage.Stage;

public class Calculator extends Application {
    private static void setStretch(HBox box) {
        box.setSpacing(3);
        for (Node node : box.getChildren()) {
            ((Control)node).setMaxWidth(Double.MAX_VALUE);
            HBox.setHgrow(node, Priority.ALWAYS);
        }
    }

    @Override
    public void start(Stage stage) {
        TextField field1 = new TextField("0");
        TextField field2 = new TextField("0");

        HBox fieldsHBox = new HBox();
        fieldsHBox.getChildren().addAll(field1, field2);
        setStretch(fieldsHBox);

        Button plusBtn = new Button("+");
        Button subtractBtn = new Button("-");
        Button clearBtn = new Button("clear");

        HBox btnsHBox = new HBox();
        btnsHBox.getChildren().addAll(plusBtn, subtractBtn, clearBtn);
        setStretch(btnsHBox);

        TextField resField = new TextField();
        resField.setMaxWidth(Double.MAX_VALUE);
        resField.setEditable(false);

        VBox root = new VBox();
        root.setSpacing(3);
        root.getChildren().addAll(fieldsHBox, btnsHBox, resField);

        plusBtn.setOnAction(actionEvent -> {
            int num1 = Integer.parseInt(field1.getText());
            int num2 = Integer.parseInt(field2.getText());
            resField.setText(field1.getText() + "+" + field2.getText() + "=" + (num1 + num2));
        });

        subtractBtn.setOnAction(actionEvent -> {
            int num1 = Integer.parseInt(field1.getText());
            int num2 = Integer.parseInt(field2.getText());
            resField.setText(field1.getText() + "-" + field2.getText() + "=" + (num1 - num2));
        });

        clearBtn.setOnAction(actionEvent -> {
            field1.setText("");
            field2.setText("");
            resField.setText("");
            field1.requestFocus();
        });

        Scene scene = new Scene(root, 500, 150);

        stage.setTitle("计算器");
        stage.setScene(scene);
        stage.show();
    }

    public static void main(String[] args) {
        launch(args);
    }
}
  • 帮你找了个相似的问题, 你可以看下: https://ask.csdn.net/questions/241537
  • 这篇博客你也可以参考下：重学 Java 设计模式：实战观察者模式「模拟类似小客车指标摇号过程，监听消息通知用户中签场景」
  • 你还可以看下java参考手册中的 java-学习Java语言 - 描述Java编程语言的基本概念和特点的课程。-泛型是Java编程语言的一个强大功能。它们提高了代码的类型安全性，使更多的错误可以在编译时发现。-野生动物
  • 除此之外, 这篇博客: 【大厂面试题系列】：请写出Java中线程安全的单例模式【设计模式】中的 第一种：双重检查 部分也许能够解决你的问题, 你可以仔细阅读以下内容或跳转源博客中阅读:
  • public class Singleton {

    private volatile static Singleton singleton;

    private Singleton() {

    }

    public static Singleton getSingleton() {
        if (singleton == null) {
            synchronized (Singleton.class) {
                if (singleton == null) {
                    singleton = new Singleton();
                }
            }
        }
        return singleton;
    }
}

    在这里插入图片描述



  • 您还可以看一下 汤小洋老师的手把手搭建Java学生信息管理系统【附源码】（毕设）课程中的 课程概述小节, 巩固相关知识点
  • 以下回答由chatgpt基于相关博客总结生成:

    我可以为您提供一个简易计算器的实现思路，可以使用Java Swing GUI库来实现界面，使用Java中的数学库完成计算器计算功能。具体步骤如下：

    1. 创建一个新项目并引入Swing库。

    2. 创建一个JFrame对象作为主界面，设置窗口大小、标题和布局方式。

    3. 创建文本框和按钮对象，并添加到主界面中，使用GridLayout布局方式排列。

    4. 为按钮对象添加动作监听器，以便在用户点击按钮时进行相应的操作。

    5. 在动作监听器中，根据用户所点击的按钮执行相应的计算操作，例如加减乘除、取模、倒数等。

    6. 使用Java中的数学库完成计算器计算功能，例如通过调用Math类中的方法进行计算。

    7. 将计算结果显示在文本框中，以便用户查看。

    下面是一个简单的Java Swing计算器的代码示例：

    import java.awt.*;
import java.awt.event.*;
import javax.swing.*;

public class Calculator extends JFrame implements ActionListener {

    private JTextField textField;

    public Calculator() {
        setTitle("Calculator");
        setSize(200, 250);
        setLocationRelativeTo(null);
        setDefaultCloseOperation(EXIT_ON_CLOSE);

        JPanel panel = new JPanel(new GridLayout(4, 4));

        textField = new JTextField();
        add(textField, BorderLayout.NORTH);
        textField.setEditable(false);

        String[] buttonLabels = {
            "7", "8", "9", "/",
            "4", "5", "6", "*",
            "1", "2", "3", "-",
            "0", ".", "=", "+"
        };

        for (String label : buttonLabels) {
            JButton button = new JButton(label);
            button.addActionListener(this);
            panel.add(button);
        }

        add(panel);
        setVisible(true);
    }

    public void actionPerformed(ActionEvent e) {
        String action = e.getActionCommand();
        if (action.equals("=")) {
            String expression = textField.getText();
            try {
                double result = evaluate(expression);
                textField.setText(Double.toString(result));
            } catch (Exception ex) {
                textField.setText("Error");
            }
        } else {
            textField.setText(textField.getText() + action);
        }
    }

    private double evaluate(String expression) {
        return (double) new ScriptEngineManager()
            .getEngineByName("JavaScript")
            .eval(expression);
    }

    public static void main(String[] args) {
        new Calculator();
    }
}

    这个计算器实现了基本的加减乘除和小数点等功能，当用户点击“=”按钮时，使用Java中的ScriptEngineManager类进行动态求值计算，并将结果显示在文本框中。

    当然，这只是一个简单的示例，还有很多扩展和优化空间，例如添加取消和撤销功能、支持复杂的计算表达式等。