Sintaks yang lebih asas - Gelung dan Pengecualian

Minggu ini adalah salah satu minggu yang tidak produktif. Saya tidak dapat memajukan banyak dalam kandungan bootcamp, tetapi saya berjaya merangkumi unit teori terakhir modul ini:

Java, seperti kebanyakan bahasa peringkat tinggi yang berasal daripada C, mempunyai tiga jenis asas gelung ulangan (gelung yang terkenal): untuk, sambil dan lakukan-sementara.

For digunakan apabila kita mengetahui terlebih dahulu saiz elemen yang akan digunakan sebagai iterable (seperti array). Elemen ini mungkin berubah secara dinamik (seperti, contohnya, menerima data daripada API), jadi anda, sebagai pembangun, mungkin tidak tahu dengan tepat berapa banyak elemen yang boleh dilelang akan ada, tetapi kod itu akan tahu. Struktur asasnya ialah:

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

Bahagian pertama, pembilang int = 0 ialah apa yang kita panggil

pembolehubah kiraan. Mesti ada nama yang lebih cantik, tetapi ini adalah nama yang menerangkan fungsinya. Dia pada asasnya... melakukan kiraan.

Kami memulakannya kepada 0 dan, di bahagian kedua, kami membandingkannya dengan saiz nombor

tatasusunan. Inilah yang kami panggil keadaan. Selagi syarat ini benar (iaitu mengembalikan benar), gelung akan diteruskan. Ia tidak semestinya perlu menjadi perbandingan dengan beberapa yang boleh diubah, tetapi ia biasanya digunakan dengan cara itu, Dan akhirnya, kita mempunyai
perubahan balas, yang boleh menjadi kenaikan atau penurunan. Perubahan ini juga tidak semestinya perlu dibuat satu demi satu, tetapi ia adalah perkara yang paling biasa untuk dilihat.

Gelung while sebaliknya, tidak menyediakan jumlah lelaran terhingga ini. Ia menyemak sama ada sesuatu syarat itu benar dan, jika ya, mengambil beberapa tindakan. Strukturnya ialah:

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

Apa yang ada di antara tanda kurung dalam pengisytiharan gelung ialah

syarat yang akan diuji untuk menyemak sama ada ia berterusan atau tidak. Selagi keputusan syarat ini benar, tindakan antara pendakap akan dilakukan. Maklumat ini penting kerana kita boleh membuat beberapa kesimpulan daripadanya:

Tindakan
1. gelung hanya akan berlaku jika keadaan positif. Jika dalam mana-mana lelaran tertentu nilai keadaan berubah (daripada benar kepada palsu), gelung akan terganggu dan tindakan kitaran itu tidak dilaksanakan;
Mungkin terdapat beberapa
2. gelung yang tidak melakukan sebarang tindakan kerana keadaan telah dinilai sebagai palsu dari lelaran pertama;
Jika tiada tindakan untuk mengubah keputusan keadaan, kita akan mendapati diri kita berhadapan dengan
3. gelung yang tidak terhingga.

Do-while sangat serupa dengan while, dengan perbezaan tindakan itu berlaku

sebelum menyemak keadaan. Ini bermakna gelung akan melakukan sekurang-kurangnya satu tindakan sebelum diganggu. Sintaks sangat serupa dengan while:

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

Dengan cara yang sama seperti sementara, jika tiada tindakan untuk mengubah keputusan

keadaan, kita akan berhadapan dengan gelung yang tidak terhingga.

Untuk mempunyai lebih kawalan ke atas aliran gelung, masih terdapat kata kunci rehat dan teruskan. break mengganggu keseluruhan gelung, manakala continue hanya mengganggu lelaran semasa. Contohnya:

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

Dalam contoh ini, for akan dijalankan sehingga pembilang i lebih besar daripada atau sama dengan nombor 5, dan pada setiap lelaran pembilang semasa akan dicetak pada konsol. Walau bagaimanapun, apabila pembilang sama dengan 4, gelung akan terganggu dan dua nombor terakhir tidak akan dicetak.

Sekarang, mari kita anggap anda perlu mencetak nombor ganjil dari 1 hingga 10 dalam konsol. Kita boleh menggunakan continue dengan struktur berikut:

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

Iaitu, dari 0 hingga 10,

gelung akan menyemak sama ada pembilang boleh dibahagi dengan 2 menggunakan modulo. Jika ya, gelung akan melangkau ke lelaran seterusnya, tetapi jika tidak, nilai i akan dicetak dalam terminal.

Setakat ini tenang kan? Mari kita beralih kepada pengendalian pengecualian.

Semasa membangunkan aplikasi, masalah akan berlaku. Di Jawa terdapat perbezaan antara masalah serius, yang menjejaskan sistem atau persekitaran di mana aplikasi berada (ralat) dan biasanya keadaan tidak dapat dipulihkan, dan masalah yang lebih mudah, yang mana aplikasi berjaya menyelesaikannya dalam beberapa cara (pengecualian).

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

Atas ialah kandungan terperinci Sintaks yang lebih asas - Gelung dan Pengecualian. Untuk maklumat lanjut, sila ikut artikel berkaitan lain di laman web China PHP!