[JAVA] La déclaration While n'est-elle pas mauvaise?

Qu'en est-il de la déclaration While?

Peut-être que presque tous les langages de programmation ont une déclaration «while», et quiconque a touché à un programme l'aura entendu ou vu.

Vérifions ce qu'est l'instruction while.

while (condition) { En traitement }

Ça ressemble à ça

Le point à noter ici est que l'instruction while continue la boucle tant que la condition est vraie. En d'autres termes, lorsqu'il devient faux, il s'échappe de la boucle.

Est-ce vrai? Est-ce une déclaration de temps? Vous penseriez seulement. Jetons un coup d'oeil à quelques programmes de ceci.

Commençons par un programme simple

Code1.java

public class Code1{
    public static void main(String[]args){
      int num = 0;

      while(num++ < 5){
        System.out.println(num);
        
      }  
 
    }
}

*** C'est une phrase pour, n'est-ce pas? ?? ?? ?? *** ***

Oui, un tel programme peut être une instruction for.

Ensuite, il y a un autre endroit pour jouer un rôle actif

Jetons un coup d'œil à ce programme.

Code2.java

import java.util.Scanner;
public class Code2{
    public static void main(String[]args){
      Scanner sc = new Scanner(System.in);
      int num = sc.nextInt();
      while(num != 0){
        System.out.println("Boucle jusqu'à ce que vous appuyiez sur 0");
        num = sc.nextInt();
      }
      System.out.println("Fin");
    }
}

Ce n'est pas beau parce que le premier processus est écrit à l'extérieur, alors réécrivons-le comme do-while.

Code3.java

import java.util.Scanner;
public class Code3{
    public static void main(String[]args){
      Scanner sc = new Scanner(System.in);
      int num;
      do{
        System.out.println("Boucle jusqu'à ce que vous appuyiez sur 0");
        num = sc.nextInt();
      }while(num != 0);
      System.out.println("Fin");
    }
}

C'est mieux qu'avant, mais les instructions do-while ont tendance à faire beaucoup d'erreurs, comme la nécessité d'un [;] après un certain temps.

Et, afin de réaliser la condition de fin lorsque num devient 0, l'instruction while boucle pendant que la condition est vraie, donc quand elle devient ~ ~, elle est incompatible avec la fin, et dans ce cas num! = Il doit s'agir d'une condition qui refuse la condition à laquelle vous souhaitez terminer dans ce cas, telle que 0 ou! (Num == 0).

*** L'extrême d'une complexité écrasante! !! !! !! !! !! !! !! !! !! *** ***

Alors que dois-je faire? ** "break in infinite loop with if statement" ** Réécrivons-le en "cassant la boucle infinie avec l'instruction if".

Code４.java

import java.util.Scanner;
public class Code4{
    public static void main(String[]args){
      Scanner sc = new Scanner(System.in);
      int num;
      while(true){
        System.out.println("Boucle jusqu'à ce que vous appuyiez sur 0");
        num = sc.nextInt();

        if(num == 0) break;
      }
      System.out.println("Fin");
    }
}

N'est-il pas plus facile de comprendre visuellement les conditions de sortie de la boucle qu'avant? Regardons le cas où la condition de boucle est simplement compliquée, au lieu du modèle comme celui-ci.

Code5.java

import java.util.Scanner;
public class Code5{
    public static void main(String[]args){
      Scanner sc = new Scanner(System.in);
      int a = 0,b = 0,c = 0,count = 0;

      System.out.print("Veuillez saisir un entier:");
      a = sc.nextInt();
      System.out.print("Veuillez saisir un entier:");
      b = sc.nextInt();
      System.out.print("Veuillez saisir un entier:");
      c = sc.nextInt();
      while(a*b>c*c){
        // （a*b est c*Se termine lorsque (supérieur à c) devient faux
        System.out.print("Veuillez saisir un entier:");
        a = sc.nextInt();
        System.out.print("Veuillez saisir un entier:");
        b = sc.nextInt();
        System.out.print("Veuillez saisir un entier:");
        System.out.println("==========================");
        c = sc.nextInt();
        count ++;
      }
      System.out.printf("Jusqu'à la fin%d fois",count);
    }
}

Il s'agit d'un programme qui entre trois entiers et affiche combien de fois a est inférieur à b ou c est inférieur à a ou a est inférieur à 0 boucles pour true en quittant la boucle.

Code6.java

import java.util.Scanner;
public class Code6{
    public static void main(String[]args){
      Scanner sc = new Scanner(System.in);
      int a = 0,b = 0,c = 0,count = 0;

      while(true){
        System.out.print("Veuillez saisir un entier:");
        a = sc.nextInt();
        System.out.print("Veuillez saisir un entier:");
        b = sc.nextInt();
        System.out.print("Veuillez saisir un entier:");
        System.out.println("==========================");
        c = sc.nextInt();
        count ++;
        //a*b est c*Se termine en dessous de c
        if(a*b <= c*c) break;
      }
      System.out.printf("Jusqu'à la fin%d fois",count);
    }
}

Lorsqu'il y a plusieurs conditions comme ces deux programmes et que cela devient une condition compliquée, elle s'échappe de la boucle lorsque toutes ne sont pas satisfaites. Lors d'une boucle dans des conditions aussi compliquées, il sera plus lisible de se terminer lorsque le code 6 devient vrai que lorsque le code 5 devient faux.

Résumé

Plus la condition de boucle de l'instruction while devient compliquée, moins l'instruction while de l'échappement de boucle devient lisible. S'il s'agit d'une rupture de l'instruction if dans une boucle infinie, elle peut être interrompue lorsqu'elle devient vraie, on peut donc dire qu'elle est excellente en lisibilité. De plus, il peut remplacer l'instruction while ou l'instruction do-while à la position où l'instruction if est placée. De plus, si vous le mettez au milieu, le fonctionnement de ~ ~ est garanti une fois (do-while), et selon les conditions, même un processus un peu délicat comme ne jamais l'exécuter peut être facilement mis en œuvre.

Conclusion

*** Briser la boucle infinie avec l'instruction if This! *** ***