Two number division

1. Import Statements
java
CopyEdit
import javax.swing.*;
import java.awt.*;
import java.awt.event.ActionEvent;
import java.awt.event.ActionListener;

• javax.swing.*: Imports the Swing library, which is used for building graphical user
interfaces (GUIs) in Java. It includes components like buttons, labels, text fields, and
more.
• java.awt.*: Imports the Abstract Window Toolkit (AWT) library. It contains classes for
building user interfaces and handling events.
• java.awt.event.ActionEvent and java.awt.event.ActionListener: These classes
are used to handle button click events. ActionEvent is the event object passed when a
button is clicked, and ActionListener is an interface used to define the action
performed on an event.

2. Class Definition
java
CopyEdit
public class DivisionCalculator {

• public class DivisionCalculator: This defines the class DivisionCalculator. It's

a public class, which means it can be accessed by other classes. This is the main class of
the program.

3. Main Method
java
CopyEdit
public static void main(String[] args) {

• public static void main(String[] args): This is the entry point of the program.
When the program is run, this method is executed.

4. JFrame Creation
java
CopyEdit
JFrame frame = new JFrame("Integer Division Calculator");

• JFrame: Creates the main window for the GUI. It represents the main frame that will
contain all other components like buttons, text fields, labels, etc.
• "Integer Division Calculator": This is the title of the window that appears at the
top.

5. Create Components (Labels, Text Fields, Buttons)

java
CopyEdit
JLabel label1 = new JLabel("Num1:");
JTextField num1Field = new JTextField(10);

JLabel label2 = new JLabel("Num2:");

JTextField num2Field = new JTextField(10);

JButton divideButton = new JButton("Divide");

JLabel resultLabel = new JLabel("Result:");

JTextField resultField = new JTextField(10);
resultField.setEditable(false);

• JLabel label1 and JLabel label2: These are labels that will be used to display text
("Num1:" and "Num2:") next to the respective input fields.
• JTextField num1Field and JTextField num2Field: These are text fields where the
user will input the values for Num1 and Num2. The 10 argument specifies the width of the
text field.
• JButton divideButton: This creates a button labeled "Divide" that the user will click
to perform the division.
• JLabel resultLabel: This label displays "Result:" next to the result text field.
• JTextField resultField: This is a text field where the result will be displayed. It is set
to non-editable with resultField.setEditable(false) so the user cannot modify the
result directly.

6. Set Layout for Frame

java
CopyEdit
frame.setLayout(new FlowLayout());
 • frame.setLayout(new FlowLayout()): This sets the layout manager for the frame.
FlowLayout places components in a left-to-right flow, which means the components will
be arranged one after the other in the frame.

7. Add Components to the Frame

java
CopyEdit
frame.add(label1);
frame.add(num1Field);

frame.add(label2);
frame.add(num2Field);

frame.add(divideButton);

frame.add(resultLabel);
frame.add(resultField);

• These lines add the components (labels, text fields, button) to the frame. Each add()
method places a component inside the frame so it will be visible to the user.

8. Action Listener for Divide Button

java
CopyEdit
divideButton.addActionListener(new ActionListener() {
@Override
public void actionPerformed(ActionEvent e) {

• divideButton.addActionListener(): This attaches an action listener to the

divideButton so that when the button is clicked, an event (ActionEvent) is triggered.
• new ActionListener(): Defines a new action listener that listens for the button click
and specifies what to do when the button is clicked.
• actionPerformed(ActionEvent e): This method is automatically called when the user
clicks the button. It contains the logic for handling the division operation.

9. Get Input and Perform Division

java
CopyEdit
try {
String num1Text = num1Field.getText();
String num2Text = num2Field.getText();
 int num1 = Integer.parseInt(num1Text);
int num2 = Integer.parseInt(num2Text);

if (num2 == 0) {
throw new ArithmeticException("Division by zero is
not allowed.");
}

int result = num1 / num2;

resultField.setText(String.valueOf(result));

• num1Field.getText() and num2Field.getText(): These retrieve the text entered by

the user in the text fields for Num1 and Num2.
• Integer.parseInt(num1Text) and Integer.parseInt(num2Text): These methods
convert the text input into integers.
• if (num2 == 0): Checks if Num2 is zero. If it is, an ArithmeticException is thrown to
handle the division by zero.
• int result = num1 / num2: This performs the division of Num1 by Num2 and stores the
result.
• resultField.setText(String.valueOf(result)): Converts the result to a string and
displays it in the resultField.

10. Catch Exceptions

java
CopyEdit
} catch (NumberFormatException ex) {
JOptionPane.showMessageDialog(frame, "Please enter valid
integers.", "Invalid Input", JOptionPane.ERROR_MESSAGE);
} catch (ArithmeticException ex) {
JOptionPane.showMessageDialog(frame, ex.getMessage(),
"Error", JOptionPane.ERROR_MESSAGE);
}

• catch (NumberFormatException ex): This block catches the

NumberFormatException that occurs when the user enters non-integer values. It shows
an error message dialog.
• catch (ArithmeticException ex): This block catches the ArithmeticException
(e.g., division by zero) and shows an error message dialog with the exception message
(like "Division by zero is not allowed.").

11. Final Setup for the Frame

java
CopyEdit
 frame.setSize(300, 200);
frame.setDefaultCloseOperation(JFrame.EXIT_ON_CLOSE);
frame.setVisible(true);
}
}

• frame.setSize(300, 200): Sets the size of the frame to 300 pixels wide and 200 pixels
tall.
• frame.setDefaultCloseOperation(JFrame.EXIT_ON_CLOSE): This ensures that the
program will terminate when the user closes the window.
• frame.setVisible(true): Makes the frame visible to the user, displaying the UI.

Summary of the Program:

1. GUI components (text fields, buttons, labels) are set up.

2. User inputs are taken for Num1 and Num2.
3. Event handling: The "Divide" button triggers division.
4. Exception handling:
o NumberFormatException: Displays an error if the input is not an integer.
o ArithmeticException: Displays an error if dividing by zero.
5. The result is shown in a non-editable text field.

This is a simple, functional calculator program that demonstrates basic Swing components and
exception handling.

Sure! Let's go through the FactorialCalculator program line by line to understand what it's
doing:

Factorial calculator
Imports:
java
CopyEdit
import javax.swing.*;
import java.awt.*;
import java.awt.event.ActionEvent;
import java.awt.event.ActionListener;

• javax.swing.*: This package is used to create GUI components like JFrame, JButton,
JTextField, etc.
• java.awt.*: The Abstract Window Toolkit (AWT) provides classes for creating
graphical user interfaces, including layout managers and event handling.
• java.awt.event.*: This package is used for handling events (like button clicks) that
occur in the application.
Class Declaration:
java
CopyEdit
public class FactorialCalculator extends JFrame implements ActionListener {

• The class FactorialCalculator extends JFrame, which means it is a window with a

title bar, borders, etc.
• It implements the ActionListener interface, meaning this class is capable of listening
for and handling events such as button clicks.

Instance Variables:
java
CopyEdit
private JTextField inputField, resultField;
private JButton computeButton;

• JTextField inputField: A text field where the user will enter the number whose
factorial is to be computed.
• JTextField resultField: A text field where the computed factorial will be displayed.
• JButton computeButton: A button that, when clicked, triggers the computation of the
factorial.

Constructor:
java
CopyEdit
public FactorialCalculator() {

• This is the constructor of the FactorialCalculator class, which sets up the GUI
components when an instance of this class is created.

java
CopyEdit
setTitle("Factorial Calculator");
setSize(300, 200); // Set initial size
setDefaultCloseOperation(JFrame.EXIT_ON_CLOSE);
setLayout(new GridBagLayout()); // Flexible & neat layout

• setTitle("Factorial Calculator"): Sets the title of the window.

• setSize(300, 200): Sets the size of the window to 300x200 pixels.
• setDefaultCloseOperation(JFrame.EXIT_ON_CLOSE): Ensures the program will exit
when the window is closed.
• setLayout(new GridBagLayout()): This sets the layout manager of the window to
GridBagLayout, which is flexible and allows easy placement of components in rows and
columns.

java
CopyEdit
GridBagConstraints gbc = new GridBagConstraints();
gbc.insets = new Insets(5, 5, 5, 5); // Padding

• GridBagConstraints gbc: This object is used to define constraints for the components
when they are added to the layout.
• gbc.insets = new Insets(5, 5, 5, 5): Adds padding around components for better
readability (5 pixels on all sides).

Adding Components:
java
CopyEdit
// Row 1: Label + Input Field
gbc.gridx = 0;
gbc.gridy = 0;
add(new JLabel("Enter Number:"), gbc);

• gbc.gridx = 0: Positions the label at column 0 (left side).

• gbc.gridy = 0: Positions the label at row 0 (top row).
• add(new JLabel("Enter Number:"), gbc): Adds a label to the frame, telling the user
to "Enter Number."

java
CopyEdit
gbc.gridx = 1;
inputField = new JTextField(10);
add(inputField, gbc);

• gbc.gridx = 1: Positions the input text field in column 1 (next to the label).
• inputField = new JTextField(10): Creates a text field with 10 columns.
• add(inputField, gbc): Adds the inputField (text field) to the frame.

java
CopyEdit
// Row 2: Compute Button
gbc.gridx = 0;
gbc.gridy = 1;
gbc.gridwidth = 2; // Span 2 columns
computeButton = new JButton("Compute");
computeButton.addActionListener(this);
add(computeButton, gbc);

• gbc.gridx = 0 and gbc.gridy = 1: Positions the "Compute" button at row 1, column 0

(in the next row).
• gbc.gridwidth = 2: The button spans across two columns (so it's centered below the
input fields).
• computeButton = new JButton("Compute"): Creates a button labeled "Compute."
• computeButton.addActionListener(this): Adds an ActionListener to the button
so that when it's clicked, the actionPerformed method is triggered.
 • add(computeButton, gbc): Adds the button to the frame.

java
CopyEdit
// Row 3: Result Label + Output Field
gbc.gridx = 0;
gbc.gridy = 2;
gbc.gridwidth = 1;
add(new JLabel("Factorial:"), gbc);

• gbc.gridx = 0: Positions the "Factorial" label at column 0.

• gbc.gridy = 2: Positions the label at row 2 (below the button).
• add(new JLabel("Factorial:"), gbc): Adds the label "Factorial."

java
CopyEdit
gbc.gridx = 1;
resultField = new JTextField(10);
resultField.setEditable(false);
add(resultField, gbc);

• gbc.gridx = 1: Positions the result field at column 1 (next to the label).

• resultField = new JTextField(10): Creates a text field with 10 columns for
displaying the result.
• resultField.setEditable(false): Makes the result field non-editable since it's just
for displaying the result.
• add(resultField, gbc): Adds the result field to the frame.

java
CopyEdit
setVisible(true);
}

• setVisible(true): Makes the frame visible to the user.

Action Listener:
java
CopyEdit
@Override
public void actionPerformed(ActionEvent e) {
try {
int n = Integer.parseInt(inputField.getText());
if (n < 0) {
resultField.setText("Invalid!");
return;
}

long factorial = 1;
for (int i = 1; i <= n; i++) {
factorial *= i;
}
 resultField.setText(String.valueOf(factorial));
} catch (NumberFormatException ex) {
resultField.setText("Invalid!");
}
}

• actionPerformed: This method is called when the "Compute" button is clicked.

• int n = Integer.parseInt(inputField.getText()): Gets the text from the input
field, converts it to an integer.
• if (n < 0): If the input is negative, it sets the result field to "Invalid!" and exits the
method.
• long factorial = 1;: Initializes the factorial value to 1.
• for (int i = 1; i <= n; i++): Loops from 1 to the input number n.
o factorial *= i;: Multiplies the current value of factorial by i.
• resultField.setText(String.valueOf(factorial)): Converts the computed
factorial to a string and sets it in the result field.
• catch (NumberFormatException ex): If the input is not a valid integer (like letters or
symbols), it catches the exception and sets the result field to "Invalid!"

Main Method:
java
CopyEdit
public static void main(String[] args) {
new FactorialCalculator();
}

• This is the entry point of the program. It creates an instance of FactorialCalculator,

which initializes the frame and components.

Summary:

• This program creates a graphical user interface for calculating the factorial of a number.
• The user inputs a number in a text field, clicks "Compute," and the factorial result is
displayed.
• The program handles invalid inputs and shows "Invalid!" when the input is not an integer
or when the input is negative.