Mais sintaxe básica - Loops e Exceções

Essa semana foi uma daquelas pouco produtivas. Não consegui progredir muito no conteúdo do bootcamp, mas consegui cobrir as últimas unidades teóricas desse módulo:

Java, assim como a maior parte das linguagens de alto nível derivadas do C, tem três tipos básicos de laços de repetição (os famosos loops): o for, o while e o do-while.

O for é usado quando sabemos previamente qual o tamanho do elemento que vai ser usado como iterável (como uma array). Esse elemento pode sofrer alterações dinamicamente (como, por exemplo, receber dados de uma API), então pode ser que você, como desenvolvedor, não saiba exatamente quantos elementos o iterável terá, mas o código vai saber. Sua estrutura básica é:

int[] numbers = {1, 2, 3, 4, 5};
for (int counter = 0; counter < numbers.length; counter++) {
    System.out.println(numbers[counter]);
}

A primeira parte, o int counter = 0 é o que chamamos de variável de contagem.
Devem existir nomes mais bonitos, mas esse é um que é bem explicativo sobre o que ela faz. Ela basicamente... faz uma contagem.

Inicializamos ela em 0 e, na segunda parte, comparamos ela ao tamanho da array numbers. Isso é o que chamamos de condição. Enquanto essa condição for verdadeira (ou seja, retornar true), o loop irá continuar.
Não precisa ser necessariamente uma comparação com algum iterável, mas normalmente é usado dessa forma, E, por fim, temos a alteração do contador, que pode ser uma incrementação ou uma decrementação. Também não é estritamente necessário que seja de um em um essa alteração, mas é o mais comum a ser visto.

O laço de repetição while por outro lado, não prevê essas quantidades finitas de iterações. Ele checa se uma condição é verdadeira e, em caso positivo, realiza alguma ação. Sua estrutura é essa:

boolean podeJavascriptNoBack = false;
while (!podeJavascriptNoBack) {
    System.out.println("Tá proibido JavaScript no back-end.");
};

O que está entre os parênteses na declaração do laço é a condição que será testada para verificar se ele continua ou não. Enquanto o resultado dessa condição for verdadeiro (true), a ação entre as chaves será realizada. Essa informação é importante porque dela podemos tirar algumas conclusões:

1. A ação do loop só vai acontecer caso a condição seja positiva. Se em alguma determinada iteração o valor da condição mudar (de true para false), o loop é interrompido e a ação daquele ciclo não é executada;
2. Pode existir algum loop que não execute ação alguma porque a condição foi avaliada como false desde a primeira iteração;
3. Se não houver alguma ação para mudar o resultado da condição, nos veremos diante de um loop infinito.

O do-while é bem parecido com o while, com a diferença de que a ação acontece antes da verificação da condição. Isso quer dizer que o laço vai executar pelo menos uma ação antes de ser interrompido. A sintaxe é muito parecida com a do while:

boolean condition = true;
do {
    System.out.println("I'm inside a loop tee-hee!");
} while (condition);

Da mesma maneira que o while, se não houver alguma ação para alterar o resultado da condição, estaremos lidando com um loop infinito.

Para ter ainda mais controle sobre o fluxo dos laços, ainda existem as palavras chaves break e continue. O break interrompe o laço inteiro, enquanto que o continue interrompe apenas a iteração atual. Por exemplo:

for (int i = 0; i <= 5; i++) {
    if (i == 4) break;
    System.out.println(i); //0 1 2 3
}

Nesse exemplo, o for vai rodar até que o contador i seja maior ou igual ao número 5, e a cada iteração o contador atual será impresso no console. Contudo, quando o contador for igual a 4, o laço vai ser interrompido e os últimos dois números não serão impressos.

Agora, vamos supor que você precise imprimir os números ímpares de 1 a 10 no console. Podemos usar o continue com a seguinte estrutura:

for (int i = 0; i <= 10; i++) {
    if (i % 2 == 0) continue;
    System.out.println(i); //1 3 5 7 9
}

Ou seja, de 0 a 10, o loop vai verificar se o contador é divisível por 2 utilizando o módulo. Em caso positivo, o laço vai pular para a próxima iteração, mas em caso negativo o valor de i vai ser impresso no terminal.

Até aqui tranquilo, né? Vamos seguir para o tratamento de exceções.

Durante o curso do desenvolvimento de uma aplicação, problemas irão ocorrer. Em Java existe uma distinção entre problemas graves, que afetam o sistema ou ambiente onde a aplicação está (os errors) e normalmente são condições irrecuperáveis, e problemas mais simples, em que a aplicação consegue contornar de alguma forma (as exceptions).

No caso dos errors, pode se tratar de algum problema físico (como um OutOfMemoryError), exaustão dos recursos disponíveis (como um StackOverflowError) ou até mesmo um erro da própria JVM (Internal Error). O importante notar é que, nesse caso, não tem como tratar isso. É uma situação que quebra a aplicação e normalmente a joga em um estado irrecuperável.

Mas existe uma categoria de problemas em que é possível se recuperar: as Exceptions. As exceções são problemas que podem ser capturados e devidamente tratados, para que nosso programa não quebre na cara do cliente. As exceções podem ter as mais variadas causas, que podem ser desde problemas com a infraestrutura (como leitura/escrita de dados, conexão com um banco de dados SQL etc) ou de lógica (como um erro de argumento inválido).

Para realizar o tratamento de erros, normalmente um bloco try-catch é utilizado. Essa estrutura tenta executar uma ação (descrita no bloco try) e, caso encontre alguma exceção, captura esse problema e realiza uma tratativa em cima dela (que está descrita no bloco catch). Ela segue essa sintaxe:

try {
    double result = 10 / 0; //isso vai lançar um ArithmeticException
    System.out.println(result);
} catch (Exception e) {
    System.out.println("Não é possível dividir por 0, mané.");
}

Podemos declarar vários blocos catch encadeados, para tentar granularizar as tratativas de acordo com os erros encontrados:

try {  
    int result = 10 / 0; 
    System.out.println(result);  
} catch (ArithmeticException e) {  
    System.out.println("Não é possível dividir por 0, mané.");
} catch (NullPointerException e) {
    System.out.println("Alguma coisa que você informou veio nula, bicho.");
} catch (Exception e) {  
    System.out.println("Deu ruim, irmão. Um erro genérico ocorreu: " + e.getMessage());  
}

Além disso, ao final de toda a estrutura podemos declarar um bloco de código que sempre será executado, independente do caminho que o fluxo tomou: o finally:

try {  
    int result = 10 / 0; 
    System.out.println(result);  
} catch (ArithmeticException e) {  
    System.out.println("Não é possível dividir por 0, mané.");
} catch (NullPointerException e) {
    System.out.println("Alguma coisa que você informou veio nula, bicho.");
} catch (Exception e) {  
    System.out.println("Deu ruim, irmão. Um erro genérico ocorreu: " + e.getMessage());  
} finally {
    System.out.println("Cabô.");
}

Nesse exemplo, o código vai tentar dividir 10 por 0. Em seguida, vai entrar no primeiro bloco catch e imprimir "Não é possível dividir por 0, mané." e, por fim, entrar no bloco finally e imprimir "Cabô". Independente do caminho seguido, se houve sucesso ou não no try, o finally vai ser sempre executado.

Isso é tudo? Não! Nada é simples no Java.
As exceções podem ser divididas em dois tipos: as exceções verificadas (checked exceptions) e as não verificadas (unchecked exceptions). No caso das exceções verificadas, o compilador pede para que elas sejam tratadas para evitar que condições que estão além do escopo de código possam impactar no fluxo da aplicação. Por exemplo, o banco de dados que o programa está usando pode ter tido um problema, e a conexão pode falhar. Ao invés de simplesmente mostrar o erro, o Java pede que seja feita uma tratativa, como a abaixo:

public class DatabaseExample {
    public static void main(String[] args){
        try {
            Connection conn = getConnection();
            //executa alguma ação aqui...
        } catch (SQLException e) {
            System.out.println("Não foi possível conectar ao banco de dados. Erro: " + e.getMessage());
        }
    }

    public static Connection getConnection() throws SQLExeption {
        String url = "jdbc:mysql://localhost:3306/mydatabase";
        String user = "user";
        String password = "mySuperSecretPassword"; //por favor não armazenem senhas no código

        //isso pode lançar um erro de SQL
        return DriverManager.getConnection(url, user, password);
    }
}

O método getConnection() tenta realizar a conexão com o banco de dados usando as credenciais informadas, mas se em algum momento der problema (o banco está offline, as credenciais estão erradas, a máquina está desconectada da rede etc), a exceção será lançada. O método main, que chama o getConnection(), captura essa exceção e informa ao usuário que houve um erro ao realizar a conexão, ao invés se só mostrar a stack trace.

O compilador pede que esse tratamento seja implementado para proteger a aplicação de erros além do controle do desenvolvedor, tornando o programa mais resiliente e resistente à falhas.

Já as unchecked exceptions são exceções que não precisam ser obrigatoriamente tratadas. São casos de classes cujos métodos estão sob o controle do desenvolvedor e são, de modo geral, algum tipo de erro no código (seja de lógica ou uso incorreto de alguma API). Alguns exemplos desses são os famosos IllegalArgumentException, ArrayIndexOutOfBoundsException e NullPointerException.
Isso quer dizer que, se o compilador não reclamar, eu não preciso implementar um tratamento?
Não né. Muito melhor ter uma mensagem de erro amigável para o usuário saber o que tá acontecendo do que mandar isso aqui:

Bota tudo num try-catch que é sucesso.

E, por fim, teve um módulo sobre debugging usando Intellij e Eclipse, que foi mais prático do que teórico. Contudo, não consegui apresentar as informações passadas pela instrutura para o meio textual. Um post sobre debug em Java fica pro futuro.

Os dois módulos que restam nessa unidade são práticos (finalmente!). O próximo post vai ter bastante código. Até lá!