より基本的な構文 - ループと例外

今週は、非生産的な週の 1 つでした。ブートキャンプの内容はあまり進めることができませんでしたが、このモジュールの最後の理論単位をなんとかカバーすることができました:

Java には、C から派生したほとんどの高級言語と同様、for、while、do-while という 3 つの基本的なタイプの繰り返しループ (有名なループ) があります。

For は、反復可能 (配列など) として使用される要素のサイズが事前にわかっている場合に使用されます。この要素は動的に変更される可能性があるため (たとえば、API からデータを受信するなど)、開発者は、反復可能オブジェクトに含まれる要素の数を正確に把握できない可能性がありますが、コードは把握します。その基本構造は次のとおりです:

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

最初の部分、int counter = 0 は、

カウント変数と呼ばれるものです。 もっときれいな名前はあるはずですが、これはその機能を説明するものです。彼女は基本的に...数えます。

これを 0 に初期化し、2 番目の部分では、それを

配列 数値のサイズと比較します。これを状態と呼びます。この条件が true である限り (つまり true を返す)、ループ は継続します。 必ずしも反復可能なものとの比較である必要はありませんが、通常はそのように使用されます。そして最後に、増分または減分となる
カウンター変更 があります。この変更を 1 つずつ行う必要は必ずしもありませんが、これが最も一般的に行われることです。

一方、while ループは、このような有限量の反復を提供しません。条件が真かどうかを確認し、真の場合は何らかのアクションを実行します。その構造は次のとおりです:

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

ループ宣言の括弧内にあるのは、継続するかどうかを確認するためにテストされる

条件 です。この条件の結果が true である限り、中かっこ間のアクションが実行されます。この情報は、そこからいくつかの結論を導き出すことができるため、重要です。

1. ループ アクションは、条件が正の場合にのみ発生します。特定の反復で条件の値が変化すると (true から false)、ループは中断され、そのサイクルのアクションは実行されません。
最初の反復で条件が false と評価されたため、アクションを実行しない
2. ループ が存在する可能性があります。
条件の結果を変更するアクションがなければ、無限
3. ループに直面することになります。

Do-while は while と非常に似ていますが、条件をチェックする

前にアクションが発生する点が異なります。これは、ループが中断される前に少なくとも 1 つのアクションを実行することを意味します。構文は 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
}

この例では、カウンター i が数値 5 以上になるまで for が実行され、反復ごとに現在のカウンターがコンソールに表示されます。ただし、カウンターが 4 に等しい場合、ループは中断され、最後の 2 つの数値は出力されません。

ここで、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 中国語 Web サイトの他の関連記事を参照してください。