Diario de un programador día 72
Lectura desde el teclado.
En la clase anterior se vio como mostrar información por pantalla usando
System.out.print(). Además de la sintaxis de las variables.
En esta ocasión se verá como solicitar información al usuario, guardarla en
una variable y luego mostrarla en pantalla.
Para leer datos se utilizará la clase Scanner, la cual se encuentra en el
paquete java.util
Así que para poder utilizar esa clase, lo primero será importarla. Para
ello, hay que escribir lo siguiente:
import java.util.Scanner;
Siempre respetando tanto mayúsculas como minúsculas.
Lo siguiente será crear la clase y el método main, lo cual ya se enseñó en
su oportunidad
import java.util.Scanner;
public class leer{
public static void main(String[]args){
}
}
Ya que se tiene la clase importada, se tiene que crear un objeto de la
clase Scanner asociado al dispositivo de entrada. Como en este caso (y en la
mayoría que se utilizarán) es el teclado, este será representado por System.in
Para crear el objeto Scanner asociado al teclado, se debe escribir lo
siguiente:
Scanner nombre = new Scanner(System.in);
Donde nombre es un nuevo tipo de
dato. Ahora nombre es de tipo Scanner. Algo muy parecido cuando se declara una
variable. Una variable puede ser de tipo entero, cadena, etc... En este caso
“nombre” es de tipo Scanner y permite la lectura por teclado.
En mi caso, crearé el objeto
“ingreso” el cual será de tipo Scanner. De esta forma:
import java.util.Scanner;
public class leer{
public static void
main(String[]args){
Scanner ingreso = new
Scanner(System.in);
}
}
Ya está casi en condiciones de
poder utilizar, solamente falta asignarle una variable, pero antes mencionaré
algunos ejemplos de lectura, quizás al principio parezca algo confuso pero con
la práctica se le agarra el ritmo.
Para leer números enteros, se
utilizará el método nextInt(), para decimales nextDouble y para cadenas nextLine().
En este primer ejemplo, lo que se
hará será leer un número desde el teclado, por lo tanto se deberá declarar una
variable de tipo int. El programa se vería así:
import
java.util.Scanner;
public class
leer{
public static void main(String[]args){
Scanner ingreso = new Scanner(System.in);
int num;
}
}
Lo siguiente que se realizará será
solicitar el ingreso del número utilizando System.out.print, y en la siguiente
línea se asignará a la variable num, el objeto Scanner, el cual permitirá que
mediante el método nextInt(), la variable guarde el número ingresado por el
usuario.
import java.util.Scanner;
public class leer{
public static void main(String[]args){
Scanner ingreso = new
Scanner(System.in);
int num;
System.out.print("Ingresa un
numero: ");
num = ingreso.nextInt();
}
}
Ahora que la variable fue asignada,
solo falta mostrarla en pantalla, para ello se puede mostrar con
System.out.print.
import
java.util.Scanner;
public
class leer{
public static void main(String[]args){
Scanner ingreso = new
Scanner(System.in);
int num;
System.out.print("Ingresa un numero: ");
num =
ingreso.nextInt();
System.out.println("El valor de num es " + num);
}
}
Ahora que el programa está listo, puede ser ejecutado.
También me he dado cuenta que no es
necesario crear múltiples objetos si es que tengo múltiples variables del mismo
tipo. Puedo ocupar el mismo objeto, como en el siguiente ejemplo:
import java.util.Scanner;
public class leer{
public static void main(String[]args){
Scanner ingreso = new
Scanner(System.in);
int num1, num2;
System.out.print("Ingresa un
numero: ");
num1 = ingreso.nextInt();
System.out.print("Ingresa otro
numero: ");
num2 =
ingreso.nextInt();
System.out.println("num1 = "
+ num1 + " num2 = " + num2);
}
}
Como dije antes, no es necesario crear otros objetos
si es que se van a leer datos del mismo tipo, pero si voy a solicitar por
ejemplo, algún nombre, es necesario crear otro objeto para recibir cadenas.
Aunque en realidad, podría utilizar el mismo objeto para todo, me he dado cuenta que al hacer eso, el programa
resultante empieza tener problemas en el manejo de su memoria y empiezan a
mostrar resultados extraños, así que por eso recomiendo crear nuevos objetos.
Aquí un pequeño ejemplo de lo que digo, fijarse en
los resultados como se "come" la lectura del teclado.
import
java.util.Scanner;
public class leer{
public static void main(String[]args){
Scanner ingreso = new
Scanner(System.in);
int num1, num2;
String palabra1,
palabra2;
System.out.print("Ingresa un numero: ");
num1 = ingreso.nextInt();
System.out.print("Ingresa una palabra: ");
palabra1 =
ingreso.nextLine();
System.out.print("Ingresa otro numero: ");
num2 =
ingreso.nextInt();
System.out.print("Ingresa otra palabra: ");
palabra2 = ingreso.nextLine();
System.out.println("num1 = " + num1);
System.out.println("palabra1 = " + palabra1);
System.out.println("num2 = " + num2);
System.out.println("palabra2
= " + palabra2);
}
}
Al utilizar el mismo objeto para recibir distintos tipos de datos, se
producen problemas como estos. Voy a arreglar esto creando un nuevo objeto para
recibir cadenas.
import java.util.Scanner;
public class leer{
public static void main(String[]args){
Scanner ingreso = new
Scanner(System.in);
Scanner texto = new Scanner(System.in);
int num1, num2;
String palabra1, palabra2;
System.out.print("Ingresa un
numero: ");
num1 = ingreso.nextInt();
System.out.print("Ingresa una
palabra: ");
palabra1 = texto.nextLine();
System.out.print("Ingresa otro
numero: ");
num2 = ingreso.nextInt();
System.out.print("Ingresa otra
palabra: ");
palabra2 = texto.nextLine();
System.out.println("num1 = "
+ num1);
System.out.println("palabra1 =
" + palabra1);
System.out.println("num2 = " + num2);
System.out.println("palabra2
= " + palabra2);
}
}
Ahora se puede ver que todos los datos fueron leídos
y mostrados sin problemas.
Alguien se podría preguntar por qué se debe importar
la clase Scanner y no las clases String o System. Algo a tener en cuenta es que
la mayoría de las clases en Java necesitan importarse, la excepción de las clases
antes mencionadas, es que esas clases (Y otras más) se encuentran dentro del
paquete java.lang, el cual se
importa de manera automática en todo programa Java, por lo que no hay necesidad
de importarlas.
Otra cosa es que las declaraciones "import"
no son obligatorias siempre y cuando se escriba el nombre de la clase completo,
incluyendo el paquete. Por ejemplo, la siguiente línea:
Scanner
ingreso = new Scanner(System.in);
podría
escribirse de la siguiente manera si no se utiliza la declaración import:
java.util.Scanner ingreso = new
java.util.Scanner(System.in);
Pero
hacerlo de esa forma es algo incómodo, por eso creo que es mejor utilizar la
declaración "import"
Esto es todo por ahora, a practicar y practicar que
la cosa de a poco se va complicando, pero no hay que preocuparse que todo
cuesta al principio y después se agarra el ritmo. Hasta la próxima
Gustavo J. Cerda Nilo
Enero 2016, Mayo 2016
No hay comentarios:
Publicar un comentario