Aprendendo Java do Zero - Parte 6: Entrada e Saída de Dados

#Java

Este é o sexto artigo da série Aprendendo Java do Zero. Na Parte 1, escrevemos nosso primeiro "Hello World". Na Parte 2, montamos um ambiente de desenvolvimento local completo. Na Parte 3, aprendemos a declarar variáveis e conhecemos os oito tipos primitivos de dados. Na Parte 4, conhecemos os cinco grupos de operadores da linguagem. E na Parte 5, exploramos String em profundidade.

Até agora, todos os nossos programas seguiram um roteiro fixo: os valores já vinham prontos, escritos diretamente no código, e a única "conversa" com quem executava o programa era mostrar um resultado na tela. Chegou a hora de abrir esse roteiro dos dois lados: aprender a mostrar dados de formas diferentes, e, principalmente, aprender a receber dados de fora do programa, digitados por quem estiver usando ele. Neste artigo, nós vamos:

revisar e aprofundar as formas de exibir dados na tela: print(), println() e printf();
entender o que é System.in e para que ele serve;
conhecer a classe Scanner e como usá-la para capturar dados digitados pelo usuário;
conhecer os principais métodos de captura de entrada, como nextLine(), nextInt() e nextDouble();
entender uma pegadinha clássica ao misturar esses métodos, e como evitá-la;
entender o que acontece quando o usuário digita um tipo de dado diferente do esperado.

O que é entrada e saída de dados

Todo programa que interage com o mundo fora dele precisa, de alguma forma, receber informação e devolver informação. Esse conceito costuma ser chamado de E/S (entrada e saída) ou, em inglês, I/O (input/output).

Nos exemplos até aqui, a "saída" sempre foi a tela do console, e usamos apenas System.out.println() para isso. Já a "entrada" nem tinha aparecido ainda: todo valor usado nos programas anteriores foi definido diretamente no código, como uma literal. Nesta parte, vamos preencher essa lacuna.

Formas de exibir dados na tela

Você já conhece System.out.println(), que imprime um texto e, em seguida, quebra a linha. Existem duas outras variações desse mesmo comando que vale a pena conhecer.

`print()`

Funciona como println(), mas sem a quebra de linha ao final. Isso é útil quando você quer que a próxima saída continue na mesma linha:

public class Main {
  public static void main(String[] args) {
      System.out.print("Qual é o seu nome? ");
  }
}

Repare que, sem print(), a pergunta acima e uma eventual resposta do usuário apareceriam sempre em linhas separadas. Com print(), a pergunta fica "esperando" na mesma linha, pronta para receber o que for digitado logo em seguida.

`printf()`

Já printf() combina impressão com os especificadores de formato que vimos no artigo sobre Strings (%s, %d, %f e outros):

public class Main {
  public static void main(String[] args) {
      String nome = "João";
      int idade = 27;

      System.out.printf("Meu nome é %s e tenho %d anos.", nome, idade);
  }
}

Na prática, System.out.printf("...", args) funciona de forma parecida a montar o texto com String.format("...", args) e depois imprimir o resultado com print(), só que em um único comando. Assim como print(), printf() não quebra a linha automaticamente ao final; se quiser uma quebra de linha, é preciso incluir \n manualmente dentro do texto formatado.

Resumindo os três comandos:

println() imprime e quebra a linha.
print() imprime sem quebrar a linha.
printf() imprime com formatação (especificadores), sem quebrar a linha.

Como capturar dados digitados pelo usuário

Para receber dados digitados por quem estiver rodando o programa, a forma mais comum em Java é usar a classe java.util.Scanner.

import java.util.Scanner;

public class Main {
  public static void main(String[] args) {
      Scanner scanner = new Scanner(System.in);

      System.out.print("Qual é o seu nome? ");
      String nome = scanner.nextLine();

      System.out.printf("Certo, %s. Quantos anos você tem? ", nome);
      int idade = scanner.nextInt();

      System.out.printf("Legal! %d é uma boa idade para começar a programar.", idade);

      scanner.close();
  }
}

Vamos entender cada peça nova desse código.

O `import`

Diferente de System.out, que está sempre disponível sem nenhuma configuração extra, a classe Scanner não faz parte do conjunto de classes carregadas automaticamente em todo programa Java. Por isso, é preciso declarar, na primeira linha do arquivo, que o programa vai usar essa classe:

import java.util.Scanner;

Esse tipo de linha é chamado de import, e ele diz ao compilador onde encontrar uma classe que não é usada com tanta frequência a ponto de já vir disponível por padrão. Vamos ver outras classes que exigem import conforme a série avançar.

`System.in`

Assim como System.out representa o fluxo padrão de saída de dados (normalmente, a tela), System.in representa o fluxo padrão de entrada de dados (normalmente, o teclado, no caso de um programa rodando em um terminal).

Scanner scanner = new Scanner(System.in);

Essa linha cria um objeto Scanner, associado a System.in. A partir daqui, esse objeto passa a ser a "ponte" entre o que o usuário digita e o seu programa.

Os métodos de captura

O objeto scanner oferece um método diferente para cada tipo de dado que você espera receber:

nextLine(): captura uma linha inteira de texto, como uma String.
next(): captura apenas a próxima "palavra" (um trecho de texto até o próximo espaço), também como String.
nextInt(): captura um número inteiro (int).
nextDouble(): captura um número de ponto flutuante (double).
nextBoolean(): captura um valor booleano (true ou false).

Existem outros métodos equivalentes para os demais tipos primitivos (nextLong(), nextFloat(), e assim por diante), mas esses cinco cobrem a grande maioria dos casos do dia a dia.

O programa fica parado, esperando, no momento em que qualquer um desses métodos é chamado, até que o usuário digite algo e pressione Enter.

Por que fechar o `Scanner`

A última linha do exemplo é:

scanner.close();

O Scanner, por baixo dos panos, mantém aberto um recurso do sistema operacional ligado ao fluxo de entrada. Fechá-lo ao final, com close(), libera esse recurso de volta para o sistema. É uma boa prática, especialmente em programas maiores, chamar close() assim que você tiver certeza de que não vai precisar capturar mais nenhuma entrada.

A pegadinha entre `nextInt()`/`nextDouble()` e `nextLine()`

Existe um comportamento que costuma confundir quem está começando com Scanner: misturar nextInt() (ou nextDouble(), nextBoolean() etc.) com nextLine() em sequência.

import java.util.Scanner;

public class Main {
  public static void main(String[] args) {
      Scanner scanner = new Scanner(System.in);

      System.out.print("Quantos anos você tem? ");
      int idade = scanner.nextInt();

      System.out.print("Qual é o seu nome? ");
      String nome = scanner.nextLine(); // aparenta "pular" essa pergunta

      System.out.printf("Ei, %s, você tem %d anos.", nome, idade);
  }
}

Ao rodar esse código, a segunda pergunta parece ser ignorada, e nome acaba guardando uma string vazia. O motivo é o seguinte: quando você digita um número e pressiona Enter, o nextInt() captura apenas o número em si, e deixa a quebra de linha gerada pelo Enter parada, esperando, no buffer de entrada. A próxima chamada, nextLine(), encontra essa quebra de linha pendente logo de cara, interpreta como "linha vazia" e devolve uma string vazia, sem esperar você digitar nada.

A forma mais simples de resolver isso é adicionar uma chamada extra de scanner.nextLine() logo depois de qualquer nextInt(), nextDouble() ou similar, só para descartar essa quebra de linha pendente:

import java.util.Scanner;

public class Main {
  public static void main(String[] args) {
      Scanner scanner = new Scanner(System.in);

      System.out.print("Quantos anos você tem? ");
      int idade = scanner.nextInt();

      scanner.nextLine(); // descarta a quebra de linha pendente

      System.out.print("Qual é o seu nome? ");
      String nome = scanner.nextLine();

      System.out.printf("Ei, %s, você tem %d anos.", nome, idade);

      scanner.close();
  }
}

Vale guardar essa regra prática: sempre que um nextInt(), nextDouble() ou equivalente for seguido de um nextLine(), inclua um nextLine() "vazio" entre eles.

O que acontece se o usuário digitar o tipo errado

Cada método de captura espera um tipo específico de dado. Se o programa pedir um int com nextInt(), e o usuário digitar um texto que não pode ser interpretado como número (como "vinte e sete", em vez de 27), o programa não converte esse texto silenciosamente; ele interrompe a execução com um erro, chamado InputMismatchException.

Exception in thread "main" java.util.InputMismatchException
  at java.base/java.util.Scanner.throwFor(Scanner.java:...)

Por enquanto, o comportamento padrão do programa diante desse erro é simplesmente parar de rodar. Mais adiante nesta série, quando chegarmos ao tópico de tratamento de exceções, vamos aprender a capturar esse tipo de erro e reagir a ele sem derrubar o programa inteiro, por exemplo, pedindo ao usuário para digitar o valor novamente.

O que vem a seguir

Neste sexto artigo, você aprendeu as diferentes formas de exibir dados na tela (print(), println() e printf()), conheceu a classe Scanner e seus principais métodos de captura de entrada, entendeu a pegadinha clássica entre nextInt()/nextDouble() e nextLine(), e viu o que acontece quando a entrada não corresponde ao tipo esperado.

Agora que já sabemos fazer nossos programas conversarem com quem os executa, na Parte 7 desta série vamos dar o próximo passo natural: ensinar o programa a tomar decisões, com o tópico "Como usar estruturas condicionais em Java", cobrindo if, else if, else e o operador ternário.

Até lá!

Este artigo é parte de uma série de introdução a Java escrita do zero, com progressão didática própria pensada para quem nunca programou na linguagem antes.

Artigos dessa série na DIO: