更基本的語法 - 循環和異常

本周是效率低下的一周之一。我在訓練營內容上沒有取得太大進展，但我設法涵蓋了本模組的最後一個理論單元：

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中文網其他相關文章！