Uma instrução de código inacessível é um problema comum entre iniciantes em Java. Muitos desenvolvedores novatos confundem o erro com “código morto” - outro fenômeno relacionado ao Java. Embora os dois sejam semelhantes por manifestação, existem algumas diferenças que abordaremos neste post. Além disso, você descobrirá quais são os motivos mais comuns para o seu compilador retornar uma declaração de código inacessível e descobrirá algumas correções fáceis para colocar seu código em funcionamento novamente.
O que é código inacessível?
Por definição, uma instrução inacessível é aquela que não será executada por um compilador quando você executar um código pronto para implantação. Uma instrução de retorno de código inacessível geralmente é um sinal de erro lógico dentro do programa. Embora existam várias razões pelas quais você acaba com tal declaração, em todos os casos, o código inacessível é redundante, desordena seu programa e deve ser evitado a todo custo.
Código Inacessível vs Código Morto
Na comunidade de desenvolvimento, os conceitos de código “inalcançável” e “morto” são praticamente sinônimos. No entanto, se você for minucioso ao ler a documentação, poderá ver que as diretrizes de desenvolvimento geralmente mencionam os dois separadamente. Existe alguma diferença entre código morto e inacessível? Basicamente, a distinção entre os dois erros está na forma como o compilador reage a eles. Se o código inserido no compilador estiver inacessível , você receberá um erro de tempo de execução de compilação na notificação Java. Se sua declaração for “ código morto ”, não haverá erros de tempo de execução - um desenvolvedor receberá o seguinte aviso do sistema:
class DeadCode {
void deadcode_Method(boolean b) {
System.out.println("Reachable statement");
if(true) {
return;
}
System.out.println("Unreachable statement"); // dead code
}
}
Como não há erro direto do compilador no caso de código morto, é mais difícil detectá-lo. No entanto, se você acompanhar cuidadosamente os retornos de System.out.printIn , detectar código morto não deve causar problemas.
Por que você obtém declarações de código inacessíveis
A boa notícia é que é fácil rastrear a causa de problemas de código inacessível. Existem três razões principais pelas quais seu compilador continua retornando erros:
Declarações de transferência. Se você quebrar seu código com uma instrução return, nada após “return = true” será executado.
Loop infinito - nenhum código que você escreveu após o loop infinito será executado, pois o sistema continuará reiterando a ação do loop. Assim, ao converter seu código em byte code, o compilador enviará um erro de código inacessível.
Para ajudá-lo a sinalizar e corrigir esses problemas, vamos ampliá-los.
Declarações de retorno
Uma instrução return faz parte do grupo de palavras-chave Transfer, o que significa que encerra seu método. É útil para separar funções e ajuda a manter seu código legível e limpo. No entanto, como você não pode adicionar novas instruções à função após return = true, tentar continuar a função após a palavra-chave resultará em um erro de compilador de “código inacessível”. Vamos dar uma olhada em um exemplo de manipulação incorreta de “return = true” e a maneira como um compilador reage a isso.
class GFG {
public static void main(String args[])
{
System.out.println("My code will run");
return;
// ironically, this code will never run
// here’s an unreachable code message a developer gets.
System.out.println("My code will run");
}
}
Veja como um uso indevido da instrução return será exibido no compilador:
Para reforçar o que você aprendeu, sugerimos que você assista a uma vídeo aula do nosso Curso de Java
Declarações de quebra
As instruções break são outro tipo de palavras-chave com as quais você precisa ter cuidado ao escrever funções Java. Pela definição, a palavra-chave break é usada para encerrar um loop. No exemplo abaixo, conforme um desenvolvedor sai do loop, ele não conseguirá mais executar a instrução da linha 8 - assim, o compilador apresentará um erro de instrução inacessível. Aqui está o código de amostra que resultará em uma declaração de código inacessível:
public class JavaCodeGeeks
{
public static void main(String[] args) {
for(int i=1;i<5;i++)
{
System.out.println(i);
break;
System.out.println("Code after break");
}
}
}
Observando o erro do ponto de vista do compilador, você obterá a seguinte declaração de erro.
Continue é uma palavra-chave de controle de loop usada para reiterar ações. Sempre que você quiser que a execução de um loop comece do zero por conta própria, adicione continue ao seu código. A instrução é útil para ajudar os desenvolvedores a escolher quais instruções do loop desejam reiterar e quais não colocariam na iteração. Embora continue seja uma palavra-chave simples de usar, não ter um entendimento completo de como funciona leva os desenvolvedores à armadilha do “código inacessível”. Como, após encontrar um continue, um sistema reiterará o loop, a palavra-chave não será capaz de alcançar as instruções que a seguem. Digamos que você tenha o seguinte código:
public class JavaIsFun
{
public static void main(String[] args) {
for(int i=0;i<8;i++)
{
System.out.println(i);
if(i==5)
{
continue;
System.out.println("Coding after continue");
}
}
}
}
O sistema não executará sua instrução "Codificação após continuar" - o compilador informará você imediatamente.
JavaIsFun.java:10: error: unreachable statement
System.out.println("Coding after continue");
Loops infinitos
Um cenário semelhante aos exemplos de casos de uso das palavras-chave “break” e “continue” é o de um loop infinito. Ao projetar um loop infinito, o desenvolvedor deve se lembrar de que nenhuma instrução após ele será executada. Assim, se você não interromper o loop, todo o código escrito depois ficará inacessível. Aqui está um exemplo interessante de manipulação incorreta de loop infinito para verificar:
public class JavaCodeGym
{
public static void main(String[] args) {
while(true)
{
System.out.println("Hey there");
}
System.out.println("Nice to see you");
}
}
Você consegue adivinhar onde o erro está escondido? O compilador apontará para ele imediatamente assim que você executar seu código:
//unreachable code statement compiler error
JavaCodeGym.java:10: error: unreachable statement
System.out.println("Nice to see you");
‘
Como há um loop infinito antes de "Prazer em ver você" , a instrução nunca será executada e continuará retornando um erro de código inacessível.
Conclusão
Para evitar código inacessível, você precisa garantir que haja um fluxo para todas as instruções do sistema. A maioria dos problemas de código inacessível do Java tem a ver com o manuseio de palavras-chave e o gerenciamento inadequado de loops. No final do dia, verificar novamente seu código é a única maneira comprovada de evitar erros de código inacessíveis. Você também não deve ser desencorajado por eles - o hábito de criar um código Java fluido vem com anos de experiência e prática. Então, vamos acessar o IDE e começar a criar produtos de software incríveis.
GO TO FULL VERSION