En este vídeo introductorio, perteneciente a nuestro curso, nuestro tutor Francisco Charte nos muestra la creación de una pequeña calculadora financiera en Java. Aprenderemos a utilizar distintos tipos de datos, operadores y expresiones de Java para construir un sencillo programa que nos va a permitir calcular la cuota de un hipotético préstamo bancario.
Vamos a utilizar para ello el entorno de Netbeans. Una vez lo hemos iniciado creamos un New Project en el menú File para crear una aplicación Java simple, le ponemos un nombre y hacemos clic en finish.
Como siempre, Netbeans crea un esqueleto del código en el cual ya tenemos una clase: CalculaPrestamos, que es como hemos llamado al módulo de código, y en él tenemos ya la función main.
Vamos a dicha función main y empezamos a introducir el código que necesitamos.
Lo primero que vamos a necesitar es un método para solicitar datos por teclado. Para ello, vamos a utilizar un objeto de la clase Scanner. Scanner es una clase que está ya predefinida en la plataforma Java, y que nos permite extraer, de un flujo de datos (un archivo, la consola o cualquier otro), datos de diferentes tipos: cadenas de caracteres, números enteros, en punto flotante, etc…
Vamos a definir una variable de este tipo, y, puesto que Scanner es una clase, tenemos que utilizar el operador new para crear un objeto de la misma. Esta clase necesita como parámetros el flujo de datos de donde vamos a extraer la información, en este caso vamos a usar la entrada estándar, la consola. Este flujo de información está representado por el objeto System.in
Scanner scanner = new Scanner(System.in);
Vemos que el editor de Netbeans subraya esta sentencia que acabamos de escribir para decirnos que hay un error.
Lo que ocurre es que no es capaz de encontrar el símbolo Scanner al que hacemos referencia. Esto es porque Scanner está definido en un paquete que no hemos importado todavía. Si nos fijamos en el inicio del módulo de código veremos que no hay ninguna sentencia import para importar este módulo. Para importarlo automáticamente no tenemos más que utilizar el atajo “Ctrl + Mayúsculas + i” y aparece una ventana que nos propone el paquete desde el cual podemos importar este objeto, lo aceptamos, y se añade automáticamente la sentencia import correspondiente.
Vemos que ahora la declaración de la variable es correcta:
Ahora vamos a solicitar varios datos por teclado y vamos a definir unas variables para almacenar estos datos. Por una parte, vamos a solicitar el importe del préstamo, el tipo de interés y un límite de cuota que podemos permitirnos como el periodo en años en el cual se amortizará.
double importe, tipo, limite;
int periodo;
Hemos utilizado el tipo double para las tres primeras variables porque contendrán una parte decimal, y el tipo int para el período en años, que será un número entero.
El siguiente paso consiste en solicitar cada uno de los datos que necesitamos. Para ello primero vamos a mostrar un mensaje en la consola indicándole al usuario el dato que estamos solicitando a través de la función print del objeto System.out.
La función print funciona igual que println, la única diferencia es que no introduce un avance de línea y retorno de carro al final, esto va a permitir solicitar el dato que nos interesa.
En primer lugar, solicitamos el importe, y el cursor se dispondrá al final del mensaje que acabamos de imprimir. Utilizamos el objeto Scanner que habíamos declarado antes, y, como vemos, este objeto tiene un conjunto de métodos con el prefijo next que nos permiten extraer del flujo de datos distintos tipos de valores numéricos enteros y en punto flotante. En este caso como el valor puede ser un importe con parte decimal, vamos a utilizar el método nextDouble(); .
De manera análoga, procederemos a solicitar el resto de datos:
- Pedimos el tipo de interés y lo almacenamos en la variable
tipo
- A continuación, la amortización en años, que almacenamos en la variable periodo. En este caso hemos utilizado el método
nextInt(); en vez de nextDouble; porque será un valor entero
- Finalmente, solicitamos el tipo de cuota que nos podemos permitir
System.out.print("Introduce el importe del préstamo: ");
importe = scanner.nextDouble();
System.out.print("Introduce el tipo de interés: ");
tipo = scanner.nextDouble();
System.out.print("Introduce el tiempo de amortización (años): ");
periodo = scanner.nextInt();
System.out.print("Introduce el límite que puedes pagar: ");
limite = scanner.nextDouble();
En este momento tenemos todos los datos que necesitamos para realizar el cálculo. Lo primero que vamos a hacer es adaptar alguno de los datos que hemos solicitado por teclado. Por ejemplo, el periodo de amortización en años del préstamo que hemos solicitado lo vamos a convertir a meses, puesto que vamos a calcular una cuota mensual. Para ello cogemos el periodo y simplemente lo multiplicamos por 12. Aquí estamos utilizando el operador abreviado *=.
periodo *= 12; // Convertir el tiempo a meses
Esta expresión:
periodo *= 12;
Sería idéntica a escribir:
periodo = periodo * 12;
Puesto que el operando en el cual se va a almacenar el resultado actúa también como primer operando de la expresión, nos lo podemos ahorrar utilizando el operador abreviado al calcular el periodo de amortización en meses.
A continuación, vamos a convertir también el tipo:
tipo = tipo / 1200;
Para calcular el tipo mensual lo dividimos entre 12 y entre 100.
De manera similar definimos las variables que necesitamos para realizar el resto del cálculo:
double numerador = tipo * Math.pow(1 + tipo, periodo);
double denominador = Math.pow(1 + tipo, periodo) - 1;
double cuota = importe * (numerador / denominador);
En la primera línea calculamos un numerador y a continuación un denominador con el interés compuesto. Puesto que, para calcular el interés compuesto tenemos que elevar el tipo al nº de plazos que hay en el periodo, utilizamos la función pov. Esta función está contenida en el paquete Math (donde hay muchas otras funciones matemáticas) y toma como parámetros dos números en punto flotante, de los cuales, usa el primero como base y el segundo como exponente. Lo mismo hacemos para calcular el denominador y finalmente calculamos la cuota.
Fíjate que, en este caso, primero queremos dividir numerador entre denominador y, finalmente, multiplicar por el importe, por eso hemos utilizado unos paréntesis para alterar el orden de evaluación habitual de izquierda a derecha.
Con esto tenemos calculada la cuota, así que podemos proceder a mostrar por la consola el resultado del cálculo. Por una parte, vamos a proceder a mostrar la cuota mensual que tenemos almacenada en la variable cuota y, por otra parte, queremos informar al usuario de si, esta cuota que hemos calculado excede o no el máximo que puede permitirse pagar mensualmente.
System.out.println(
"\nLa cuota mensual será de " + cuota +
"\n¿La cuota supera tu límite? -> " + (cuota > limite));
Introducimos una indicación, una cadena de caracteres y, a continuación, vamos a utilizar una expresión relacional, vamos a calcular si la cuota que hemos calculado es superior al límite que habíamos solicitado previamente por teclado y que tenemos almacenado en una variable.
Esta expresión racional se va a evaluar y va a producir un valor de tipo booleano (true o false) que será lo que se va a mostrar tras el mensaje ¿La cuota supera el límite?.
Al final quedaría así:
import java.util.Scanner;
public class Prestamos {
public static void main(String[] args) {
Scanner scanner = new Scanner(System.in);
double importe, tipo, limite;
int periodo;
System.out.print("Introduce el importe del préstamo: ");
importe = scanner.nextDouble();
System.out.print("Introduce el tipo de interés: ");
tipo = scanner.nextDouble();
System.out.print("Introduce el tiempo de amortización (años): ");
periodo = scanner.nextInt();
System.out.print("Introduce el límite que puedes pagar: ");
limite = scanner.nextDouble();
periodo *= 12; // Convertir el tiempo a meses
tipo = tipo / 1200; // Calcular el tipo mensual
double numerador = tipo * Math.pow(1 + tipo, periodo);
double denominador = Math.pow(1 + tipo, periodo) - 1;
double cuota = importe * (numerador / denominador);
System.out.println(
"\nLa cuota mensual será de " + cuota +
"\n¿La cuota supera tu límite? -> " + (cuota > limite));
}
}
Probando nuestra calculadora
Para comprobar el funcionamiento de esta calculadora, basta con pulsar F6 o hacer clic en el botón de ejecución, se abre el panel de la consola y nos solicita el primero de los datos. Introducimos el importe del préstamo, a continuación, el interés aplicable, el plazo de amortización y el importe máximo que podemos pagar mensualmente.
El programa realiza los cálculos y nos facilita tanto cuota mensual como la indicación de si esta cuota supera o no la cuota que podemos permitirnos pagar.
Fíjate que, al introducir un valor con parte fraccionaria en la consola (por ejemplo, al solicitar el tipo de interés) hemos escrito "1,2" en lugar de "1.2" . Al escribir código dentro de lo que sería código fuente de un programa Java, siempre utilizaremos el punto como separador decimal. Sin embargo, al ejecutar una aplicación Java, la máquina virtual utiliza la configuración regional del sistema en el que está ejecutándose. Como en este caso tiene una configuración regional que establece que el separador de miles es la coma, este es el carácter que hemos utilizado.
En este enlace te puedes descargar el código de ejemplo de este proyecto.
Si volvemos a ejecutar el programa y probamos a utilizar el punto, vemos que se produce una excepción, un error que detiene la ejecución del programa ya que se ha encontrado un caracter que la clase Scanner no ha sabido cómo interpretar.
Fecha de publicación: