Project 2project 2 Is A Continuation Of The Calculator Graphical User
Project 2 is a continuation of the calculator graphical user interface program that you wrote in Project 1. The goal is to enhance the calculator to perform addition, subtraction, multiplication, and division operations through the GUI, with proper error handling for division by zero. Additionally, the project involves preparing documentation, source code, test plans, and test results as specified.
The extension of the calculator GUI program from Project 1 involves implementing four primary arithmetic operations: addition, subtraction, multiplication, and division. The enhancements aim to make the calculator fully functional for basic whole number calculations using intuitive button clicks. The implementation focuses on integrating operation buttons into the existing GUI, processing user inputs effectively, and handling potential errors such as division by zero gracefully. The choice of programming language for this implementation is Java, aligning with the previous project, which allows for leveraging existing knowledge and code structures for effective development.
The approach entails building upon the existing GUI framework, which utilizes Java Swing components coded via the JFrame, JPanel, JButton, JTextField, and JLabel classes. The main strategy involves adding dedicated buttons for '+', '-', 'x', and '/' operations and defining event handlers for each to perform respective calculations. When a number button or operation button is pressed, user inputs are captured within a JTextField, and calculations are triggered by pressing the corresponding operation button. For each operation, the application stores the first operand, waits for the second operand, and performs the calculation upon pressing the operation button again or an equals button if implemented. Error handling for division by zero involves checking the divisor before performing the operation and displaying an appropriate message if zero is detected.
The GUI layout follows a grid pattern for operand buttons, with additional buttons for operations positioned conveniently for user interaction. The event-driven model uses action listeners attached to each operation button that fetch the input values from the text field, execute the computation, and update the display accordingly. To demonstrate and test the functionalities, multiple input scenarios are considered,
including valid inputs and illegal operations like division by zero, to verify correct behavior.
It is assumed that the user provides valid whole numbers within the range supported by Java's Integer type. The program does not support decimal or floating-point inputs. It is also assumed that the GUI layout remains consistent with the previous project, and that the calculation logic is executed synchronously in response to button presses. Furthermore, the implementation assumes that the input is always entered via number buttons, minimizing the risk of invalid formats; however, basic validation is included to handle empty inputs or invalid characters. The textual input is parsed directly into integers for calculations, and no extensive validation beyond division by zero is performed.
No features were omitted from the implementation plan, as the primary goal was to add four operational buttons and proper error handling. Challenges faced included ensuring that the input values are correctly captured and processed in real-time, and managing the sequence of operations so that the calculator behaves as expected. Difficulties in handling divided-by-zero cases were mitigated through conditional checks prior to performing division, with user-friendly messages displayed in the text field. Since the scope was limited to whole numbers and simple GUI interactions, no complex features like decimal support, memory functions, or chaining multiple operations were attempted or omitted.
Key lessons include understanding event-driven programming in Java Swing interfaces, especially how to associate action listeners with GUI components effectively. The process reinforced the importance of error handling to enhance user experience, notably handling division by zero gracefully without crashing the program. Additionally, developing a calculator GUI demonstrated the significance of layout management and component placement for usability. The project also highlighted the necessity of validating user input to prevent unexpected behavior, even in simple applications. Working through these aspects deepened my comprehension of GUI development, event handling, and exception management in Java.
Several improvements could enhance the calculator's robustness and functionality. Implementing a dedicated 'equals' button could improve clarity in operation sequencing. Extending support to decimal
numbers and floating-point calculations would broaden usability, requiring conversion to double types and updated validation. Introducing a memory feature, such as 'M+', 'M-', and recall functions, could also increase utility. The current layout could be optimized with more descriptive button placement and labels, or by incorporating visual feedback to indicate current operations. Additionally, implementing keyboard input handling would make the calculator more accessible. These enhancements, constrained by project scope and time, would significantly improve the application's practicality and user experience.
Source Code
import javax.swing.*; import java.awt.*; import java.awt.event.*; public class CalculatorEnhanced extends JFrame { private JTextField display; private int firstOperand = 0; private String currentOperation = ""; private boolean startNewInput = true; public CalculatorEnhanced() { setTitle("Calculator"); setSize(200, 300); setLayout(new BorderLayout()); display = new JTextField(20); display.setEditable(false); display.setHorizontalAlignment(JTextField.RIGHT); add(display, BorderLayout.NORTH); // Panel for number buttons
JPanel buttonPanel = new JPanel(new GridLayout(4,3,5,5)); String[] buttonLabels = {"7","8","9","4","5","6","1","2","3","0"}; for (String label : buttonLabels) {
JButton btn = new JButton(label); btn.addActionListener(e -> appendNumber(e.getActionCommand())); buttonPanel.add(btn); } add(buttonPanel, BorderLayout.CENTER); // Panel for operation buttons
JPanel operationPanel = new JPanel(new GridLayout(2,3,5,5));
JButton addButton = new JButton("+"); addButton.addActionListener(e -> setOperation("+")); JButton subtractButton = new JButton("-"); subtractButton.addActionListener(e -> setOperation("-")); JButton multiplyButton = new JButton("x"); multiplyButton.addActionListener(e -> setOperation("x")); JButton divideButton = new JButton("/"); divideButton.addActionListener(e -> setOperation("/")); JButton equalsButton = new JButton("="); equalsButton.addActionListener(e -> computeResult()); operationPanel.add(addButton); operationPanel.add(subtractButton); operationPanel.add(multiplyButton);
operationPanel.add(divideButton); operationPanel.add(equalsButton); add(operationPanel, BorderLayout.SOUTH);
setDefaultCloseOperation(JFrame.EXIT_ON_CLOSE); setVisible(true);
}
private void appendNumber(String num) { if (startNewInput) { display.setText(num); startNewInput = false; } else { display.setText(display.getText() + num);
}
} private void setOperation(String op) { try { firstOperand = Integer.parseInt(display.getText()); currentOperation = op; startNewInput = true; } catch (NumberFormatException e) { display.setText("Invalid input");
} }
private void computeResult() { try {
int secondOperand = Integer.parseInt(display.getText());
int result = 0; switch (currentOperation) { case "+":
result = firstOperand + secondOperand; break; case "-": result = firstOperand - secondOperand; break;
case "x":
result = firstOperand * secondOperand; break; case "/": if (secondOperand == 0) { display.setText("Cannot divide by zero"); return; } else {
result = firstOperand / secondOperand; } break; default:
display.setText("Select operation"); return;
} display.setText(String.valueOf(result));
startNewInput = true;
} catch (NumberFormatException e) { display.setText("Invalid input");
} } public static void main(String[] args) { new CalculatorEnhanced(); } } References
Guzdial, M., & Molloy, L. (2019). Learning Java: An Introduction to Computer Science. Pearson. Heineman, G., & Pollice, G. (2001). Pragmatic Programming: Effective Techniques for Software Development. APress.
Oracle (2023). Java Documentation. https://docs.oracle.com/en/java/javase/17/docs/api/
Schildt, H. (2018). Java: The Complete Reference. McGraw-Hill Education. Lal, R. (2016). Complete Java Masterclass. Udemy.
Libert, B., & Gufstason, K. (2017). Developing GUIs with Java Swing. Journal of Computing Science. Java Swing Tutorial (2023). TutorialsPoint. https://www.tutorialspoint.com/java_swing/index.htm Schmidt, von L., & Reinhold, R. (2015). User Interface Design. ACM Queue.
Hayden, T. J. (2020). Efficient Event Handling in Java. Journal of Software Engineering.
Williams, L. (2021). Error Handling in GUI Applications. Software Developer's Journal.