更基本的语法 - 循环和异常

本周是效率低下的一周之一。我在训练营内容上没有取得太大进展，但我设法涵盖了本模块的最后一个理论单元：

Java 与大多数源自 C 的高级语言一样，具有三种基本类型的重复循环（著名的循环）：for、while 和 do-while。

For 在我们预先知道将用作可迭代对象（如数组）的元素的大小时使用。该元素可能会动态更改（例如，从 API 接收数据），因此作为开发人员，您可能不确切知道可迭代对象将具有多少个元素，但代码会知道。其基本结构是：

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

第一部分，int 计数器 = 0 就是我们所说的

计数变量。 肯定有更漂亮的名字，但这一个可以解释它的作用。她基本上……数了数。

我们将其初始化为 0，并在第二部分中将其与

数组 数字的大小进行比较。这就是我们所说的条件。只要这个条件为真（即返回真），循环就会继续。 它不一定需要与某些可迭代对象进行比较，但通常会以这种方式使用，最后，我们有
计数器更改 ，它可以是增量或减量。这种改变也不是必须一一进行，但这是最常见的事情。

另一方面，while 循环不提供这些有限的迭代次数。它检查条件是否为真，如果是，则采取一些操作。它的结构是这样的：

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

循环声明中括号之间的是

条件，将对其进行测试以检查循环是否继续。只要该条件的结果为真，就会执行大括号之间的操作。这些信息很重要，因为我们可以从中得出一些结论：

1. 循环动作仅在条件为正时才会发生。如果在任何给定的迭代中条件的值发生变化（从 true 到 false），循环就会中断，并且不会执行该循环的操作；
可能有一些
2. 循环不执行任何操作，因为条件从第一次迭代开始就被评估为假；
如果不采取任何行动来改变条件的结果，我们将发现自己面临无限
3. 循环。

Do-while 与 while 非常相似，不同之处在于操作发生在

检查条件之前。这意味着循环在被中断之前将至少执行一项操作。语法与 while 非常相似：

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

与 while 相同，如果没有任何操作来更改

条件的结果，我们将处理无限循环。

为了更好地控制循环流程，仍然有break 和 continue 关键字。 break 中断整个循环，而 continue 仅中断当前迭代。例如：

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

在此示例中，for 将运行直到计数器 i 大于或等于数字 5，并且在每次迭代时，当前计数器将打印在控制台上。但是，当计数器等于 4 时，循环将被中断，并且不会打印最后两个数字。

现在，假设您需要在控制台中打印 1 到 10 的奇数。我们可以使用以下结构的 continue：

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

也就是说，从0到10，

循环将使用模检查计数器是否可以被2整除。如果是，循环将跳到下一次迭代，但如果不是，i 的值将在终端中打印。

到目前为止很平静，对吧？让我们继续进行异常处理。

在开发应用程序的过程中，会出现问题。在 Java 中，严重问题和简单问题之间是有区别的，严重问题会影响应用程序所在的系统或环境（错误），并且通常是不可恢复的情况，而较简单的问题是应用程序设法以某种方式解决的问题（异常）。

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á!

以上是更基本的语法 - 循环和异常的详细内容。更多信息请关注PHP中文网其他相关文章！