[JAVA] Ist die While-Aussage nicht böse?

Was ist mit der While-Anweisung?

Vielleicht hat fast jede Programmiersprache eine while-Anweisung, und jeder, der ein Programm berührt hat, hat es gehört oder gesehen.

Lassen Sie uns überprüfen, was die while-Anweisung ist.

while (Bedingung) { wird bearbeitet }

Es sieht aus wie das

Hierbei ist zu beachten, dass die while-Anweisung die Schleife fortsetzt, solange die Bedingung erfüllt ist. Mit anderen Worten, wenn es falsch wird, entweicht es aus der Schleife.

Ist das so? Ist das eine Weile Aussage? Du würdest nur denken. Schauen wir uns einige Programme an.

Beginnen wir mit einem einfachen Programm

Code1.java

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

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

*** Es ist ein Satz, nicht wahr? ?? ?? ?? *** ***

Ja, ein solches Programm kann eine for-Anweisung sein.

Dann gibt es einen anderen Ort, an dem Sie eine aktive Rolle spielen können

Werfen wir einen Blick auf dieses Programm.

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("Schleife, bis Sie 0 drücken");
        num = sc.nextInt();
      }
      System.out.println("Ende");
    }
}

Dies ist nicht schön, da der erste Prozess außerhalb geschrieben wird. Schreiben wir ihn also als "do-while" um.

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("Schleife, bis Sie 0 drücken");
        num = sc.nextInt();
      }while(num != 0);
      System.out.println("Ende");
    }
}

Dies ist besser als zuvor, aber Do-While-Anweisungen neigen dazu, viele Fehler zu machen, z. B. die Notwendigkeit eines [;] nach der Weile.

Und um die Bedingung des Endens zu realisieren, wenn num 0 wird, wird die while-Anweisung wiederholt, während die Bedingung wahr ist. Wenn sie also ~ ~ wird, ist sie mit dem Ende nicht kompatibel, und in diesem Fall num! = Es muss eine Bedingung sein, die die Bedingung ablehnt, die Sie in diesem Fall beenden möchten, z. B. 0 oder! (Num == 0).

*** Das Extrem überwältigender Komplexität! !! !! !! !! !! !! !! !! !! *** ***

Was soll ich dann tun? ** "Unterbrechung der Endlosschleife mit if-Anweisung" ** Schreiben wir es neu, indem wir "Endlosschleife mit if-Anweisung unterbrechen".

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("Schleife, bis Sie 0 drücken");
        num = sc.nextInt();

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

Ist es nicht einfacher als zuvor, die Bedingungen für das visuelle Entkommen aus der Schleife zu verstehen? Schauen wir uns den Fall an, in dem die Schleifenbedingung einfach kompliziert ist, anstatt des Musters wie dieses Do-While.

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("Bitte geben Sie eine Ganzzahl ein:");
      a = sc.nextInt();
      System.out.print("Bitte geben Sie eine Ganzzahl ein:");
      b = sc.nextInt();
      System.out.print("Bitte geben Sie eine Ganzzahl ein:");
      c = sc.nextInt();
      while(a*b>c*c){
        // （a*b ist c*Endet, wenn (größer als c) falsch wird
        System.out.print("Bitte geben Sie eine Ganzzahl ein:");
        a = sc.nextInt();
        System.out.print("Bitte geben Sie eine Ganzzahl ein:");
        b = sc.nextInt();
        System.out.print("Bitte geben Sie eine Ganzzahl ein:");
        System.out.println("==========================");
        c = sc.nextInt();
        count ++;
      }
      System.out.printf("Bis zum Ende%d mal",count);
    }
}

Dies ist ein Programm, das drei Ganzzahlen eingibt und anzeigt, wie oft die Bedingung, bei der a kleiner als b oder c kleiner als a oder a ist, kleiner als 0 ist. Schleifen für true und Schleifen aus der Schleife.

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("Bitte geben Sie eine Ganzzahl ein:");
        a = sc.nextInt();
        System.out.print("Bitte geben Sie eine Ganzzahl ein:");
        b = sc.nextInt();
        System.out.print("Bitte geben Sie eine Ganzzahl ein:");
        System.out.println("==========================");
        c = sc.nextInt();
        count ++;
        //a*b ist c*Endet unter c
        if(a*b <= c*c) break;
      }
      System.out.printf("Bis zum Ende%d mal",count);
    }
}

Wenn es mehrere Bedingungen wie diese beiden Programme gibt und es zu einer komplizierten Bedingung wird, entweicht es aus der Schleife, wenn nicht alle erfüllt sind. Bei einer Schleife unter solch komplizierten Bedingungen ist es besser lesbar, zu beenden, wenn Code 6 wahr wird, als wenn Code 5 falsch wird.

Zusammenfassung

Je komplizierter die Schleifenbedingung der while-Anweisung wird, desto weniger lesbar wird die while-Anweisung der Schleifenflucht. Wenn es sich um eine Unterbrechung der if-Anweisung in einer Endlosschleife handelt, kann sie beendet werden, wenn sie wahr wird. Man kann also sagen, dass sie eine hervorragende Lesbarkeit aufweist. Darüber hinaus kann an der Stelle, an der die if-Anweisung platziert wird, die while-Anweisung oder die do-while-Anweisung ersetzt werden. Wenn Sie es in die Mitte stellen, ist der Betrieb von ~ ~ einmal (do-while) garantiert, und abhängig von den Bedingungen kann sogar ein etwas kniffliger Prozess, wie z. B. nie ausgeführt zu werden, leicht implementiert werden.

Fazit

*** Unterbrechen Sie die Endlosschleife mit der if-Anweisung This! *** ***