Java

Instructions de contrôle de boucle - break, continue

Java prend en charge trois instructions de saut: break, continue et return. Ces trois déclarations transfèrent le contrôle à une autre partie du programme.

Instruction break

L’instruction break en langage de programmation Java a les trois utilisations suivantes:

  •   Lorsque l'instruction break est rencontrée à l'intérieur d'une boucle, celle-ci est immédiatement terminée et le contrôle du programme reprend à l'instruction suivante qui suit la boucle.
  •   Il peut être utilisé pour mettre fin à un cas dans l'instruction switch
  •   Utilisée comme une forme de goto.

L'instruction break est presque toujours utilisée avec l'instruction if ... else à l'intérieur de la boucle.

 Rappelez-vous toujours que l'instruction break, lorsqu'elle est rencontrée, sort de la boucle, mais lorsque l'instruction continue est rencontrée, la boucle n'est pas terminée, mais le contrôle est passé au début de la boucle.
Exemple 1 - switch
                                public class Test{
                                    public static void main(String args[]){
                                        int jour=3;

                                        switch(jour){
                                            case 1 : {
                                                    System.out.println("Lundi"); 
                                                    break;
                                                }
                                            case 2 : {
                                                    System.out.println("Mardi"); 
                                                    break;
                                                }
                                            case 3 : {
                                                    System.out.println("Mercredi"); 
                                                    break;
                                                }
                                            case 4 : {
                                                    System.out.println("Jeudi"); 
                                                    break;
                                                }
                                            case 5 : {
                                                    System.out.println("Vendredi"); 
                                                    break;
                                                }
                                            case 6 : {
                                                    System.out.println("Samedi"); 
                                                    break;
                                                }
                                            case 7 : {
                                                    System.out.println("dimanche"); 
                                                    break;
                                                }
                                            default: System.out.println("jour invalide");
                                        }
                                    }
                                }
                            
Exemple 2 : boucle
                                public class Test{

                                    public static void main(String args[]){

                                        for(int i=0;i < 5;i++){
                                            if(i==3){
                                                break;
                                            }
                                            System.out.println("i = " + i);
                                        }
                                    }
                                }
                            
i = 0
i = 1
i = 2

Java n'a pas d'instruction goto car elle fournit un moyen de créer des branches de manière arbitraire et non structurée. Java utilise l'étiquette. Une étiquette est utilisée pour identifier un bloc de code.

Syntaxe :
                                label:{
                                    //instructions
                                }
                            

Vous pouvez maintenant utiliser l'instruction break pour sortir du bloc cible.
vous ne pouvez pas vous connecter à une étiquette(label) non définie pour un bloc englobant.

Exemple 3 : goto
                                public class Test {

                                    public static void main(String args[]) {
                                        int i = 4;
                                        bloc1: {
                                            bloc2: {
                                                System.out.println("debut bloc 2");
                                                if (i == 4) {
                                                    break bloc1;
                                                }
                                                System.out.println("fin du bloc 2");
                                            }
                                            System.out.println("fin du bloc 1");
                                        }
                                        System.out.println("fin");
                                    }
                                }
                            
debut bloc 2
fin
La déclaration de break dans une boucle imbriquée

Lorsque l'instruction break est utilisée à l'intérieur d'une boucle imbriquée, elle ne provoque la sortie que de la boucle la plus interne.

Exemple 4 :
                                public class Test {

                                    public static void main(String args[]) {
                                    
                                        for (int i = 0; i < 3; i++) {
                                            for (int j = 0; j < 2; j++) {
                                                if (j == 1) {
                                                    break;
                                                }
                                                System.out.println("j= " + j);
                                            }
                                            System.out.println("i= " + i);
                                        }
                                    }
                                }
                            
j= 0
i= 0
j= 0
i= 1
j= 0
i= 2

Instruction continue

L'instruction continue ignore l'itération actuelle de la boucle et continue à l'itération suivante.
Lorsque l'instruction continue est rencontré dans une boucle, toutes les déclarations après l'instruction continue sont omis et la boucle continue avec la prochaine itération.

Exemple 5 :
                                public class Test {

                                    public static void main(String args[]) {
                                        int i;
                                        for (i = 0; i < 5; i++) {
                                            if (i == 2) {
                                                continue;
                                            }
                                            System.out.println("i= " + i);
                                        }
                                    }
                                }
                            
i= 0
i= 1
i= 3
i= 4

Instruction return

L'instruction return est utilisée pour renvoyer explicitement à partir d'une méthode. Autrement dit, un contrôle de programme est renvoyé à l'appelant de la méthode.

Exemple 6 :
                                public class Test {

                                    public static void main(String args[]) {
                                        int i = 2;
                                    
                                        if (i == 2) {
                                            System.out.println("say good bye");
                                            return;
                                        }
                                    
                                        System.out.println(" Good bye ");
                                    
                                    }
                                }
                            
say good bye

Partager ce cours avec tes amis :

Rédigé par M. ESSADDOUKI

Learning a new programming language is an easy thing, but the most difficult thing is how to design efficient algorithms for real-world problems, so don't be a programmer, be a problems solver.

Cours Similaires :