Erreur de code de déclaration inaccessible en Java

Une instruction de code inaccessible est un problème courant chez les débutants en Java. De nombreux développeurs novices confondent l'erreur avec du "code mort" - un autre phénomène lié à Java. Bien que les deux soient similaires par leur manifestation, il existe certaines différences que nous aborderons dans cet article. En dehors de cela, vous découvrirez quelles sont les raisons les plus courantes pour lesquelles votre compilateur renvoie une instruction de code inaccessible et découvrirez quelques solutions simples pour remettre votre code en marche.

Qu'est-ce qu'un code inaccessible ?

Par définition, une instruction inaccessible est celle qui ne sera pas exécutée par un compilateur lorsque vous exécuterez du code prêt à déployer. Une instruction de retour de code inaccessible est généralement le signe d'une erreur logique dans le programme. Bien qu'il y ait plusieurs raisons pour lesquelles vous vous retrouvez avec une telle déclaration, dans tous les cas, le code inaccessible est redondant, encombre votre programme et doit être évité à tout prix.

Code inaccessible vs code mort

Dans la communauté du développement, les concepts de code « inaccessible » et « mort » sont pratiquement synonymes. Cependant, si vous êtes pointilleux lors de la lecture de la documentation, vous constaterez peut-être que les directives de développement mentionnent souvent les deux séparément. Y a-t-il une différence entre le code mort et inaccessible ? Fondamentalement, la distinction entre les deux erreurs réside dans la manière dont le compilateur y réagit. Si le code que vous entrez dans le compilateur est inaccessible , vous obtiendrez une erreur d'exécution de compilation dans la notification Java. Si votre déclaration est " code mort ", il n'y aura pas d'erreurs d'exécution - un développeur recevra l'avertissement système suivant :

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

Puisqu'il n'y a pas d'erreur directe du compilateur dans le cas d'un code mort, il est plus difficile à détecter. Cependant, si vous suivez attentivement les retours de System.out.printIn , la capture de code mort ne devrait pas vous causer de problèmes.

Pourquoi vous obtenez des instructions de code inaccessibles

La bonne nouvelle est qu'il est facile de retracer la cause des problèmes de code inaccessibles. Il y a trois raisons principales pour lesquelles votre compilateur continue de renvoyer des erreurs :

Déclarations de transfert. Si vous cassez votre code avec une instruction return, rien après « return = true » ne sera exécuté.
Boucle infinie - aucun code que vous avez écrit après la boucle infinie ne sera exécuté non plus puisque le système continuera à répéter l'action de boucle. Ainsi, lors de la conversion de votre code en byte code, le compilateur enverra une erreur de code inaccessible.

Pour vous aider à signaler et à résoudre ces problèmes, zoomons dessus.

Déclarations de retour

Une instruction return fait partie du groupe de mots clés Transfer, ce qui signifie qu'elle met fin à votre méthode. Il est utile pour séparer les fonctions et aide à garder votre code lisible et propre. Cependant, puisque vous ne pouvez pas ajouter de nouvelles instructions à la fonction après return = true, essayer de continuer la fonction après le mot-clé vous donnera une erreur de compilation "Code inaccessible". Jetons un coup d'œil à un exemple de mauvaise manipulation "retour = vrai" et à la façon dont un compilateur y réagit.

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

Voici comment une mauvaise utilisation de l'instruction return sera affichée dans le compilateur :

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

Pour renforcer ce que vous avez appris, nous vous suggérons de regarder une leçon vidéo de notre cours Java

Déclarations de rupture

Les instructions break sont un autre type de mots-clés auxquels vous devez faire attention lorsque vous écrivez des fonctions Java. Par définition, le mot-clé break est utilisé pour terminer une boucle. Dans l'exemple ci-dessous, lorsqu'un développeur quitte la boucle, il ne pourra plus exécuter l'instruction à la ligne 8 - ainsi, le compilateur affichera une erreur d'instruction inaccessible. Voici l'exemple de code qui se traduira par une instruction de code inaccessible :

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

En regardant l'erreur du point de vue du compilateur, vous obtiendrez l'instruction d'erreur suivante.

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

Continuer les déclarations

Continue est un mot-clé de contrôle de boucle utilisé pour réitérer les actions. Chaque fois que vous souhaitez que l'exécution d'une boucle reparte de zéro, ajoutez continue à votre code. L'instruction est utile pour aider les développeurs à choisir les instructions de la boucle qu'ils souhaitent réitérer et celles qu'ils ne mettraient pas dans l'itération. Bien que continue soit un mot-clé simple à utiliser, le fait de ne pas bien comprendre son fonctionnement conduit les développeurs au piège du « code inaccessible ». Comme, après avoir rencontré un continue, un système réitèrera la boucle, le mot-clé ne pourra pas atteindre les instructions qui le suivent. Dis, tu as le code suivant :

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

Le système n'exécutera pas votre instruction "Coding after continue" - le compilateur vous en informera immédiatement.

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

Boucles infinies

Un scénario similaire aux exemples de cas d'utilisation des mots-clés « break » et « continue » est celui d'une boucle infinie. Lors de la conception d'une boucle infinie, un développeur doit se rappeler qu'aucune instruction après elle ne sera jamais exécutée. Ainsi, si vous ne cassez pas la boucle, tout le code écrit après sera inaccessible. Voici un exemple intéressant de mauvaise gestion de la boucle infinie à vérifier :

public class JavaCodeGym
{
    public static void main(String[] args) {
        while(true)
        {
            System.out.println("Hey there");
        }
        System.out.println("Nice to see you");
    }
}

Pouvez-vous deviner où se cache l'erreur ? Le compilateur le pointera immédiatement une fois que vous aurez exécuté votre code :

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

Puisqu'il y a une boucle infinie avant "Nice to see you" , l'instruction ne s'exécutera jamais et continuera à renvoyer une erreur de code inaccessible.

Conclusion

Pour éviter un code inaccessible, vous devez vous assurer qu'il existe un flux vers toutes vos instructions système. La plupart des problèmes de code Java inaccessibles sont liés à la gestion des mots-clés et à la mauvaise gestion des boucles. En fin de compte, revérifier votre code est le seul moyen éprouvé d'éviter les erreurs de code inaccessibles. Vous ne devriez pas non plus être découragé par eux - l'habitude de créer du code Java fluide vient avec des années d'expérience et de pratique. Alors, passons à l'IDE et commençons à créer des produits logiciels géniaux.