Calculator Program in Java

Calculator Program in Java

A calculator performs the basic mathematical operations such as addition, subtraction, multiplication, etc. In this section, we will create a calculator program in Java using switch case and Java swing.

Let’s start with the switch case.

Using Switch Case

Filename: BasicCalculatorExample.java

import java.util.*;
public class BasicCalculatorExample
{             
   public static void main(String[] args)
   {
      double a; //will store the first operand
      double b;//will store the second operand
      double result;//will store the final outcome
      char operator;// will store the operator acting upon the above two operands
      Scanner rdr = new Scanner(System.in);//taking user input
      System.out.print("Enter two numbers: \n");
      a = rdr.nextDouble(); //assigning first operand
      b = rdr.nextDouble(); //assigning second operand
      System.out.print("\n Enter one of the mentioned operators (+, -, *, /): \n");
      operator = rdr.next().charAt(0);//assigning operator
      switch(operator) {
         case '+': result = a + b;
            break;
         case '-': result = a - b;
            break;
         case '*': result = a * b;
            break;
         case '/': result = a / b;
            break;
      default: System.out.print("Please enter one of the mentioned operators.");
         return;
      }
      System.out.print("\nThe result is given as follows:\n");
      System.out.printf(a + " " + operator + " " + b + " = " + result);//printing the result
   }
}

Output:

Enter two numbers:
2
3
Enter one of the mentioned operators (+, -, *, /):
-
The result is given as follows:
2.0 - 3.0 = -1.0

Explanation: The working of the code is quite straight-forward. We are taking input from the user to get the values of both the operands and the operator, respectively. Then, we are doing the operation, on both the operands, on the basis of the operator provided by the user. Finally, we are printing the final outcome.

Now, let’s observe the following code, which uses Java-Swing to implement a basic calculator.

Using Java Swing

Filename: BasicCalculatorExample1.java

import java.awt.*;
import java.awt.event.*;
import javax.swing.*;
public class BasicCalculatorExample1 implements ActionListener
{
               private static JTextField inBox;// inBox will be used to display the result
               BasicCalculatorExample1(){}
               public static void main(String[] args)
               {
                                makeWindow();
               }
               private static void makeWindow()
               {         
                               //Setting name of the frame
                               JFrame fr = new JFrame("Basic Calculator");
                               //For closing Jframes
                               fr.setDefaultCloseOperation(JFrame.EXIT_ON_CLOSE);
                               createUI(fr);
                               fr.setSize(200, 200);  //setting frame size         
                               fr.setLocationRelativeTo(null);//for centering the window
                               fr.setVisible(true);//making the frame visible
}
private static void createUI(JFrame fr)
{
               JPanel pnl = new JPanel(); //creating object of JPanel
               BasicCalculatorExample1 basicCalculator = new BasicCalculatorExample1();
               //GridBagLayout is responsible for placing components in grid of columns and //rows
               GridBagLayout layout = new GridBagLayout(); //creating GridBagLayout object
               //Specifics constraints for components       
               GridBagConstraints gbc = new GridBagConstraints(); //creating               //GridBagConstraintsobject
               pnl.setLayout(layout);
               inBox = new JTextField(10); // Creating a text field. Also, setting default             //columns to 10  
               inBox.setEditable(false); // The text field is not editable
               //Creating buttons and putting appropriate labels on it
               JButton btn0 = new JButton("0");
               JButton btn1 = new JButton("1");
               JButton btn2 = new JButton("2");
               JButton btn3 = new JButton("3");
               JButton btn4 = new JButton("4");
               JButton btn5 = new JButton("5");
               JButton btn6 = new JButton("6");
               JButton btn7 = new JButton("7");
               JButton btn8 = new JButton("8");
               JButton btn9 = new JButton("9");
               JButton btnPlus = new JButton("+");
               JButton btnMinus = new JButton("-");
               JButton btnDivide = new JButton("/");
               JButton btnMultiply = new JButton("*");
               JButton btnClear = new JButton("C");
               JButton btnDot = new JButton(".");
               JButton btnEquals = new JButton("=");
               //Adding listeners to the above-created buttons
               btn1.addActionListener(basicCalculator);
               btn2.addActionListener(basicCalculator);
               btn3.addActionListener(basicCalculator);
               btn4.addActionListener(basicCalculator);
               btn5.addActionListener(basicCalculator);
               btn6.addActionListener(basicCalculator);
               btn7.addActionListener(basicCalculator);
               btn8.addActionListener(basicCalculator);
               btn9.addActionListener(basicCalculator);
               btn0.addActionListener(basicCalculator);
                btnPlus.addActionListener(basicCalculator);
               btnMinus.addActionListener(basicCalculator);
               btnDivide.addActionListener(basicCalculator);
               btnMultiply.addActionListener(basicCalculator);
               btnClear.addActionListener(basicCalculator);
               btnDot.addActionListener(basicCalculator);
               btnEquals.addActionListener(basicCalculator);
               gbc.fill = GridBagConstraints.HORIZONTAL; // Specifying constraint horizontal
               //Assigning the positioning of different buttons and adding them to the panel
               gbc.gridx = 0;       gbc.gridy = 0;       pnl.add(btn1, gbc);       
               gbc.gridx = 1;       gbc.gridy = 0;       pnl.add(btn2, gbc);
               gbc.gridx = 2;       gbc.gridy = 0;       pnl.add(btn3, gbc);
               gbc.gridx = 3;       gbc.gridy = 0;       pnl.add(btnPlus, gbc);
               gbc.gridx = 0;       gbc.gridy = 1;       pnl.add(btn4, gbc);
               gbc.gridx = 1;       gbc.gridy = 1;       pnl.add(btn5, gbc);
               gbc.gridx = 2;       gbc.gridy = 1;       pnl.add(btn6, gbc);
               gbc.gridx = 3;       gbc.gridy = 1;       pnl.add(btnMinus, gbc);
               gbc.gridx = 0;       gbc.gridy = 2;       pnl.add(btn7, gbc);
               gbc.gridx = 1;       gbc.gridy = 2;       pnl.add(btn8, gbc);
               gbc.gridx = 2;       gbc.gridy = 2;       pnl.add(btn9, gbc);
               gbc.gridx = 3;       gbc.gridy = 2;       pnl.add(btnDivide, gbc);
               gbc.gridx = 0;       gbc.gridy = 3;       pnl.add(btnDot, gbc);
               gbc.gridx = 1;       gbc.gridy = 3;       pnl.add(btn0, gbc);
               gbc.gridx = 2;       gbc.gridy = 3;       pnl.add(btnClear, gbc);
               gbc.gridx = 3;       gbc.gridy = 3;       pnl.add(btnMultiply, gbc);
               gbc.gridwidth = 3; //Now, the component width will span to 3 columns
               gbc.gridx = 0;       gbc.gridy = 4;       pnl.add(inBox, gbc); //Notice the width of   //text field in the output 
               gbc.gridx = 3;       gbc.gridy = 4;       pnl.add(btnEquals, gbc);
               //Adding the panel to the frame and positioning it to center. Options like North,           
               //West, South, East can also be tried instead of center.
               fr.getContentPane().add(pnl, BorderLayout.CENTER);       
   }
//This method displays text in the text field on the basis of the button pressed.
//It also invokes the evaluate method.
public void actionPerformed(ActionEvent e)
{
               String cmd = e.getActionCommand();
               if (cmd.charAt(0) == 'C')
               {                     
                              inBox.setText("");
               }
               else if (cmd.charAt(0) == '=')
               {                   
                              inBox.setText(evaluate(inBox.getText()));
               }
               else
               {                               
                              inBox.setText(inBox.getText() + cmd);
               }
}
//This method takes the expression in its argument and filters out the two operands and //the operator. Then, it does the calculation on the basis of the operator and returns the //result.
public static String evaluate(String exp)
{
               char[] arr = exp.toCharArray();
               String a = ""; String b = ""; String op = "";
               double ans = 0;
               for (int i = 0; i < arr.length; i++)
               {
                               if (arr[i] >= '0' && arr[i] <= '9' || arr[i] == '.')
                               {
                                              if(op.isEmpty())
                                              {
                                                             a += arr[i];
                                              }
                                              else
                                              {
                                                             b += arr[i];
                                              }
                               } 
                               if(arr[i] == '+' || arr[i] == '-' || arr[i] == '/' || arr[i] == '*')
                               {
                                              op += arr[i];
                               }
               }
               if (op.equals("+"))
                               ans = (Double.parseDouble(a) + Double.parseDouble(b));
               else if (op.equals("-"))
                               ans = (Double.parseDouble(a) - Double.parseDouble(b));
               else if (op.equals("/"))
                               ans = (Double.parseDouble(a) / Double.parseDouble(b));
               else
                               ans = (Double.parseDouble(a) * Double.parseDouble(b));   
               return a + op + b + "=" + ans;
} 
}

Output:

Explanation: First, we are creating a JFrame namely Basic Calculator. Then, we are adding a panel to the frame. Alignment of the panel is center which is achieved by BorderLayout.Center. The panel contains all the buttons and the text fields. In the output, we can see the buttons are aligned horizontally. This is due to GridBagConstraints.HORIZONTAL.

GridBagConstraints also contains fields gridx and gridy which helps in the positioning of the buttons. For button 1, gridx = 0 and gridy = 0. That is why button 1 is taking the top-left position. For button =, gridx = 4 and gridy = 4. Therefore, it is taking the bottom-right position. All these buttons are filled in a grid of rows and columns. The field gridx handles the rows and gridy handles the columns. In the code, we are overriding actionPerformed() method. The method gets invoked when we press any button and also responsible for doing the calculation and rendering the output in the text field.