Una Sencilla Calculadora en Java: Código Fuente

Codigos

Java es un lenguaje de programación muy popular, pero tiene una sintaxis bastante complicada, lo que dificulta los inicios de los principiantes. En este tutorial, construiremos una calculadora sencilla en Java demostrando los fundamentos de este lenguaje de programación. El resultado debería ser un programa Java que pueda mostrar una calculadora sencilla.

Calculadora Java con GUI

Aquí está el código para una calculadora simple en Java. La calculadora utiliza la biblioteca gráfica Swing y permite realizar operaciones aritméticas sencillas.

import javax.swing.*;
import java.awt.*;
import java.awt.event.ActionEvent;
import java.awt.event.ActionListener;
import java.math.BigDecimal;
public class GUICalculator {
    public static void main(String[] args) {
        EventQueue.invokeLater(new Runnable() {
            public void run() {
                CalculatorFrame frame = new CalculatorFrame();
                frame.setDefaultCloseOperation(JFrame.EXIT_ON_CLOSE);
                frame.setVisible(true);
            }
        });
    }
}
class CalculatorFrame extends JFrame {
    public CalculatorFrame() {
        setTitle("Calculadora javadesdecero.es");
        CalculatorPanel panel = new CalculatorPanel();
        add(panel);
        pack();
        int width = 350;
        int height = 350;
        GraphicsDevice gd = GraphicsEnvironment.getLocalGraphicsEnvironment().getDefaultScreenDevice();
        int screenWidth = gd.getDisplayMode().getWidth();
        int screenHeight = gd.getDisplayMode().getHeight();
        setBounds(screenWidth / 2 - width / 2, screenHeight / 2 - height / 2, width, height);
    }
}
class CalculatorPanel extends JPanel {
    private JButton display;
    private JPanel panel;
    private BigDecimal result;
    private String lastCommand;
    private boolean start;
    public CalculatorPanel() {
        setLayout(new BorderLayout());
        result = BigDecimal.ZERO;
        lastCommand = "=";
        start = true;
        display = new JButton("0");
        display.setEnabled(false);
        display.setFont(display.getFont().deriveFont(50f));
        add(display, BorderLayout.NORTH);
        ActionListener insert = new InsertAction();
        ActionListener command = new CommandAction();
        panel = new JPanel();
        panel.setLayout(new GridLayout(4, 4));
        addButton("7", insert);
        addButton("8", insert);
        addButton("9", insert);
        addButton("/", command);
        addButton("4", insert);
        addButton("5", insert);
        addButton("6", insert);
        addButton("*", command);
        addButton("1", insert);
        addButton("2", insert);
        addButton("3", insert);
        addButton("-", command);
        addButton("0", insert);
        addButton(".", insert);
        addButton("=", command);
        addButton("+", command);
        add(panel, BorderLayout.CENTER);
    }
    private void addButton(String label, ActionListener listener) {
        JButton button = new JButton(label);
        button.setFont(button.getFont().deriveFont(20f));
        button.addActionListener(listener);
        panel.add(button);
    }
    private class InsertAction implements ActionListener {
        public void actionPerformed(ActionEvent event) {
            String input = event.getActionCommand();
            if (start) {
                display.setText("");
                start = false;
            }
            display.setText(display.getText() + input);
        }
    }
    private class CommandAction implements ActionListener {
        public void actionPerformed(ActionEvent event) {
            String command = event.getActionCommand();
            if (start) {
                if (command.equals("-")) {
                    display.setText(command);
                    start = false;
                } else lastCommand = command;
            } else {
                calculate(new BigDecimal(display.getText()));
                lastCommand = command;
                start = true;
            }
        }
    }
    public void calculate(BigDecimal x) {
        if (lastCommand.equals("+")) result = result.add(x);
        else if (lastCommand.equals("-")) result = result.subtract(x);
        else if (lastCommand.equals("*")) result = result.multiply(x);
        else if (lastCommand.equals("/")) result = result.divide(x);
        else if (lastCommand.equals("=")) result = x;
        if (result.compareTo(BigDecimal.ZERO) == 0) {
            result = BigDecimal.ZERO;
        }
        display.setText(result.toString());
    }
}
Ejemplo de Calculadora en Java con Interfaz gráfica
Ejemplo de Calculadora en Java con Interfaz gráfica

En resumen, la calculadora sólo tiene 16 botones y 4 operaciones, es decir, suma, resta, división y multiplicación. El código es corto y legible. Por lo tanto, se podría utilizar como ejemplo para explicar un curso elemental de Java, o para mostrar cómo escribir una calculadora GUI en Java.

Ahora pongámoslo más sencillo de explicar.

Ejercicio Calculadora Java

Condición de la tarea:

Tienes que escribir una simple calculadora de consola en Java con los siguientes requisitos de uso:

  • Método int getInt() – debe leer un entero de la consola y devolverlo
  • Método char getOperation() – debe leer algún valor de la consola y devolver el carácter con la operación (+, -, * o /)
  • Método int calc(int num1, int num2, char) – debe realizar sobre los números num1 y num2 una operación aritmética, dada por operación.
  • Método main() – debe leer 2 números (usando getInt()), leer la operación (usando getOperation()), pasar todo al método calc() y mostrar el resultado.

Solución:

import java.util.Scanner;
public class Calculadora {
    static Scanner scanner = new Scanner(System.in);
    public static void main(String[] args) {
        int num1 = getInt();
        int num2 = getInt();
        char operation = getOperation();
        int result = calc(num1,num2,operation);
        System.out.println("El resultado de la operación: "+result);
    }
    public static int getInt(){
        System.out.println("Introduzca un número:");
        int num;
        if(scanner.hasNextInt()){
            num = scanner.nextInt();
        } else {
            System.out.println("Te has equivocado al introducir el número. Inténtalo de nuevo.");
            scanner.next();//recursividad
            num = getInt();
        }
        return num;
    }
    public static char getOperation(){
        System.out.println("Introduzca la operación:");
        char operation;
        if(scanner.hasNext()){
            operation = scanner.next().charAt(0);
        } else {
            System.out.println("Ha cometido un error al entrar en la operación. Inténtalo de nuevo.");
            scanner.next();//recursividad
            operation = getOperation();
        }
        return operation;
    }
    public static int calc(int num1, int num2, char operation){
        int result;
        switch (operation){
            case '+':
                result = num1+num2;
                break;
            case '-':
                result = num1-num2;
                break;
            case '*':
                result = num1*num2;
                break;
            case '/':
                result = num1/num2;
                break;
            default:
                System.out.println("La operación no se reconoce. Repite la entrada.");
                result = calc(num1, num2, getOperation());//recursividad
        }
        return result;
    }
}
Calculadora en Java desde la consola
Calculadora en Java desde la consola

Explicación sobre la tarea

Antes de resolver este problema, hay que dividirlo en subtareas. Como puedes ver en la imagen de abajo, hay 3 pasos básicos en total:

Pasos de la tarea calculadora en Java
Pasos de la tarea calculadora en Java
public static int getInt(){
        System.out.println("Introduzca un número:");
        int num;
        if(scanner.hasNextInt()){
            num = scanner.nextInt();
        } else {
            System.out.println("Te has equivocado al introducir el número. Inténtalo de nuevo.");
            scanner.next();//recursividad
            num = getInt();
        }
        return num;
    }

Y luego simplemente llamar al método int getInt() 2 veces en el método main(), porque el usuario introducirá 2 números.

Observa que utilizamos una construcción if-else para especificar que si el número es un entero, entonces asigna el valor introducido por el usuario a la variable num, y si no es un entero, entonces imprima en la consola “Te has equivocado al introducir el número. Inténtalo de nuevo.“.

También hay que tener en cuenta que hemos utilizado la recursividad en ‘else’:

else {
            System.out.println("Te has equivocado al introducir el número. Inténtalo de nuevo.");
            scanner.next();//recursividad
            num = getInt();
        }

Seleccionamos la operación (+,-,*,/) mediante el método char getOperation()

public static char getOperation(){
        System.out.println("Introduzca la operación:");
        char operation;
        if(scanner.hasNext()){
            operation = scanner.next().charAt(0);
        } else {
            System.out.println("Ha cometido un error al entrar en la operación. Inténtalo de nuevo.");
            scanner.next();//recursividad
            operation = getOperation();
        }
        return operation;
    }

Como puedes ver, se pide al usuario que introduzca una operación. A continuación, el programa debe reconocer si el usuario ha introducido un valor char o no. Sólo nos satisface si el usuario introduce: +, – , * o /. Por ejemplo, si el usuario introduce un número, no estamos satisfechos. ¿Verdad? Así que hemos aplicado un pequeño “truco” aquí en estas 2 líneas de código:

if(scanner.hasNext()){
            operation = scanner.next().charAt(0);

Utilizamos el método next() de scanner para leer toda la cadena. Y luego, como no necesitamos toda la cadena, sino sólo el primer elemento de la cadena, es decir, el elemento cero, entonces también llamamos al método charAt(0). Y de esta manera, sólo obtendremos el valor del elemento 0-ésimo, no toda la cadena.

En caso de que no recuerde cómo funcionan los métodos de scanner, eche un vistazo a este artículo, “Scanner en Java“.

Y luego escribimos el método int calc(int num1, int num2, int operación):

public static int calc(int num1, int num2, char operation){
        int result;
        switch (operation){
            case '+':
                result = num1+num2;
                break;
            case '-':
                result = num1-num2;
                break;
            case '*':
                result = num1*num2;
                break;
            case '/':
                result = num1/num2;
                break;
            default:
                System.out.println("La operación no se reconoce. Repite la entrada.");
                result = calc(num1, num2, getOperation());//recursividad
        }
        return result;
    }

Como puedes ver, hemos utilizado una construcción de tipo switch-case. Y lo escribimos:

  • si el usuario introdujo +, entonces num1+num2, es decir, sumamos 2 números introducidos por el usuario.
  • si el usuario introdujo -, entonces num1-num2, es decir, restamos el 2º número del 1º número introducido por el usuario
  • y así sucesivamente.

Si necesitas recordar cómo funcionan las construcciones switch-case, echa un vistazo a este artículo “switch en Java“.

Obsérvese también que aquí hemos utilizado la recursividad. En estas líneas de código:

default:
                System.out.println("La operación no se reconoce. Repite la entrada.");
                result = calc(num1, num2, getOperation());//recursividad

Y después de prescribir todos los métodos necesarios, escribimos lo siguiente en el método main():

public static void main(String[] args) {
        int num1 = getInt();
        int num2 = getInt();
        char operation = getOperation();
        int result = calc(num1,num2,operation);
        System.out.println("El resultado de la operación: "+result);
    }
  • Es decir, num1 y num2 serán asignados a los números 1 y 2 introducidos por el usuario, respectivamente.
  • La variable operación contendrá la operación introducida por el usuario: +, – , * o /.
  • A continuación, el resultado del cálculo de “nuestra calculadora” se asignará a la variable de resultado (result)
  • Y entonces el resultado se mostrará en la consola

En resumen, este artículo pretendía ofrecer una calculadora Java sencilla para principiantes. Una calculadora puede ser muy útil para mostrar cómo unos pocos operadores pueden hacer un programa con mucha utilidad. La calculadora es una buena candidata para que los estudiantes practiquen la programación, y para que se diviertan creando una herramienta real que mucha gente pueda utilizar.

Sobre el Autor:

Hey hola! Yo soy Alex Walton y tengo el placer de compartir conocimientos hacía ti sobre el tema de Programación en Java, desde cero, Online y Gratis.

1 comentario

  1. Jesús

    Alguien ya ha podido adaptar el botón de borrar aún no encuentro como

Deja una Respuesta

*

Este sitio usa Akismet para reducir el spam. Aprende cómo se procesan los datos de tus comentarios.