Simple Calculator Program in Java (Code, switch, methods, swing)

Creating a calculator program in Java is often one of the first projects undertaken by aspiring developers. It serves as an excellent introduction to the fundamentals of programming logic, user input, and basic arithmetic operations in Java.

In this step-by-step tutorial, we will guide you through the process of creating a simple calculator program in Java. Whether you're a beginner looking to kickstart your programming journey or an experienced developer wanting to refresh your skills, this tutorial is designed to be accessible and educational.

By the end of this tutorial, you will have a fully functional Java calculator program that can perform addition, subtraction, multiplication, and division. You will also gain a deeper understanding of concepts like variables, user input, conditional statements, and loops, which are fundamental to Java programming and many other programming languages.

So, let's get started and create a Simple Calculator Program in Java. Get ready to explore the world of Java programming and create a useful tool that you can further enhance and customize as you continue your coding journey.

Concepts to Learn:

Program for Calculator in Java Using if else

Coding a calculator in Java has several ways. The first way is to use the if else conditional statements:

Code

import java.util.Scanner;

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

        System.out.print("Enter first number: ");
        num1 = input.nextDouble();

        System.out.print("Enter an operator (+, -, *, /): ");
        operator = input.next().charAt(0);

        System.out.print("Enter second number: ");
        num2 = input.nextDouble();

        if (operator == '+') {
            result = num1 + num2;
        } else if (operator == '-') {
            result = num1 - num2;
        } else if (operator == '*') {
            result = num1 * num2;
        } else if (operator == '/') {
            if (num2 != 0) {
                result = num1 / num2;
            } else {
                System.out.println("Error: Division by zero is not allowed.");
                return;
            }
        } else {
            System.out.println("Error: Invalid operator.");
            return;
        }

        System.out.println("Result: " + result);
    }
}

Output

Enter first number: 10
Enter an operator (+, -, *, /): *
Enter second number: 5
Result: 50.0

Explanation

This example shows a simple calculator program in Java using if-else statements. It begins by taking user input for two numbers and an operator (+, -, , /).

Then, it uses if-else statements to determine which operation to perform based on the operator entered.

If the operator is '+', it performs addition; if '-', subtraction; if '', multiplication; and if '/', division.

The Java code for calculator also checks for division by zero and handles invalid operators.

Finally, it displays the result of the calculation.

Simple Calculator Using Switch Case in Java

Here is a Java program for calculator using switch case:

Code

import java.util.Scanner;

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

        System.out.print("Enter first number: ");
        num1 = input.nextDouble();

        System.out.print("Enter an operator (+, -, *, /): ");
        operator = input.next().charAt(0);

        System.out.print("Enter second number: ");
        num2 = input.nextDouble();

        switch (operator) {
            case '+':
                result = num1 + num2;
                break;
            case '-':
                result = num1 - num2;
                break;
            case '*':
                result = num1 * num2;
                break;
            case '/':
                if (num2 != 0) {
                    result = num1 / num2;
                } else {
                    System.out.println("Error: Division by zero is not allowed.");
                    return;
                }
                break;
            default:
                System.out.println("Error: Invalid operator.");
                return;
        }

        System.out.println("Result: " + result);
    }
}

Output

Enter first number: 50
Enter an operator (+, -, *, /): +
Enter second number: 30
Result: 80.0

Explanation

This example showcases a simple calculator program in Java using switch-case statements.

It starts by obtaining user input for two numbers and an operator (+, -, , /). Then, it employs a switch-case statement to determine the appropriate operation based on the operator entered.

If the operator is '+', it performs addition; if '-', subtraction; if '', multiplication; and if '/', division.

The program also checks for division by zero and handles invalid operators.

Finally, it displays the result of the calculation.

Simple Calculator Program in Java Using Methods

Here is a how to make a calculator in Java using methods or functions:

Code

import java.util.Scanner;

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

        System.out.print("Enter first number: ");
        num1 = input.nextDouble();

        System.out.print("Enter an operator (+, -, *, /): ");
        operator = input.next().charAt(0);

        System.out.print("Enter second number: ");
        num2 = input.nextDouble();

        double result = calculate(num1, num2, operator);

        if (result == Double.MAX_VALUE) {
            System.out.println("Error: Invalid operator or division by zero.");
        } else {
            System.out.println("Result: " + result);
        }
    }

    public static double calculate(double num1, double num2, char operator) {
        switch (operator) {
            case '+':
                return num1 + num2;
            case '-':
                return num1 - num2;
            case '*':
                return num1 * num2;
            case '/':
                if (num2 != 0) {
                    return num1 / num2;
                } else {
                    return Double.MAX_VALUE; // Indicate division by zero or invalid operator.
                }
            default:
                return Double.MAX_VALUE; // Indicate invalid operator.
        }
    }
}

Output

Enter first number: 25
Enter an operator (+, -, *, /): /
Enter second number: 5
Result: 5.0

Explanation

In this example, we implement a Simple Calculator Program in Java using functions or methods for code modularity and readability.

The main method is responsible for taking user input for two numbers and an operator. It then calls a separate method named calculate to perform the actual calculation.

The calculate method uses a switch-case statement to determine the appropriate operation based on the operator provided.

It also checks for division by zero and handles invalid operators by returning a special value (Double.MAX_VALUE) to indicate errors.

The main method checks the result returned by the calculate method.

If the result is Double.MAX_VALUE, it indicates an error (either division by zero or an invalid operator), and an error message is displayed. Otherwise, it displays the calculated result.

Java Calculator Program Using OOPs

Here is a program on how to make a simple calculator in Java using Object-oriented programming concepts:

Code

import java.util.Scanner;

public class SimpleCalculator {
    public static void main(String[] args) {
        Scanner input = new Scanner(System.in);

        System.out.print("Enter first number: ");
        double num1 = input.nextDouble();

        System.out.print("Enter an operator (+, -, *, /): ");
        char operator = input.next().charAt(0);

        System.out.print("Enter second number: ");
        double num2 = input.nextDouble();

        Calculator calculator = new Calculator(num1, num2, operator);
        double result = calculator.calculate();

        if (Double.isNaN(result)) {
            System.out.println("Error: Invalid operator or division by zero.");
        } else {
            System.out.println("Result: " + result);
        }
    }
}

class Calculator {
    private double num1;
    private double num2;
    private char operator;

    public Calculator(double num1, double num2, char operator) {
        this.num1 = num1;
        this.num2 = num2;
        this.operator = operator;
    }

    public double calculate() {
        switch (operator) {
            case '+':
                return num1 + num2;
            case '-':
                return num1 - num2;
            case '*':
                return num1 * num2;
            case '/':
                if (num2 != 0) {
                    return num1 / num2;
                } else {
                    return Double.NaN; // Indicate division by zero or invalid operator.
                }
            default:
                return Double.NaN; // Indicate invalid operator.
        }
    }
}

Output

Enter first number: 100
Enter an operator (+, -, *, /): *
Enter second number: 32
Result: 3200.0

Explanation

In this example, we create a Simple Calculator Program in Java using OOPs concepts. We define a Calculator class to encapsulate the calculator's behavior.

The Calculator class has private instance variables for the two numbers (num1 and num2) and the operator. Its constructor takes these values as parameters, initializing the object's state.

The calculate method in the Calculator class performs the actual calculation based on the operator using a switch-case statement.

It handles addition, subtraction, multiplication, and division while checking for division by zero and invalid operators. If an error occurs, it returns Double.NaN (Not-a-Number) to indicate an error.

In the main method, we instantiate a Calculator object with user-provided values and call the calculate method to perform the calculation.

If the result is Double.NaN, it indicates an error (division by zero or an invalid operator), and an error message is displayed. Otherwise, it displays the calculated result.

Calculator Program in Java Using Swing

Creating a Simple Calculator Program in Java using Swing involves building a graphical user interface (GUI) for the calculator. Here's an example along with the output and a brief explanation:

Code

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

public class SimpleCalculatorSwing {
    public static void main(String[] args) {
        SwingUtilities.invokeLater(() -> {
            JFrame frame = new CalculatorFrame();
            frame.setTitle("Simple Calculator");
            frame.setDefaultCloseOperation(JFrame.EXIT_ON_CLOSE);
            frame.setVisible(true);
        });
    }
}

class CalculatorFrame extends JFrame {
    private JTextField display;

    private double firstOperand;
    private String operator;
    private boolean startNewInput = true;

    public CalculatorFrame() {
        display = new JTextField();
        display.setEditable(false);
        display.setHorizontalAlignment(JTextField.RIGHT);
        display.setFont(new Font("Arial", Font.PLAIN, 20));

        JPanel buttonPanel = new JPanel();
        buttonPanel.setLayout(new GridLayout(4, 4, 10, 10));

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

        for (String label : buttonLabels) {
            JButton button = new JButton(label);
            button.setFont(new Font("Arial", Font.PLAIN, 20));
            button.addActionListener(new ButtonClickListener());
            buttonPanel.add(button);
        }

        setLayout(new BorderLayout());
        add(display, BorderLayout.NORTH);
        add(buttonPanel, BorderLayout.CENTER);
    }

    private class ButtonClickListener implements ActionListener {
        public void actionPerformed(ActionEvent event) {
            String command = event.getActionCommand();

            if (Character.isDigit(command.charAt(0))) {
                if (startNewInput) {
                    display.setText(command);
                    startNewInput = false;
                } else {
                    display.setText(display.getText() + command);
                }
            } else if (command.equals(".")) {
                if (startNewInput) {
                    display.setText("0.");
                    startNewInput = false;
                } else if (display.getText().indexOf('.') == -1) {
                    display.setText(display.getText() + ".");
                }
            } else if (command.equals("=")) {
                if (!startNewInput) {
                    double secondOperand = Double.parseDouble(display.getText());
                    double result = performOperation(firstOperand, secondOperand, operator);
                    display.setText(String.valueOf(result));
                    startNewInput = true;
                }
            } else {
                if (!startNewInput) {
                    firstOperand = Double.parseDouble(display.getText());
                    operator = command;
                    startNewInput = true;
                }
            }
        }

        private double performOperation(double num1, double num2, String op) {
            switch (op) {
                case "+":
                    return num1 + num2;
                case "-":
                    return num1 - num2;
                case "*":
                    return num1 * num2;
                case "/":
                    if (num2 != 0) {
                        return num1 / num2;
                    } else {
                        JOptionPane.showMessageDialog(null, "Error: Division by zero.", "Error", JOptionPane.ERROR_MESSAGE);
                        return 0;
                    }
                default:
                    return 0;
            }
        }
    }
}

Output

A graphical calculator interface will appear with buttons for digits, operators, and an input display. You can enter arithmetic expressions, perform calculations, and view the results on the display.

Explanation

This Java program creates a simple calculator using the Swing GUI library. It includes a CalculatorFrame class that extends JFrame to define the calculator's graphical interface. The calculator supports addition, subtraction, multiplication, and division operations.

Key components and features of the program include:

JTextField for Display: The display area at the top of the frame is implemented using a JTextField that is set to be non-editable and right-aligned.
Button Layout: The calculator buttons are organized in a 4x4 grid using a GridLayout.
Button Labels: An array of button labels (digits, operators, and "=") is used to create the buttons dynamically.
Action Listeners: Each button is associated with an action listener (ButtonClickListener) that handles button clicks.

User input is processed as follows:

Digits and the decimal point are appended to the display.
Operators are applied when the user selects them. The first operand and operator are stored.
When the "=" button is clicked, the second operand is read, and the operation is performed.
The performOperation method performs the arithmetic operations based on the selected operator.

Error Handling:

Division by zero is checked, and an error message is displayed using JOptionPane if needed.

Learn Next:

Popular Courses

Popular Courses

Popular Courses

Popular Courses

Popular Courses

Examples

Simple Calculator Program in Java (Code, switch, methods, swing)

Program for Calculator in Java Using if else

Code

Output

Explanation

Simple Calculator Using Switch Case in Java

Code

Output

Explanation

Simple Calculator Program in Java Using Methods

Code

Output

Explanation

Java Calculator Program Using OOPs

Code

Output

Explanation

Calculator Program in Java Using Swing

Code

Output

Explanation