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á em execução (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.

Relacionado: Erros de programação e codificação mais comuns

Você pode acabar escrevendo o código abaixo em seu loop for, que fornece apenas os primeiros quatro desses números.

para (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, será 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. Aleatório;
public class OddEven {
public static void main (String [] args) {
Gerador de número aleatório = novo Random ();
int randomNumber = numberGenerator.nextInt (10);
if ((randomNumber% 2) == 0)
System.out.println ("Aqui está seu número da sorte:" + randomNumber);
System.out.println ("O número" + randomNumber + "que você obteve é ​​par"); // linha 11
}
}

Observe a linha 11. Ele sempre será executado, 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.

Incluindo ambos System.out.println declarações entre colchetes {}, teriam evitado isso.

Relacionado: Etapas de desenvolvimento de software que todos os programadores devem saber

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 try..catch declarações para conseguir isso.

Para continuar com a execução do programa, independentemente da exceção capturada no pega bloco, use o finalmente demonstração.

A sintaxe é:

tente {// Bloco para executar se não houver problemas} 
catch (Exceção e) {
// Bloco para lidar com problemas encontrados
} finalmente {// Bloco para executar após captura
}

Veja o exemplo de código abaixo:

import java.util. Aleatório;
public class RandomNumbers {
public static void main (String [] args) {
Gerador de número aleatório = novo Random ();
tentar{
para (contador interno = 10; contador <= 100; counter ++) {
int randomNumber = numberGenerator.nextInt (10);
System.out.println (contador / randomNumber); } }
catch (Exceção e) {
System.out.println ("Divisão por zero encontrada!");
}
finalmente{
System.out.println ("Valor infinito obtido");}
}
}

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 fortes.

Com boas práticas de codificação, você deve ser capaz de evitar erros de programação comuns.

O que é codificação e como funciona?

Ficou confuso com a codificação? Não entende o script? Aqui está o que você precisa saber sobre os blocos de construção da programação.

Leia a seguir

Sobre o autor

Expandir para ler a história completa