더 기본적인 구문 - 루프 및 예외

이번 주는 비생산적인 한 주였습니다. 부트캠프 콘텐츠에서는 많은 진전을 이루지 못했지만 이 모듈의 마지막 이론 단원은 다룰 수 있었습니다.

C에서 파생된 대부분의 고급 언어와 마찬가지로 Java에는 for, while 및 do-while의 세 가지 기본 반복 루프 유형(유명한 루프)이 있습니다.

For는 반복 가능 항목(예: 배열)으로 사용될 요소의 크기를 미리 알고 있을 때 사용됩니다. 이 요소는 동적으로 변경될 수 있습니다(예: API에서 데이터 수신 등). 따라서 개발자로서 귀하는 iterable에 포함되는 요소 수를 정확히 알지 못할 수도 있지만 코드에서는 알 수 있습니다. 기본 구조는 다음과 같습니다.

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

첫 번째 부분인 int counter = 0은

count 변수라고 부르는 것입니다. 더 예쁜 이름이 있어야 하지만 이것이 무엇을 하는지 설명하는 이름입니다. 그녀는 기본적으로... 계산을 합니다.

0으로 초기화하고 두 번째 부분에서는

배열 숫자의 크기와 비교합니다. 이것이 우리가 조건이라고 부르는 것입니다. 이 조건이 true인 한(즉, true를 반환하는 경우) 루프는 계속됩니다. 일부 반복 가능한 항목과 반드시 ​​비교할 필요는 없지만 일반적으로 그런 식으로 사용됩니다. 그리고 마지막으로 증가 또는 감소가 될 수 있는
카운터 변경이 있습니다. 또한 이 변경 사항이 꼭 하나씩 이루어질 필요는 없지만 가장 흔히 볼 수 있는 현상입니다.

반면에 while 루프는 이러한 유한한 양의 반복을 제공하지 않습니다. 조건이 참인지 확인하고, 참이면 조치를 취합니다. 구조는 다음과 같습니다.

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

루프 선언에서 괄호 사이에 있는 것은 계속되는지 여부를 테스트할

조건입니다. 이 조건의 결과가 true인 한 중괄호 사이의 작업이 수행됩니다. 이 정보는 다음과 같은 결론을 도출할 수 있기 때문에 중요합니다.

1. loop 작업은 조건이 긍정적인 경우에만 발생합니다. 특정 반복에서 조건 값이 변경되면(참에서 거짓으로) 루프가 중단되고 해당 주기의 작업이 실행되지 않습니다.
처음 반복부터 조건이 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까지의 홀수를 출력해야 한다고 가정해 보겠습니다. 다음 구조로 계속을 사용할 수 있습니다.

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 중국어 웹사이트의 기타 관련 기사를 참조하세요!