AnteriorPosterior

4. Variables. Operaciones matemáticas básicas. Pedir datos al usuario.

  Curso: Introducción a Java

4. Variables. Operaciones matemáticas básicas. Pedir datos al usuario

4.1. Las variables.

Curso de Java,por Nacho Cabanes

En nuestro primer ejemplo escribíamos un texto en pantalla, pero este texto estaba prefijado dentro de nuestro programa.

De forma muy similar, podemos realizar operaciones matemáticas si las indicamos sin comillas. Así, el ordenador sabrá que no debe escribir algo "tal cual", sino que debe intentar descubrir su significado:

// Suma1.java
// Ejemplo de suma con datos prefijados
// Introducción a Java, Nacho Cabanes
 
class Suma1 { 
 
    public static void main( String args[] ) { 
        System.out.println( 
            "La suma de 56 y 23 es:" ); // Muestro un mensaje de aviso 
        System.out.println( 
            56+23 ); // y el resultado de la operación 
    }
}
 

Pero esto no es lo habitual: normalmente los datos que maneje nuestro programa serán el resultado de alguna operación matemática o de cualquier otro tipo, a partir de datos introducidos por el usuario, leídos de un fichero, obtenidos de Internet... Por eso, necesitaremos un espacio en el que ir almacenando valores temporales y resultados de las operaciones.

En casi cualquier lenguaje de programación podremos reservar esos "espacios", y asignarles un nombre con el que acceder a ellos. Esto es lo que se conoce como "variables".

Por ejemplo, si queremos que el usuario introduzca dos números y el ordenador calcule la suma de ambos números y la muestre en pantalla, necesitaríamos el espacio para almacenar al menos esos dos números iniciales. No sería imprescindible reservar espacio también para la suma, porque podemos mostrarla en pantalla en el mismo instante en que la calculamos. Los pasos a dar serían los siguientes:

  • Avisar al usuario de que deseamos que introduzca un número.
  • Almacenar ese valor que introduzca el usuario (por ejemplo, en un espacio de memoria al que podríamos asignar el nombre "primerNumero").
  • Pedir al usuario que introduzca otro número.
  • Almacenar el nuevo valor (por ejemplo, en otro espacio de memoria llamado "segundoNumero").
  • Mostrar en pantalla el resultado de sumar "primerNumero" y "segundoNumero".

Pues bien, en este programa estaríamos empleando dos variables llamadas "primerNumero" y "segundoNumero". Cada una de ellas se usaría para acceder a un espacio de memoria, que será capaz de almacenar un número.

Para no desperdiciar memoria de nuestro ordenador, el espacio de memoria que hace falta "reservar" se podrá optimizar según lo grande que pueda llegar a ser dicho número (la cantidad de cifras), o según la precisión que necesitemos para ese número (cantidad de decimales). Por eso, tenemos disponibles diferentes "tipos de variables".

Por ejemplo, si vamos a manejar números sin decimales ("números enteros") de como máximo 9 cifras, nos interesaría el tipo de datos llamado "int" (esa palabra es la abreviatura de "integer", "entero" en inglés). Este tipo de datos consume un espacio de memoria de 4 bytes. Si no necesitamos guardar datos tan grandes (por ejemplo, si nuestros datos va a ser números inferiores a 10.000), podemos emplear el tipo de datos llamado "short" (entero "corto"), que ocupa la mitad de espacio.

Con eso, vamos a ver un programa sume dos números enteros (de no más de 9 cifras) prefijados y muestre en pantalla el resultado:

// Suma2.java
// Ejemplo de suma con variables
// Introducción a Java, Nacho Cabanes
 
class Suma2 { 
 
    public static void main( String args[] ) { 
 
        int primerNumero = 56; // Dos enteros con valores prefijados 
        int segundoNumero = 23; 
 
        System.out.println( 
            "La suma de 56 y 23 es:" ); // Muestro un mensaje de aviso 
        System.out.println( 
            primerNumero+segundoNumero ); // y el resultado de la operación 
    }
}
 

Como se ve, la forma de "declarar" un variable es detallando primero el tipo de datos que podrá almacenar ("int", por ahora) y después el nombre que daremos la variable. Además, opcionalmente se puede indicar un valor inicial.

 

Podríamos pensar en mejorar el programa anterior para que los números a sumar no estén prefijados, sino que se pidan al usuario... pero eso no es trivial. El lenguaje Java prevé que quizá se esté utilizando desde un equipo que no sea un ordenador convencional, y que quizá no tenga un teclado conectado, así que deberemos hacer ciertas comprobaciones de errores que todavía están fuera de nuestro alcance. Por eso, vamos a aplazar un poco eso de pedir datos al usuario.

Ejercicio propuesto 4.1.1: Crea un programa en Java que escriba en pantalla el producto de dos números prefijados (pista: el símbolo de la multiplicación es el asterisco, "*").

4.2. Operaciones matemáticas básicas.

Hay varias operaciones matemáticas que son frecuentes. Veremos cómo expresarlas en Java, así como otra operación menos habitual

Las que usaremos con más frecuencia son:

Operación matemática
Símbolo correspondiente
Suma
+
Resta
-
Multiplicación
*
División
/
Resto de la división
%

Hemos visto un ejemplo de cómo calcular la suma de dos números; las otras operaciones se emplearían de forma similar. La única operación "menos habitual" es el resto de la división. Por ejemplo, si dividimos 14 entre 3, obtenemos 4 como cociente y 2 como resto, de modo que el resultado de 14 % 3 sería 2.


Ejercicio propuesto 4.2.1: Crea un programa que muestre la división de dos números prefijados.

Ejercicio propuesto 4.2.2: Crea un programa que muestre el resto de dividir 100 entre 30.

4.3. Operar con datos introducidos por el usuario

Vamos a ver cómo hacer que sea el usuario quien introduzca valores para esas variables, que es algo mucho más habitual. Nuestro primer ejemplo sumará dos números, que en esta ocasión no estarán prefijados:

// Suma3.java
// Ejemplo a las variables introducidas por el usuario
// Introducción a Java, Nacho Cabanes
 
import java.util.Scanner;
 
class Suma3 { 
 
    public static void main( String args[] ) { 
 
        Scanner teclado = new Scanner(System.in);
        System.out.print( "Introduzca el primer número: " );
        int primerNumero = teclado.nextInt();
        System.out.print( "Introduzca el segundo número: " );
        int segundoNumero = teclado.nextInt(); 
 
        System.out.print( "Su suma es: " );
        System.out.println( primerNumero+segundoNumero );
    }
}
 

En este programa hay varias cosas nuevas:

  • Vamos a usar una característica que no es algo básico del lenguaje. Por eso le decimos que deseamos "importar" nuevas funcionalidades. En nuestro caso, se trata de un tal "Scanner", que nos permitirá analizar textos: import java.util.Scanner;
  • En concreto, nuestro scanner va a tomar datos desde la entrada del sistema (System.in), por lo que lo declaramos con: Scanner teclado = new Scanner(System.in); El nombre "teclado" podría ser "entrada" o cualquier otro.
  • A partir de entonces, cada vez que llamemos a ".nextInt()" se leerá un número desde la entrada estándar del sistema (el teclado): int primerNumero = teclado.nextInt();

Son varias novedades, pero tampoco debería resultar difícil. Este programa escribirá algo como (dependiendo de los datos que introduzca el usuario):

Introduzca el primer número: 34
Introduzca el segundo número: 56
Su suma es: 90

Es habitual declarar las variables al principio del programa, antes de que comience la lógica real que resuelve el problema. Si varias variables van a guardar datos del mismo tipo, se pueden declarar todas ellas a la vez, separadas por comas, como en el siguiente ejemplo:

// Suma3b.java
// Dos variables declaradas a la vez
// Introducción a Java, Nacho Cabanes
 
import java.util.Scanner;
 
class Suma3b { 
 
    public static void main( String args[] ) { 
 
        Scanner teclado;
        int primerNumero, segundoNumero;
 
        teclado = new Scanner(System.in);
        System.out.print( "Introduzca el primer número: " );
        primerNumero = teclado.nextInt();
        System.out.print( "Introduzca el segundo número: " );
        segundoNumero = teclado.nextInt(); 
 
        System.out.print( "Su suma es: " );
        System.out.println( primerNumero+segundoNumero );
    }
}
 

Como la forma de asimilar todo esto es probándolo, aquí tienes varios ejercicios propuestos:

Ejercicio propuesto 4.3.1: Crea un programa que calcule y muestre el producto de dos números enteros que introduzca el usuario.

Ejercicio propuesto 4.3.2: Crea un programa que calcule y muestre la división de dos números enteros introducidos por el usuario.

Ejercicio propuesto 4.3.3: Crea un programa que calcule y muestre el resto de la división de dos números enteros que introduzca el usuario.

Ejercicio propuesto 4.3.4: Crea un programa que pida al usuario una longitud en millas (por ejemplo, 3) y calcule su equivalencia en metros (1 milla = 1609 m).

Ejercicio propuesto 4.3.5: Crea un programa que pida al usuario una temperatura en grados centígrados y calcule (y muestre) a cuántos grados Fahrenheit equivalen (F = 9*C/5 + 32).

Ejercicio propuesto 4.3.6: Crea un programa que pregunte al usuario la base y la altura de un triángulo y muestre su superficie (S = B*A/2).


4.4. Incremento y asignaciones abreviadas.

Hay varias operaciones muy habituales, que tienen una sintaxis abreviada en Java.

Por ejemplo, para sumar 2 a una variable "a", la forma "normal" de conseguirlo sería:

a = a + 2;

pero existe una forma abreviada en Java:

a += 2;

Al igual que tenemos el operador += para aumentar el valor de una variable, podemos emplear -= para disminuirlo, /= para dividirla entre un cierto número, *= para multiplicarla por un número, y así sucesivamente. Por ejemplo, para multiplicar por 10 el valor de la variable "b" haríamos

b *= 10;

También podemos aumentar o disminuir en una unidad el valor de una variable, empleando los operadores de "incremento" (++) y de "decremento" (--). Así, para sumar 1 al valor de "a", podemos emplear cualquiera de estas tres formas:

a = a+1;
a += 1;
a++;

Los operadores de incremento y de decremento se pueden escribir antes o después de la variable. Así, es lo mismo escribir estas dos líneas:

a++;
++a;

Pero hay una diferencia si ese valor se asigna a otra variable "al mismo tiempo" que se incrementa/decrementa:

int c = 5;
int b = c++;

da como resultado c = 6 y b = 5, porque se asigna el valor a "b" antes de incrementar "c", mientras que

int c = 5;
int b = ++c;

da como resultado c = 6 y b = 6 (se asigna el valor a "b" después de incrementar "c").

Por eso, para evitar efectos colaterales no esperados, es mejor no incrementar una variables a la vez que se asigna su valor a otra, sino hacerlo en dos pasos.

Ejercicio propuesto 4.4.1: Calcula "a mano" el resultado de las siguientes operaciones con números enteros, y luego crea un programa que muestre el resultado.
a = 5;
a++;
a*=2;
a-=3;
a%=5;
a=a+7;

4.5. Otros tipos de datos numéricos

No sólo se puede almacenar números enteros de hasta 9 cifras. Java nos permite usar también otros tipos de datos numéricos:

Nombre ¿Admite decimales? Valor mín. Valor máx. Precisión Ocupa
byte no -128 127 - 1 byte
short no -32.768 32.767 - 2 bytes
int no -2.147.483.648 2.147.483.647 - 4 bytes
long no -9.223.372.036.854.775.808 9..223.372.036.854.775.807 - 8 bytes
float 1.401298E-45 3.402823E38 6-7 cifras 4 bytes
double 4.94065645841247E-324 1.79769313486232E308 14-15 cifras 8 bytes

 

Los datos de tipo byte, short, int y long sirven para almacenar números enteros, de mayor o menor tamaño. Si se desborda ese tamaño, el programa se interrumpirá con un error, como en este ejemplo:

// DesbordarByte.java
// Ejemplo de desbordamiento de una variable
// Introducción a Java, Nacho Cabanes
 
class DesbordarByte { 
    public static void main( String args[] ) { 
        byte dato = 100;
        System.out.print( "El dato inicialmente es: " );
        System.out.println( dato );
        dato += 100; 
        System.out.print( "Si sumamos 100, el dato ahora es: " );
        System.out.println( dato );
    }
}
 

Que mostraría:

El dato inicialmente es: 100
Si sumamos 100, el dato ahora es: -56

Por su parte, los datos float y double permiten almacenar números reales (con cifras decimales), que pueden almacenar los números de forma incorrecta si tienen más cifras que la permitida por ese tipo de datos, como en este ejemplo:

// PrecisionFloat.java
// Ejemplo de límite de precisión de un dato float
// Introducción a Java, Nacho Cabanes
 
class PrecisionFloat { 
    public static void main( String args[] ) { 
        float dato = 1.23456789f;
        System.out.print( "El dato inicialmente es: " );
        System.out.println( dato );
        dato += 1000; 
        System.out.print( "Si sumamos 1000, el dato ahora es: " );
        System.out.println( dato );
    }
}
 

Que escribiría:

El dato inicialmente es: 1.2345679
Si sumamos 1000, el dato ahora es: 1001.23456

Para pedir datos de estos tipos, podemos usar un "Scanner" con ".nextByte", ".nextShort", ".nextLong", ".nextFloat" o ".nextDouble"

Por ejemplo, se podría sumar dos números reales de forma similar a como hemos visto para dos números enteros:

// SumaFloat.java
// Sumar dos números reales
// Introducción a Java, Nacho Cabanes
 
import java.util.Scanner;
 
class SumaFloat { 
 
    public static void main( String args[] ) { 
 
        Scanner teclado;
        float primerNumero, segundoNumero;
 
        teclado = new Scanner(System.in);
        System.out.print( "Introduzca el primer número real: " );
        primerNumero = teclado.nextFloat();
        System.out.print( "Introduzca el segundo número real: " );
        segundoNumero = teclado.nextFloa.t(); 
 
        System.out.print( "Su suma es: " );
        System.out.println( primerNumero+segundoNumero );
    }
}
 

Un ejemplo de su posible resultado (que muestra las posibles pérdidas de precisión) podría ser:

Introduzca el primer número real: 2,3
Introduzca el segundo número real: 3,56
Su suma es: 5.8599997

Ejercicio propuesto 4.5.1: Crea un programa que calcule y muestre la suma de dos números de dos cifras (de tipo byte) que introduzca el usuario.

Ejercicio propuesto 4.5.2: Crea un programa que pida al usuario su año de nacimiento y el año actual (suando datos de tipo short) y halle la diferencia de ambos para obtener su edad.

Ejercicio propuesto 4.5.3: Crea un programa que calcule y muestre la división de dos números reales de doble precisión introducidos por el usuario.

Ejercicio propuesto 4.5.4: Crea un programa que pida al usuario una longitud en millas (por ejemplo, 3) y calcule su equivalencia en kilómetros, usando datos de tipo float (1 milla = 1.609 km).

Actualizado el: 15-07-2015 00:26

AnteriorPosterior