Simple Calculator Program in Java Without Scanner

Introduction

A calculator program is a fundamental programming exercise that helps beginners understand basic input/output operations, arithmetic operations, and control structures in Java. While the Scanner class is commonly used for user input, there are alternative methods to create a calculator without it.

In this guide, we'll explore three approaches to building a simple calculator in Java:

1. Using command line arguments
2. Creating a basic console application with input validation
3. Building a simple GUI version (optional)

Each approach has its own advantages and is suitable for different learning scenarios. The command line method is particularly useful for understanding how Java processes command line arguments, while the GUI version introduces basic concepts of graphical user interfaces.

Basic Calculator Program

The most straightforward approach is to create a console-based calculator that takes input from command line arguments. Here's a complete example:

public class SimpleCalculator {
    public static void main(String[] args) {
        if (args.length != 3) {
            System.out.println("Usage: java SimpleCalculator <num1> <operator> <num2>");
            System.out.println("Operators: +, -, *, /");
            return;
        }

        try {
            double num1 = Double.parseDouble(args[0]);
            double num2 = Double.parseDouble(args[2]);
            char operator = args[1].charAt(0);
            double result = 0;

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

            System.out.printf("Result: %.2f %c %.2f = %.2f%n", num1, operator, num2, result);
        } catch (NumberFormatException e) {
            System.out.println("Error: Invalid number format");
        }
    }
}

How to Use This Calculator

To use this calculator, compile the code and run it from the command line with three arguments:

1. The first number
2. The operator (+, -, *, /)
3. The second number

Example: java SimpleCalculator 5 * 3

Key Features

• Handles basic arithmetic operations
• Validates input format
• Checks for division by zero
• Provides clear error messages

Using Command Line Arguments

Command line arguments provide a simple way to pass input to a Java program without using the Scanner class. The main method receives these arguments as an array of strings.

Advantages of Command Line Arguments

• No need for user interaction during execution
• Easy to automate and integrate into scripts
• Good for learning basic Java program structure

Disadvantages

• Less user-friendly than interactive input
• Requires recompilation for different inputs
• Limited to simple input scenarios

GUI Version (Optional)

For a more user-friendly experience, you can create a simple GUI calculator using Java's Swing library. Here's a basic example:

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

public class GUICalculator {
    public static void main(String[] args) {
        JFrame frame = new JFrame("Simple Calculator");
        frame.setDefaultCloseOperation(JFrame.EXIT_ON_CLOSE);
        frame.setSize(300, 400);
        frame.setLayout(new BorderLayout());

        JTextField display = new JTextField();
        display.setEditable(false);
        display.setHorizontalAlignment(JTextField.RIGHT);
        display.setFont(new Font("Arial", Font.PLAIN, 24));
        frame.add(display, BorderLayout.NORTH);

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

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

        for (String text : buttons) {
            JButton button = new JButton(text);
            button.addActionListener(new ActionListener() {
                public void actionPerformed(ActionEvent e) {
                    String command = e.getActionCommand();
                    if (command.charAt(0) >= '0' && command.charAt(0) <= '9') {
                        display.setText(display.getText() + command);
                    } else if (command.equals("C")) {
                        display.setText("");
                    } else if (command.equals("=")) {
                        try {
                            String expression = display.getText();
                            double result = evaluateExpression(expression);
                            display.setText(String.valueOf(result));
                        } catch (Exception ex) {
                            display.setText("Error");
                        }
                    } else {
                        display.setText(display.getText() + " " + command + " ");
                    }
                }
            });
            buttonPanel.add(button);
        }

        frame.add(buttonPanel, BorderLayout.CENTER);
        frame.setVisible(true);
    }

    private static double evaluateExpression(String expression) {
        String[] tokens = expression.split(" ");
        double result = Double.parseDouble(tokens[0]);

        for (int i = 1; i < tokens.length; i += 2) {
            String operator = tokens[i];
            double operand = Double.parseDouble(tokens[i+1]);

            switch (operator) {
                case "+":
                    result += operand;
                    break;
                case "-":
                    result -= operand;
                    break;
                case "*":
                    result *= operand;
                    break;
                case "/":
                    if (operand == 0) throw new ArithmeticException("Division by zero");
                    result /= operand;
                    break;
            }
        }

        return result;
    }
}

Features of the GUI Version

• Interactive button interface
• Clear display for input and results
• Basic error handling
• Simple expression evaluation