Instruction de rupture en Java

Bonjour à tous les collègues et à ceux simplement intéressés. Aujourd'hui, nous examinerons une fonctionnalité du langage de programmation Java telle que l'opérateur break. Ceci est le premier article sur le thème des opérateurs de transition, donc si vous l'aimez, je serai heureux d'en écrire davantage. Je voudrais tout de suite noter que cet article est principalement destiné aux développeurs débutants, et que les étudiants plus avancés ne trouveront peut-être rien de nouveau pour eux-mêmes ici. Alors allons-y. En Java, il existe 2 façons de modifier l'ordre dans lequel les instructions du programme sont exécutées : les instructions de saut et le mécanisme de gestion des exceptions. Il existe trois opérateurs de saut en Java : break, continue et return. Aujourd'hui, je vous invite à regarder de plus près l'opérateur break. La gestion des exceptions est un sujet si vaste qu’il dépasse le cadre de cet article. Il existe trois façons d'utiliser l'instruction break en Java. La première et la plus populaire consiste à l’utiliser breakpour quitter la boucle plus tôt, par exemple :

public class SimpleExample {
    public static void main(String[] args) {
        findNumberInLoop(3);
    }
    public static void findNumberInLoop(int number){
        for (int i = 0; i < 10; i++) {
            if (i == number) {
                break;
            }
            System.out.println(i);
        }
        System.out.println("cycle was finished");
    }
}

Cet exemple affichera :

1
2
cycle was finished

Cela signifie que lorsque le compteur de boucle idevient égal au paramètre passé number, c'est-à-dire le chiffre 3, l'exécution de la boucle se termine plus tôt. Si le programme comporte plusieurs boucles imbriquées, interrompez uniquement les sorties de la boucle la plus interne, par exemple :

public class SimpleExample {
    public static void main(String[] args) {
        findNumberInLoop(3);
    }
    public static void findNumberInLoop(int number){
        for(int i = 0; i < 5; i++) {
            for (int j =0; j < 10; j++) {
                if(j == number) {
                    break;
                }
                System.out.print(j);
            }
            System.out.println();
        }
        System.out.println("cycles was finished");
    }
}

Cet exemple produit le résultat :

012
012
012
012
012
cycles was finished

Comme le montre l'exemple, la boucle interne est interrompue à chaque fois au chiffre 3 (paramètre number), et la boucle externe est exécutée 5 fois, comme prévu. En Java, vous pouvez utiliser plusieurs instructions break dans une boucle, mais cela n'est pas recommandé, car la lisibilité et la structure du code sont fortement dégradées. La deuxième utilisation breakest de l'utiliser pour interrompre l'exécution des instructions dans les branches switch, par exemple :

public class SimpleExample {
    public static void main(String[] args) {
        square(2);
    }

    public static void square(int number){
        switch (number){
            case 1:
                System.out.println(number*number);
                break;
            case 2:
                System.out.println(number*number);
                break;
            case 3:
                System.out.println(number*number);
                break;
        }
        System.out.println("after switch");
    }
}

L’exécution de cet exemple produira le résultat :

4
after switch

L'instruction break a transmis le contrôle au code suivant l'ensemble du bloc switch. Si vous ne précisez pas breakdans switchcet exemple :

public class SimpleExample {
    public static void main(String[] args) {
        square(2);
    }
    public static void square(int number){
        switch (number){
            case 1:
                System.out.println(number*number);
            case 2:
                System.out.println(number*number);
            case 3:
                System.out.println(number*number);
        }
        System.out.println("after switch");
    }
}

Le résultat ne sera pas comme prévu :

4
4
after switch

Cela s'est produit parce qu'après l'exécution du bloc, case 2le programme a continué à exécuter tous les blocs de cas suivants , ce qui nous a donné le résultat correspondant. Parfois cette fonctionnalité de l'opérateur switch peut nous être bénéfique, par exemple :

public class SimpleExample {
    public static void main(String[] args) {
        compare(2);
        compare(7);
        compare(12);
    }
    public static void compare(int number){
        switch (number){
            case 0:
            case 1:
            case 2:
            case 3:
            case 4:
            case 5:
                System.out.println("number is less than 5 or equal 5");
                break;
            case 6:
            case 7:
            case 8:
            case 9:
                System.out.println("number is greater than 5");
                break;
            default:
                System.out.println("number is less than 0 or greater than 9");
        }
        System.out.println("after switch");
    }
}

Ce programme compare un nombre donné avec le nombre 5 et donne le résultat suivant :

after switch
number is greater than 5
after switch
number is less than 0 or greater than 9
after switch

Lorsqu'une méthode est appelée pour la première fois, l'opérateur switchtransfère le contrôle à l'opérateur case 2puis à l'opérateur breakdans case 5. Le deuxième appel est similaire au premier, mais commence par c case 7. Le troisième appel ne trouve pas de valeur appropriée parmi tous les cas, donc l'opérateur est exécuté default. La troisième façon consiste à utiliser l'opérateur breakau lieu de l' gotoopérateur C. Pour ce faire, nous utiliserons une forme spéciale de l'opérateur breakappelée breakavec une étiquette. Ce formulaire ressemble à break метка;une étiquette - il s'agit généralement de n'importe quel nom approprié de l'espace de noms Java, précédant un bloc de code. De plus, après avoir appliqué ce bloc de code breakavec une étiquette, le code continuera à être exécuté à partir de l'endroit après le bloc avec l'étiquette correspondante, par exemple :

public class SimpleExample {
    public static void main(String[] args) {
        howWeUseLabels(true);
        System.out.println();
        howWeUseLabels(false);
    }
    public static void howWeUseLabels(boolean bool) {
        firstBlock:{
            secondBlock:{
                thirdBlock:{
                    System.out.println("We will see it always");
                    if(bool) {
                        break secondBlock;
                    }
                    System.out.println("We won't see it if bool == true");
                }
                System.out.println("We won't see it if bool == true");
            }
            System.out.println("We will see it always");
        }
    }
}

Cet exemple produira le résultat suivant :

We will see it always
We will see it always

We will see it always
We won't see it if bool == true
We won't see it if bool == true
We will see it always

Après le premier appel de méthode, l'opérateur breaktransfère le contrôle à la fin du bloc secondBlock, en sortant secondBlocket thirdBlock, tout en exécutant un autre opérateur println()à la fin firstBlock. Après le deuxième appel, toutes les lignes s'affichent à l'écran. Les étiquettes peuvent également être utilisées pour indiquer les cycles. Il ne faut pas oublier que vous ne pouvez accéder à une étiquette qu'à l'intérieur du bloc de code indiqué par l'étiquette ; par exemple, un tel code ne sera pas compilé :

public class SimpleExample {
    public static void main(String[] args) {
        label:{
            System.out.println("inside label");
        }
        if(true) {
            break label;
        }
        System.out.println("This is error");
    }
}

Notes sur la propreté du code et des instructions break: Il est généralement conseillé d'utiliser l'instruction breakavec beaucoup de prudence, car son utilisation breakrend la boucle plus difficile à comprendre et oblige le programmeur à regarder à l'intérieur de la boucle pour comprendre les nuances de son fonctionnement. Il existe une règle heuristique que break vous pouvez utiliser avec plus de confiance dans les boucles plus courtes et avec plus de prudence dans les boucles longues et profondément imbriquées, car cela augmente le risque d'erreurs et complique la lecture et la compréhension de votre code par d'autres programmeurs. Comme je l'ai écrit ci-dessus, l'utilisation d'un grand nombre de break.disséminés dans le code indique que le programmeur ne comprend pas complètement pourquoi il a écrit son code de cette façon. Il pourrait être intéressant d’envisager de refactoriser une telle boucle en la divisant en plusieurs boucles plus petites. Essayez d'être prudent lorsque vous utilisez break une étiquette en remplacement de goto, car cela complique la structure du code. C'est tout ce que je voulais vous dire aujourd'hui sur l'opérateur breaken Java. Je serai heureux de recevoir des critiques constructives et je suis également prêt à écrire une suite sur les opérateurs continueet return, si vous êtes intéressé.