Grundlegendere Syntax – Schleifen und Ausnahmen

Diese Woche war eine dieser unproduktiven. Ich konnte in den Bootcamp-Inhalten keine großen Fortschritte machen, aber ich habe es geschafft, die letzten theoretischen Einheiten dieses Moduls abzudecken:

Java verfügt, wie die meisten von C abgeleiteten Hochsprachen, über drei grundlegende Arten von Wiederholungsschleifen (die berühmten Schleifen): for, while und do-while.

For wird verwendet, wenn wir im Voraus die Größe des Elements kennen, das als iterierbares Element (wie ein Array) verwendet wird. Dieses Element kann sich dynamisch ändern (z. B. durch den Empfang von Daten von einer API), sodass Sie als Entwickler möglicherweise nicht genau wissen, wie viele Elemente das Iterable haben wird, aber der Code weiß es. Seine Grundstruktur ist:

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

Der erste Teil, der int counter = 0, ist das, was wir die

Zählvariable nennen. Es muss schönere Namen geben, aber dieser erklärt, was er bewirkt. Im Grunde... zählt sie.

Wir initialisieren es auf 0 und vergleichen es im zweiten Teil mit der Größe der

Array-Zahlen. Das nennen wir Zustand. Solange diese Bedingung wahr ist (d. h. wahr zurückgibt), wird die Schleife fortgesetzt. Es muss nicht unbedingt ein Vergleich mit einer iterierbaren Variable sein, aber normalerweise wird es so verwendet. Und schließlich haben wir die
Zähleränderung, die ein Inkrement oder ein Dekrement sein kann. Es ist auch nicht unbedingt notwendig, dass diese Änderung einzeln vorgenommen wird, aber sie ist am häufigsten zu sehen.

Die while-Schleife hingegen sieht diese endlichen Mengen an Iterationen nicht vor. Es prüft, ob eine Bedingung wahr ist und ergreift gegebenenfalls Maßnahmen. Seine Struktur ist folgende:

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

Was zwischen den Klammern in der Schleifendeklaration steht, ist die

Bedingung, die getestet wird, um zu überprüfen, ob sie fortgesetzt wird oder nicht. Solange das Ergebnis dieser Bedingung wahr ist, wird die Aktion zwischen den geschweiften Klammern ausgeführt. Diese Informationen sind wichtig, weil wir daraus einige Schlussfolgerungen ziehen können:

Die Aktion
1. Schleife wird nur ausgeführt, wenn die Bedingung positiv ist. Wenn sich in einer bestimmten Iteration der Wert der Bedingung ändert (von wahr zu falsch), wird die Schleife unterbrochen und die Aktion dieses Zyklus wird nicht ausgeführt;
Möglicherweise gibt es eine
2. Schleife, die keine Aktion ausführt, weil die Bedingung bei der ersten Iteration als falsch bewertet wurde;
Wenn keine Maßnahmen ergriffen werden, um das Ergebnis der Bedingung zu ändern, stehen wir vor einer
3. Endlosschleife.

Do-while ist while sehr ähnlich, mit dem Unterschied, dass die Aktion

vor der Überprüfung der Bedingung erfolgt. Das bedeutet, dass die Schleife mindestens eine Aktion ausführt, bevor sie unterbrochen wird. Die Syntax ist while: sehr ähnlich

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

Auf die gleiche Weise wie while haben wir es mit einer

Endlosschleife zu tun, wenn keine Aktion zur Änderung des Ergebnisses der Bedingung erfolgt.

Um noch mehr Kontrolle über den Ablauf der Schleifen zu haben, gibt es weiterhin die Schlüsselwörter break und continue. break unterbricht die gesamte Schleife, während continue nur die aktuelle Iteration unterbricht. Zum Beispiel:

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

In diesem Beispiel wird for ausgeführt, bis der Zähler i größer oder gleich der Zahl 5 ist, und bei jeder Iteration wird der aktuelle Zähler auf der Konsole gedruckt. Wenn der Zähler jedoch gleich 4 ist, wird die Schleife unterbrochen und die letzten beiden Zahlen werden nicht gedruckt.

Nehmen wir nun an, Sie müssen die ungeraden Zahlen von 1 bis 10 in der Konsole drucken. Wir können continue mit der folgenden Struktur verwenden:

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

Das heißt, von 0 bis 10 prüft die

Schleife mithilfe des Modulo, ob der Zähler durch 2 teilbar ist. Wenn ja, springt die Schleife zur nächsten Iteration, wenn nicht, wird der Wert von i im Terminal ausgegeben.

Bisher ruhig, oder? Fahren wir mit der Ausnahmebehandlung fort.

Im Verlauf der Entwicklung einer Anwendung können Probleme auftreten. In Java gibt es eine Unterscheidung zwischen schwerwiegenden Problemen, die sich auf das System oder die Umgebung auswirken, in der sich die Anwendung befindet (Fehler) und normalerweise nicht behebbare Zustände sind, und einfacheren Problemen, die die Anwendung auf irgendeine Weise umgehen kann (Ausnahmen).

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

Das obige ist der detaillierte Inhalt vonGrundlegendere Syntax – Schleifen und Ausnahmen. Für weitere Informationen folgen Sie bitte anderen verwandten Artikeln auf der PHP chinesischen Website!