Con Java podemos leer datos del teclado (que son introducidos por el usuario) a través de la clase Scanner. En este post voy a explicar su uso un poco más detallado para manejar excepciones y también explicaré los otros métodos para leer un booleano, entero, flotante, cadena u otro tipo de dato.

En resumen, veremos cómo leer datos introducidos por el teclado en Java, y además:

• Instanciar de la clase Scanner
• Manejo de excepciones al leer datos del teclado
• Todos los métodos que existen con Scanner
• Leer un entero, cadena, flotante y más tipos de datos

Vamos allá.

La clase Scanner y su import

Para tener la clase Scanner en Java (y para poder leer datos del teclado) debemos importar la clase con:

import java.util.Scanner;

Luego instanciamos un objeto de esa clase así:

Scanner escaner = new Scanner(System.in);

En donde indicamos que nuestra variable se llamará escaner y que es de tipo de entrada (System.in).

Una vez que ya tenemos nuestro objeto que lee datos del teclado, podemos comenzar a trabajar.

Leer datos del teclado con Scanner

Para leer algo que el usuario introduce, primero le mandamos un mensaje para que sepa lo que tiene que escribir. Después de ello llamamos a un método de Scanner dependiendo del tipo de dato que vayamos a escanear.

Aquí un ejemplo que hace todo eso:

/**
 Leer datos que el usuario introduce a través del teclado
 usando Scanner y algunos métodos

 @author parzibyte
*/import java.util.Scanner;

class Main {
 public static void main(String[] args) {
  Scanner escaner = new Scanner(System.in);
  // Leer una cadena
  System.out.println("Hola. Dime tu nombre: ");
  String nombre = escaner.nextLine();
  // Leer un entero
  System.out.println("Dime tu edad: ");
  int edad = escaner.nextInt();

  // Leer un flotante
  System.out.println("Dime tu peso: ");
  float peso = escaner.nextFloat();

  System.out.println("Te llamas " + nombre + ", tienes " + edad + " años y tu peso es de " + peso + " kilogramos");
  // Al final y por buenas prácticas cerramos el escaner
  escaner.close();
 }
}

Con eso nos damos cuenta que para leer una cadena llamamos a nextLine, para leer un entero usamos nextInt y finalmente para leer un flotante usamos nextFloat.

Por cierto, por buenas prácticas recomiendo cerrar el Scanner al final con el método close.

Finalmente, para imprimir un mensaje usamos el ya conocido System.out.println("mensaje");.

Métodos que tiene Scanner

Tiene muchísimos, los cuales puedes ver aquí. Voy a explicar algunos:

• Para leer un entero se usa nextInt
• Si queremos leer un double, entonces nextDouble
• En caso de necesitar un flotante o float, se llama a nextFloat
• Si necesitamos un booleano usamos el método nextBoolean

Por cierto, el método nextInt (también nextShort, nextBigInteger y nextLong) acepta un radix o base que permite especificar la base en la que está el número que vamos a leer.

Un ejemplo de la base sería en donde leemos un número binario como entero, llamando a nextInt(2) especificando la base 2; así el usuario puede introducir por ejemplo el número 1000 y Java lo regresará como 8 (pues ese número binario en base 10 es 8).

Otros métodos que no puse son nextBigDecimal, nextBigInteger, nextLong y nextShort. Si quieres profundizar más, visita el enlace que dejé aquí arriba.

Manejar excepciones y validar entrada

Cada método genera sus excepciones en caso de que algo salga mal. Por poner un ejemplo, nextInt lanza tres excepciones pero una de ellas es la de InputMismatchException que se lanza cuando se introduce un entero que no es válido, ya sea porque no es un entero según la base especificada o se sale del rango.

El siguiente ejemplo de código lee un entero por teclado pero además atrapa la excepción y valida si es un entero o no:

/**
 Leer datos que el usuario introduce a través del teclado
 usando Scanner, pero validar la entrada

 @author parzibyte
*/import java.util.Scanner;
import java.util.InputMismatchException; // No olvides importar la excepción

class Main {
 public static void main(String[] args) {
  Scanner escaner = new Scanner(System.in);
  // Leer un entero pero usar un Try/Catch
  System.out.println("Dime tu edad: ");
  try {
   // En caso de que todo vaya bien
   int edad = escaner.nextInt();
   System.out.println("Tienes " + edad + " años");
  } catch (InputMismatchException e) {
   /*
    * Pero si el usuario introduce algo que no es numérico, se sale del rango o no
    * es la base deseada, atrapamos la excepción
    */   System.out.println("No introdujiste un número válido");
  }

  // Al final y por buenas prácticas cerramos el escaner
  escaner.close();
 }
}

Cada método tiene sus excepciones, las cuales se pueden ver a detalle aquí.

Probar ejemplos de código o descargar

Eres libre de descargar el código de Java. Recomiendo ver cómo instalar Java y cómo instalar NetBeans.

No olvides que aquí puedes ver más tutoriales de Java.