Error de código de declaración inalcanzable en Java

Una declaración de código inalcanzable es un problema común entre los principiantes de Java. Muchos desarrolladores novatos confunden el error con "código muerto", otro fenómeno relacionado con Java. Aunque los dos son similares por manifestación, hay algunas diferencias que cubriremos en esta publicación. Aparte de eso, descubrirá cuáles son las razones más comunes por las que su compilador devuelve una declaración de código inalcanzable y descubrirá algunas soluciones fáciles para que su código vuelva a funcionar.

¿Qué es el código inalcanzable?

Por definición, una declaración inalcanzable es aquella que no será ejecutada por un compilador cuando ejecute código listo para implementar. Una declaración de devolución de código inalcanzable suele ser un signo de un error lógico dentro del programa. Aunque hay varias razones por las que termina con tal declaración, en todos los casos, el código inalcanzable es redundante, abarrota su programa y debe evitarse a toda costa.

Código inalcanzable vs código muerto

En la comunidad de desarrollo, los conceptos de código “inalcanzable” y “muerto” son prácticamente sinónimos. Sin embargo, si es quisquilloso al leer la documentación, es posible que vea que las pautas de desarrollo a menudo mencionan los dos por separado. ¿Hay alguna diferencia entre código muerto e inalcanzable? Básicamente, la distinción entre los dos errores está en la forma en que el compilador reacciona ante ellos. Si no se puede acceder al código que ingresa en el compilador , obtendrá un error de tiempo de ejecución de compilación en la notificación de Java. Si su declaración es " código muerto ", no habrá errores de tiempo de ejecución; un desarrollador recibirá la siguiente advertencia del sistema:

class DeadCode {
    void deadcode_Method(boolean b) {
    System.out.println("Reachable statement");
        if(true) {
        return;
        }
    System.out.println("Unreachable statement"); // dead code
    }
}

Dado que no hay un error de compilación directo en el caso de código inactivo, es más difícil de detectar. Sin embargo, si realiza un seguimiento cuidadoso de las devoluciones de System.out.printIn , la captura de código muerto no debería causarle problemas.

Por qué obtiene declaraciones de código inalcanzables

La buena noticia es que es fácil rastrear la causa de los problemas de código inalcanzables. Hay tres razones principales por las que su compilador sigue devolviendo errores:

Transferir declaraciones. Si rompe su código con una declaración de devolución, no se ejecutará nada después de "return = true".
Bucle infinito: no se ejecutará ningún código que haya escrito después del bucle infinito, ya que el sistema seguirá reiterando la acción del bucle. Por lo tanto, al convertir su código en código de bytes, el compilador enviará un error de código inalcanzable.

Para ayudarlo a marcar y solucionar estos problemas, acerquémonos a ellos.

Declaraciones de devolución

Una declaración de devolución es parte del grupo de palabras clave Transfer, lo que significa que finaliza su método. Es útil para separar funciones y ayuda a mantener el código limpio y legible. Sin embargo, dado que no puede agregar nuevas declaraciones a la función después de return = true, intentar continuar con la función después de la palabra clave le dará un error de compilación de "Código inalcanzable". Echemos un vistazo a un ejemplo de mal manejo de "return = true" y la forma en que reacciona un compilador.

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");
    }
}

Así es como se mostrará el uso indebido de una declaración de devolución en el compilador:

prog.java:11: error: unreachable statement
System.out.println(“My code will run”);
^
1 error

Para reforzar lo que aprendió, le sugerimos que vea una lección en video de nuestro Curso de Java

romper declaraciones

Las declaraciones de ruptura son otro tipo de palabras clave con las que debe tener cuidado al escribir funciones Java. Por definición, la palabra clave break se usa para terminar un bucle. En el siguiente ejemplo, cuando un desarrollador sale del bucle, ya no podrá ejecutar la declaración en la línea 8; por lo tanto, el compilador mostrará un error de declaración inalcanzable. Aquí está el código de muestra que dará como resultado una declaración de código inalcanzable:

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");
        }
    }
}

Al observar el error desde el punto de vista del compilador, obtendrá la siguiente declaración de error.

JavaCodeGeeks.java:8: error: unreachable statement
System.out.println("After break");
                ^
1 error

Continuar declaraciones

Continuar es una palabra clave de control de bucle utilizada para reiterar acciones. Siempre que desee que la ejecución de un ciclo comience desde cero por sí solo, agregue continuar a su código. La declaración es útil para ayudar a los desarrolladores a elegir qué declaraciones del ciclo quieren reiterar y cuáles no incluirían en la iteración. Aunque continuar es una palabra clave fácil de usar, no tener una comprensión completa de cómo funciona lleva a los desarrolladores a la trampa del "código inalcanzable". Dado que, después de encontrar una continuación, un sistema reiterará el ciclo, la palabra clave no podrá alcanzar las declaraciones que la siguen. Digamos que tienes el siguiente 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");
            }
        }
    }
}

El sistema no ejecutará su declaración "Codificación después de continuar": el compilador se lo informará de inmediato.

JavaIsFun.java:10: error: unreachable statement
                                System.out.println("Coding after continue");

Bucles infinitos

Un escenario que es similar a los ejemplos de casos de uso de palabras clave "romper" y "continuar" es el de un bucle infinito. Al diseñar un bucle infinito, un desarrollador debe recordar que nunca se ejecutará ninguna instrucción posterior. Por lo tanto, si no rompe el ciclo, todo el código escrito después será inalcanzable. Aquí hay un ejemplo interesante de mal manejo de bucle 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");
    }
}

¿Puedes adivinar dónde se esconde el error? El compilador lo señalará de inmediato una vez que ejecute su código:

//unreachable code statement compiler error
JavaCodeGym.java:10: error: unreachable statement
                System.out.println("Nice to see you");
‘

Dado que hay un bucle infinito antes de "Encantado de verte" , la declaración nunca se ejecutará y seguirá devolviendo un error de código inalcanzable.

Conclusión

Para evitar el código inalcanzable, debe asegurarse de que haya un flujo para todas las declaraciones de su sistema. La mayoría de los problemas de código inalcanzable de Java tienen que ver con el manejo deficiente de palabras clave y bucles. Al final del día, verificar dos veces su código es la única forma comprobada de evitar errores de código inalcanzables. Tampoco debe desanimarse por ellos: el hábito de crear código Java fluido viene con años de experiencia y práctica. Entonces, entremos al IDE y comencemos a construir productos de software asombrosos.