3 tipos de erros de programação e como evitá-los
Erros de programação são falhas no funcionamento dos aplicativos. Eles são comumente chamados de "bugs", daí o termo "depuração".
Como desenvolvedor, você passará muito tempo consertando bugs. Vários dos erros que você encontrará são comuns e conhecê-los o ajudará a evitá-los em primeiro lugar.
Aqui está o que você precisa saber sobre esses três tipos de erros de programação e como você pode se proteger contra eles:
1. Erros de tempo de execução ou execução
Esses são erros que ocorrem quando um programa está sendo executado (ou seja, em tempo de execução). Eles podem fazer com que um programa não seja executado corretamente ou até mesmo não seja executado.
Os erros fatais de tempo de execução fazem com que a execução do programa pare, enquanto os não fatais fazem com que a execução termine, mas com resultados incorretos.
Um erro de tempo de execução típico é uma divisão por erro zero. Supõe-se que a divisão por zero produza um resultado infinito, mas, infelizmente, ainda não criamos uma estrutura de dados que possa armazenar essa quantidade de dados.
Portanto, a divisão por zero leva a uma exceção aritmética no compilador Java.
2. Erros lógicos
Os erros de lógica são causados devido a raciocínios falhos. É importante observar que esses erros não são necessariamente causados por um “erro” que você cometeu. Eles podem ocorrer porque você não considerou um determinado cenário de execução.
Eles são os mais difíceis de manusear. Isso ocorre porque o código com um erro lógico é um programa válido na linguagem em que foi escrito. Portanto, ele não gerará um erro do compilador. O único problema é que ele produz resultados incorretos.
Um erro lógico fatal fará com que a execução do programa pare, enquanto um erro não fatal permitirá que a execução do programa continue, mas com resultados incorretos.
Um erro lógico comum é um erro off-by-one. Isso normalmente ocorre ao declarar uma condição de continuação de loop. Digamos que você queira imprimir os primeiros cinco números quadrados.
Você pode acabar escrevendo o código abaixo em seu loop for, que fornece apenas os primeiros quatro desses números.
for( int x=1; x<5; x++){ System.out.ln(x*x); }Para evitar tal erro, você pode usar o sinal <=. Usar o sinal de menor ou igual a é mais intuitivo e, portanto, é menos provável que você confunda suas operações relacionais.
Outro erro lógico comum é omitir as duas chaves de uma instrução de controle e, ainda assim, o corpo abaixo formar um bloco de código que está sob seu controle.
Veja o exemplo abaixo. Ele verifica se um número aleatório é ímpar ou par e, em seguida, imprime uma saída.
import java.util.Random;
public class OddEven{
public static void main(String[] args) {
Random numberGenerator = new Random();
int randomNumber = numberGenerator.nextInt(10);
if ((randomNumber%2)==0)
System.out.println("Here is your lucky number :" + randomNumber);
System.out.println("The number "+ randomNumber +" that you got is even"); // line 11
}
}Observe a linha 11. Ela sempre será executada independentemente de o número aleatório que você obteve ser par. É claro que isso seria logicamente errado quando o número obtido for ímpar.
Incluir as duas instruções System.out.println entre colchetes {} teria evitado isso.
Outro erro lógico a ser observado é não fornecer uma condição de encerramento do loop. Isso resultará em um loop infinito e seu programa nunca terminará a execução.
3. Erros de sintaxe ou de tempo de compilação
Esses são erros causados por violações das regras da linguagem Java. Eles também são chamados de erros de compilação ou de tempo de compilação.
Esses são os erros mais fáceis de lidar porque seu compilador sempre os relatará. Muitos compiladores vão em frente e informam a linha em seu código em que o erro está.
Tolerância ao erro
Uma maneira prática de lidar com problemas de software é empregar tolerância a falhas, incluindo tratamento de exceções. Você pode usar instruções try..catch para fazer isso.
Para continuar com a execução do programa independentemente da exceção capturada no bloco catch , use a instrução finally .
A sintaxe é:
try{ // Block to execute if there are no issues }
catch (Exception e){
// Block to handle issues found
}finally{ // Block to execute after catch
}Veja o exemplo de código abaixo:
import java.util.Random;
public class RandomNumbers{
public static void main(String[] args) {
Random numberGenerator = new Random();
try{
for (int counter = 10; counter<=100; counter++){
int randomNumber = numberGenerator.nextInt(10);
System.out.println(counter/randomNumber); } }
catch(Exception e){
System.out.println("Division by zero encountered!");
}
finally{
System.out.println("Infinite value got");}
}
}O programa acima gera um número aleatório entre zero e 10 e, em seguida, usa esse número para dividir um valor do contador entre 10 e 100. Se a divisão por zero for encontrada, o sistema detecta o erro e exibe uma mensagem.
Melhore a codificação
É uma boa prática adicionar comentários ao seu código. Isso o ajudará a vasculhar facilmente seus arquivos quando houver um bug. Uma etapa pequena, mas muito importante para o desenvolvimento de práticas de codificação sólidas.
Com boas práticas de codificação, você deve ser capaz de evitar erros de programação comuns.
