在 Java 挥杆计算器中保存 3 个事件

Question

我是 Java 的新学生。我们的教授要求我们使用按键创建一个计算器。

说明如下：
运行程序。用户只能使用键盘输入数字。输入第一个数字后，您可以仅使用 4 个按钮 select 所需的操作。按下按钮后，可以进入第二个数字。按 SOLVE 按钮将答案显示到文本字段中。

我的问题是如何保存另外两个命令以用于求解。

num1 的示例我当时使用了 5（运算符，然后是 num2）。我怎样才能保存它们以在解决按钮中使用。这让我感到困惑，因为那里只有一个文本框。我尝试使用以下代码的两个文本框。可以用，但是有一个盒子失败了。

int a = Integer.parseInt(textFirst.getText());
int b = Integer.parseInt(textSecond.getText());
int c = 0;
if (e.getSource().equals(btnMulti)) {
c = a * b;
textResult.setText(String.valueOf("The product of "+a+" * "+b+" is "+c));
}

到目前为止，这是我的代码；

package first_Lab_2022;

import java.awt.EventQueue;

import javax.swing.JFrame;
import javax.swing.JTextField;
import javax.swing.JButton;
import java.awt.event.KeyAdapter;
import java.awt.event.KeyEvent;
import javax.swing.SwingConstants;
import java.awt.event.ActionListener;
import java.awt.event.ActionEvent;

public class Lab3_2 {

    private JFrame frame;
    private JTextField textField;
    
    int num1,num2 = 0;
    String operator="";

    /**
     * Launch the application.
     */
    public static void main(String[] args) {
        EventQueue.invokeLater(new Runnable() {
            public void run() {
                try {
                    Lab3_2 window = new Lab3_2();
                    window.frame.setVisible(true);
                } catch (Exception e) {
                    e.printStackTrace();
                }
            }
        });
    }

    /**
     * Create the application.
     */
    public Lab3_2() {
        initialize();
    }

    /**
     * Initialize the contents of the frame.
     */
    private void initialize() {
        frame = new JFrame();
        frame.getContentPane().addKeyListener(new KeyAdapter() {
            @Override
            public void keyPressed(KeyEvent e) {
                
            }
        });
        frame.setBounds(100, 100, 450, 300);
        frame.setDefaultCloseOperation(JFrame.EXIT_ON_CLOSE);
        frame.getContentPane().setLayout(null);
        
        textField = new JTextField();
        textField.addKeyListener(new KeyAdapter() {
            @Override
            public void keyPressed(KeyEvent e) {
                num1 = Integer.parseInt(textField.getText());
            }
        });
        textField.setHorizontalAlignment(SwingConstants.RIGHT);
        textField.setBounds(114, 73, 242, 60);
        frame.getContentPane().add(textField);
        textField.setColumns(10);
        
        JButton btnAdd = new JButton("Add");
        btnAdd.addActionListener(new ActionListener() {
            public void actionPerformed(ActionEvent e) {
                textField.setText(String.valueOf("+"));
            }
        });
        
        btnAdd.setBounds(124, 144, 100, 23);
        frame.getContentPane().add(btnAdd);
        
        JButton btnSub = new JButton("Subtract");
        btnSub.addActionListener(new ActionListener() {
            public void actionPerformed(ActionEvent e) {
            textField.setText(String.valueOf("-"));
            
            }
        });
        btnSub.setBounds(267, 144, 89, 23);
        frame.getContentPane().add(btnSub);
        
        JButton btnMul = new JButton("Multiply");
        btnMul.addActionListener(new ActionListener() {
            public void actionPerformed(ActionEvent e) {
                    textField.setText(String.valueOf("*"));
            }
        });
        btnMul.setBounds(124, 190, 100, 23);
        frame.getContentPane().add(btnMul);
        
        JButton btnDiv = new JButton("Divide");
        btnDiv.addActionListener(new ActionListener() {
            public void actionPerformed(ActionEvent e) {
                textField.setText(String.valueOf("/"));
            }
        });
        btnDiv.setBounds(267, 190, 100, 23);
        frame.getContentPane().add(btnDiv);
        
        JButton btnSolve = new JButton("Solve");
        btnSolve.addActionListener(new ActionListener() {
            public void actionPerformed(ActionEvent e) {

//              String a = textField.getText();
//              int i=Integer.parseInt(a);

            }
        });
        btnSolve.setBounds(202, 227, 100, 23);
        frame.getContentPane().add(btnSolve);
    }
}

我希望有人能帮我解决这个问题。

Answer 1

在这里问这种问题有点危险，因为您得到的答案可能超出您的需求 and/or 理解范围。

我怀疑也许你可以利用 JOptionPane 提示用户输入第一个数字、运算符和最后一个数字，将每个请求的结果分配给一个变量。

你应该先看看 How to Make Dialogs

要将输入限制为数值，您可以使用 How to Use Formatted Text Fields or a DocumentFilter。两者都不简单。或者，您可以使用 Integer.parse(String) 来解析提示用户时返回的文本，并将其放入循环中，直到获得适当的响应。

对于操作员，我只使用 JComboBox 来限制用户输入您想要的内容。参见 How to Use Combo Boxes。

现在，在你问之前，不，我不能给你举个例子（事实上我已经在上面列出了一个数字）。练习的重点是让您应用所学内容。

根据改进的要求进行更新

你会后悔你问的。

基本概念是您运行处于事件驱动的环境中，也就是说，某事发生后您会做出响应。你有责任管理状态并根据可用信息做事。

至于只接受整数的要求，你可以使用DocumentFilter，但这是相当高级的概念，详情请参阅Implementing a Document Filter。或者，您可以只解析文本并在失败时向用户显示错误消息，这取决于您。

import java.awt.EventQueue;
import java.awt.GridBagConstraints;
import java.awt.GridBagLayout;
import java.awt.GridLayout;
import java.awt.Toolkit;
import java.awt.event.ActionEvent;
import java.awt.event.ActionListener;
import javax.swing.ButtonGroup;
import javax.swing.JButton;
import javax.swing.JFrame;
import javax.swing.JOptionPane;
import javax.swing.JPanel;
import javax.swing.JTextField;
import javax.swing.JToggleButton;
import javax.swing.border.EmptyBorder;
import javax.swing.event.DocumentEvent;
import javax.swing.event.DocumentListener;
import javax.swing.text.AbstractDocument;
import javax.swing.text.AttributeSet;
import javax.swing.text.BadLocationException;
import javax.swing.text.DocumentFilter;

public class Test {

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

    public Test() {
        EventQueue.invokeLater(new Runnable() {
            @Override
            public void run() {
                JFrame frame = new JFrame();
                frame.add(new TestPane());
                frame.pack();
                frame.setLocationRelativeTo(null);
                frame.setVisible(true);
            }
        });
    }

    public class TestPane extends JPanel {

        enum Operator {
            ADD, SUBTRACT, MULTIPLE, DIVIDE;
        }

        private JTextField inputField;
        private JToggleButton addButton = new JToggleButton("Add");
        private JToggleButton subtractButton = new JToggleButton("Subtract");
        private JToggleButton multipleButton = new JToggleButton("Multiple");
        private JToggleButton divideButton = new JToggleButton("Divide");

        private JButton solveButton = new JButton("Solve");

        private JToggleButton[] operators = new JToggleButton[]{
            addButton, subtractButton, multipleButton, divideButton
        };

        private Integer firstValue;
        private Integer secondValue;
        private Operator operator;

        private ButtonGroup operatorButtonGroup = new ButtonGroup();

        public TestPane() {
            setBorder(new EmptyBorder(32, 32, 32, 32));
            setLayout(new GridBagLayout());

            inputField = new JTextField(10);
            inputField.setHorizontalAlignment(JTextField.TRAILING);
            ((AbstractDocument) inputField.getDocument()).setDocumentFilter(new IntegerDocumentFilter());
            inputField.getDocument().addDocumentListener(new DocumentListener() {
                @Override
                public void insertUpdate(DocumentEvent e) {
                    updateState();
                }

                @Override
                public void removeUpdate(DocumentEvent e) {
                    updateState();
                }

                @Override
                public void changedUpdate(DocumentEvent e) {
                    updateState();
                }
            });

            operatorButtonGroup.add(addButton);
            operatorButtonGroup.add(subtractButton);
            operatorButtonGroup.add(multipleButton);
            operatorButtonGroup.add(divideButton);

            addButton.addActionListener(new ActionListener() {
                @Override
                public void actionPerformed(ActionEvent e) {
                    firstValue = getCurrentValue();
                    if (firstValue != null) {
                        setOperator(Operator.ADD);
                        inputField.setText(null);
                    }
                }
            });

            subtractButton.addActionListener(new ActionListener() {
                @Override
                public void actionPerformed(ActionEvent e) {
                    firstValue = getCurrentValue();
                    if (firstValue != null) {
                        setOperator(Operator.SUBTRACT);
                        inputField.setText(null);
                    }
                }
            });

            multipleButton.addActionListener(new ActionListener() {
                @Override
                public void actionPerformed(ActionEvent e) {
                    firstValue = getCurrentValue();
                    if (firstValue != null) {
                        setOperator(Operator.MULTIPLE);
                        inputField.setText(null);
                    }
                }
            });

            divideButton.addActionListener(new ActionListener() {
                @Override
                public void actionPerformed(ActionEvent e) {
                    firstValue = getCurrentValue();
                    if (firstValue != null) {
                        setOperator(Operator.DIVIDE);
                        inputField.setText(null);
                    }
                }
            });

            GridBagConstraints gbc = new GridBagConstraints();
            gbc.gridx = 0;
            gbc.gridy = 0;
            gbc.weightx = 1;
            gbc.anchor = GridBagConstraints.LINE_END;
            add(inputField, gbc);

            JPanel operatorPane = new JPanel(new GridLayout(2, 2));
            operatorPane.add(addButton);
            operatorPane.add(subtractButton);
            operatorPane.add(multipleButton);
            operatorPane.add(divideButton);

            gbc.gridy++;
            gbc.weightx = 0;
            gbc.anchor = GridBagConstraints.LINE_END;

            add(operatorPane, gbc);

            gbc.gridy++;
            gbc.weightx = 0;
            gbc.anchor = GridBagConstraints.LINE_END;

            add(solveButton, gbc);

            solveButton.addActionListener(new ActionListener() {
                @Override
                public void actionPerformed(ActionEvent e) {
                    Integer secondValue = getCurrentValue();
                    if (firstValue != null && secondValue != null && operator != null) {
                        // Insert your logic here

                        resetState();
                    } else {
                        JOptionPane.showMessageDialog(TestPane.this, "Can't not solve equation, missing required parameters", "Error", JOptionPane.ERROR_MESSAGE);
                    }
                }
            });

            solveButton.setEnabled(false);
            setOperatorsEnabled(false);
        }

        protected void resetState() {
            firstValue = null;
            operator = null;

            inputField.setText(null);
            operatorButtonGroup.clearSelection();

            updateState();
        }

        protected Integer getCurrentValue() {
            try {
                return Integer.parseInt(inputField.getText());
            } catch (NumberFormatException exp) {
                return null;
            }
        }

        protected void setOperatorsEnabled(boolean enabled) {
            for (JToggleButton btn : operators) {
                btn.setEnabled(enabled);
            }
        }

        protected void updateState() {
            String currentValue = inputField.getText();
            if (currentValue.isBlank()) {
                solveButton.setEnabled(false);
                setOperatorsEnabled(false);
            } else {
                if (operator != null) {
                    solveButton.setEnabled(true);
                    setOperatorsEnabled(false);
                } else {
                    solveButton.setEnabled(false);
                    setOperatorsEnabled(true);
                }
            }
        }

        protected void setOperator(Operator operator) {
            this.operator = operator;
            updateState();
        }

    }

    public class IntegerDocumentFilter extends DocumentFilter {

        public void insertString(DocumentFilter.FilterBypass fb, int offset, String text, AttributeSet attr) throws BadLocationException {
            try {
                int parseInt = Integer.parseInt(text);
                super.insertString(fb, offset, text, attr);
            } catch (NumberFormatException exp) {
                Toolkit.getDefaultToolkit().beep();
            }
        }

        public void replace(DocumentFilter.FilterBypass fb, int offset, int length, String string, AttributeSet attr) throws BadLocationException {
            if (string == null || string.isBlank()) {
                super.replace(fb, offset, length, "", attr);
            } else {
                try {
                    int parseInt = Integer.parseInt(string);
                    super.replace(fb, offset, length, string, attr);
                } catch (NumberFormatException exp) {
                    Toolkit.getDefaultToolkit().beep();
                }
            }
        }
    }
}

在 Java 挥杆计算器中保存 3 个事件

Save 3 event in Java Swing Calculator

java

swing

根据改进的要求进行更新