Java à partir du débutant, imbriqué / break / continue

introduction

Cet article est un mémorandum. Bien qu'il s'agisse d'un contenu de niveau de référence, le code à publier dans cet article est ** Mauvais ** sont les choses principales. C'est dans le but de publier la partie qui s'est réellement trompée lors du codage et de la publier pour une réflexion personnelle. De plus, je n'aborderai pas la partie profonde ici parce que je vais l'examiner plus tard tout en étudiant les questions d'examen Java Silver.

environnement

Langue: Java11, JDK13.0.2 Environnement d'exploitation: Windows 10

Imbriqué

Avez-vous déjà vu une poupée Matriochka? C'est une pile de nombreux objets similaires de différentes tailles. L'imbrication traitée ici est ** l'imbrication des structures de contrôle **. Instruction ʻIf for`` while`. La structure de commande est également incluse dans le traitement, et elle convient pour effectuer un traitement hiérarchique tel qu'une double boucle et une triple boucle.

break J'ai mentionné le break lui-même dans l'instruction switch, mais si je l'explique après l'imbrication, ce sera " interrompre l'imbrication en cours de traitement et entrer dans la boucle supérieure " .. Même si vous êtes dans une boucle infinie, vous pouvez la quitter si les conditions de l'instruction break sont remplies. Ce qui suit est une citation de la référence ** Kuromoto **

int num = 0; while(true){ num++; if(num == 3){ break; } System.out.println(num); }

continue
 `continue` est souvent confondu avec` break`, mais si **` continue` est fait, le processus itératif ci-dessous` continue` sera complètement ignoré et le message sera transféré à l'instruction de mise à jour **.
 Un exemple de continuer sera ajouté plus tard. Aucun des codes que j'ai créés ne fonctionnait avec une erreur de compilation. La pratique est particulièrement nécessaire.

# Entraine toi
 Regardons un exemple d'échec.


#### **`nestingTwo.java`**
```java

class nestingTwo
{
    public static void main(String[] args)
    {
        int forLoop = 0;
        int whileLoop = 0;
        //Le nombre total doit être 9

            for(; forLoop < 3; forLoop++){
                while(whileLoop < 3){
                    whileLoop++;    
                }
            }
        System.out.println("Le processus est terminé.");
        System.out.println("Le résultat final est l'instruction for" + forLoop + "Time, While déclaration" + whileLoop + "C'était un temps."); 
        }
            
    }



/*Le processus est terminé.
Le résultat final était de 3 pour les déclarations et de 3 déclarations While, pour un total de 3 fois.*/

whileLoop satisfait la condition une fois qu'il devient 3 dans l'imbrication de for, et le for n'a été tourné qu'une seule fois et aucun changement n'a été fait depuis lors. Cette fois, pour faire du nombre de for x le nombre de while.

after

(réduction)
        int totalCounter = 0;
        //Le nombre total doit être 9
        int whileLoopTemporary =0;
        
            for(; forLoop < 3; forLoop++){
                while(whileLoop < 3){
                    whileLoop++;    
                    totalCounter++;
                    whileLoopTemporary = whileLoop;
                }
                whileLoop = 0;
            }
        System.out.println("Le processus est terminé.");
        System.out.println("Le résultat final est l'instruction for" + forLoop + "Time, While déclaration" + whileLoopTemporary + "Temps, au total" + totalCounter + "C'était du temps."); 
        }
            
    }

Un «whileLoopTemporary» est créé et remplacé pour libérer le nombre de rotations accumulées pendant le while, puis initialisé à «0» dans l'instruction for. Il doit y avoir une manière plus intelligente.

À la fin

Il semble y avoir un mécanisme appelé étiquette qui transfère le contrôle au ** traitement étiqueté **, mais il est omis ici. Est-ce la même chose que le «aller à» que j'ai vu quelque part?

référence

J'écris et compile des variables et des expressions par moi-même autant que possible, donc si je veux les citer complètement, je vais les décrire.

Easy Java 7ème édition Java SE11 Silver Problem Collection (communément appelé Kuromoto)