Código de Java - Calculadora Básica

Imágen de perfil

Calculadora Básicagráfica de visualizaciones


Java

estrellaestrellaestrellaestrellaestrella(2)
Publicado el 06 de Octubre del 2017 por Omar
14.762 visualizaciones desde el 06 de Octubre del 2017. Una media de 280 por semana
El programa es una calculadora muy sencilla el cual colocas dos números y puedes elegir la operación a realizar, que son:
Sumar
Restar
Multiplicar
Dividir
Elevar al cuadrado
Residuo
Muestra el resultado y el programa finaliza.
El punto clave del programa es que puedes poner en la entrada de datos lo que tu quieras, ya sea una cadena, .30, 34b, -.df3, etc. Y el programa no seguirá hasta que se coloque los datos correctos.

Requerimientos

Requiere tener instalado el JDK 8.

1.0
estrellaestrellaestrellaestrellaestrella(2)

Actualizado el 03 de Enero del 2018 (Publicado el 06 de Octubre del 2017)gráfica de visualizaciones de la versión: 1.0
14.783 visualizaciones desde el 06 de Octubre del 2017. Una media de 280 por semana
estrellaestrellaestrellaestrellaestrella
estrellaestrellaestrellaestrella
estrellaestrellaestrella
estrellaestrella
estrella

Pros
- No hay error al colocar una cadena.
- Es posible poner un signo negativo.
- Acepta decimales.

Contras
- No hay interfaz gráfica.
- No puede calcular números complejos.
- La opción residuo debería ir de lado de la división.
- No esta comentado correctamente.
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
package calculadora;
import java.util.Scanner; // Importación de la clase Scanner.
 
public class TestCalculadora{
  public static void main(String[] args) {
        Scanner sc = new Scanner(System.in);
        double res = 0;
        String operacion;
        boolean comprobar = false;
 
        do{
            //Verificación de los datos puestos por el usuario del número 1.
            /* Con matches, hay una condición de que dígitos primero puede
            poner el usuario, en la condicional tenemos primero que solo se admite los caracteres '+' y '-', pero con la condición de que sea una sola vez o ninguna vez. Después tenemos que se admiten cualquier número del 0 al 9 y que se ponga o 0 veces o más veces, es decir, se pone algo o no se pone nada. Mas otra condición de que solo admite el carácter '.' una o ninguna vez. Seguido del punto, si es que se coloca, se admite cualquier número del 0 al 9 que sea una o más veces.*/
            String numero1;
            do {
                System.out.println("\n Por favor, dame el primer número de la operación. ");
                numero1 = sc.nextLine();
            } while (!numero1.matches("[+-]?[\\d]*[.]?[\\d]+"));
            double nume1 = Double.parseDouble(numero1);
            double n1 = new Double(numero1);
            // Fin de la verificación de los datos puestos por el usuario del número 1.
 
            do {
                System.out.println("\n ¿Que operación desea hacer? (Solo coloque un signo)");
                System.out.println("Teniendo en cuenta que: \n + = sumar \n - = restar \n"
                        + " x = multiplicar \n / = dividir \n * = elevar primer número al segundo numero."
                        + "\n % = residuo");
            operacion = sc.nextLine();
                if (operacion.equals("+") || operacion.equals("-") || operacion.equals("x") ||
                    operacion.equals("X") || operacion.equals("/") || operacion.equals("%") ||
                    operacion.equals("*")) {
                    comprobar = true;
                }else { comprobar = false; }
            } while (comprobar != true);
 
            // Verificación de los datos puestos por el usuario del número 2.
            String numero2;
            do {
                System.out.println("\n Por favor, dame el segundo número.");
                numero2 = sc.nextLine();
            } while (!numero2.matches("[+-]?[\\d]*[.]?[\\d]+"));
            double nume2 = Double.parseDouble(numero2);
            double n2 = new Double(numero2);
            // Fin de la verificación de los datos puestos por el usuario del número 2.
 
            do{
                comprobar = true;
                switch(operacion){
                    case "+":
                        res = n1 + n2;
                        break;
                    case "-":
                        res = n1 - n2;
                        break;
                    case "x":
                    case "X":
                        res = n1 * n2;
                        break;
                    case "/":
                        /* Por tal de evitar errores y añadir números complejos, si el usuario coloca 0 como segundo número, se piensa entonces que el denominador es 0, y por ello añado una condicional que lo verifique, y para hacer el codigo mas dinamico y no solo añadir un 1, le vuelvo a preguntar al usuario que añada un número distinto, podría volver a colocar 0, y es la razón por la que se encuentra en un ciclo, así que mientras n2 sea 0, el código seguirá ejecutando hasta que ponga otro. */
                        while(n2 == 0){
                                 do {
                                    System.err.println(" En el denominador se encuentra \n"
                                            + "un cero, para evitar errores coloca otro número.");
                                    numero2 = sc.nextLine();
                                }while (!numero2.matches("[+-]?[\\d]*[.]?[\\d]+"));
                                    nume2 = Double.parseDouble(numero2);
                                    n2 = new Double(numero2);
                        }
                        res = n1 / n2;
                        break;
                    case "*":
                        res = Math.pow(n1, n2);
                        break;
                    case "%":
                        while(n2 == 0){
                                 do {
                                    System.err.println(" En el denominador se encuentra \n"
                                            + "un cero, para evitar errores coloca otro número.");
                                    numero2 = sc.nextLine();
                                }while (!numero2.matches("[+-]?[\\d]*[.]?[\\d]+"));
                                    nume2 = Double.parseDouble(numero2);
                                    n2 = new Double(numero2);
                        }
                        res = n1 % n2;
                        break;
                }
            }while(comprobar != true);
 
            System.out.println("(" + numero1 + ") " + operacion + " (" + numero2 + ")" + " = " + res);
            System.out.println("\n ¿Desea hacer alguna otra operación? \n");
            System.out.println(" [s/n]");
            do{
                comprobar = true;
                operacion = sc.nextLine();
 
                switch (operacion) {
                    case "s":
                    case "S":
                    case "n":
                    case "N":
                        break;
                    default:
                        System.err.println("\n Error, ponga un literal valido. \n");
                        comprobar = false;
                }
            }while(comprobar != true);
        }while(operacion.equals("s") || operacion.equals("S"));
  }
}



Comentarios sobre la versión: 1.0 (2)

emanuel
18 de Mayo del 2018
estrellaestrellaestrellaestrellaestrella
esta bien estecodigo
Responder
Jose
21 de Julio del 2018
estrellaestrellaestrellaestrellaestrella
Bien estructurado. Gracias
Responder

Comentar la versión: 1.0

Nombre
Correo (no se visualiza en la web)
Valoración
Comentarios
Es necesario revisar y aceptar las políticas de privacidad

http://lwp-l.com/s4241  
Revisar política de publicidad