Si l'expression conditionnelle est correcte, le processus 1 est exécuté, et si elle est incorrecte, le processus 2 est exécuté.

if(Expression conditionnelle)
Processus 1;
}else{
Processus 2;
}

２．if-else if-else

Si l'expression conditionnelle 1 est correcte, le processus 1 est exécuté, si l'expression conditionnelle 1 est incorrecte et l'expression conditionnelle 2 est correcte, le processus 2 est exécuté et si ni l'expression conditionnelle 1 ni l'expression conditionnelle 2 ne sont correctes, le processus 3 est exécuté.

if(Expression conditionnelle 1){
Processus 1;
}else if(Expression conditionnelle 2){
Processus 2;
} else{
Processus 3;
}

Exemple: Traitement des branches selon l'âge

int age = 25; //Déclarez la variable d'âge et définissez 25 comme valeur initiale
if(age < 18) {//Sortie des mineurs si l'âge est inférieur à 18 ans
     System.out.println("Mineur");
}
else if(age >= 60){ //Sortie des personnes âgées lorsque l'âge est de 60 ans ou plus
     System.out.println("personnes agées");
}else{//Sortie adulte si pas moins de 18 ans ou plus de 60 ans
     System.out.println("Adulte");
}

• Dans cet exemple, l'âge est de 25 ans, donc l'adulte est sorti.

Branche conditionnelle ② instruction switch-case

Il s'agit d'une structure de contrôle qui effectue plusieurs branches en fonction de la valeur de l'expression. Décrivez la valeur dans l'instruction case et déterminez si l'expression et la valeur sont égales. Si aucune des valeurs ne correspond, le processus décrit par défaut est exécuté. Break; est toujours requis après l'instruction case, et si break; n'est pas décrit, même s'il correspond, l'instruction switch ne sera pas quittée et le traitement sera effectué plus que nécessaire. Vous pouvez facilement écrire un programme car vous pouvez créer des branches de plusieurs processus avec une seule instruction switch. Cependant, l'instruction Java switch-case a une limitation selon laquelle la plage de valeurs ne peut pas être spécifiée. Le format est le suivant.

switch(formule){
valeur de cas 1:
Traitement (lorsque le contenu de l'expression correspond à la valeur 1);
　　　　　break; //Sortez de l'instruction switch.
valeur de cas 2:
Traitement (lorsque le contenu de l'expression et la valeur 2 correspondent);
　　　　　break;
　　default:
Traitement (lorsque le contenu de l'expression ne correspond à aucune valeur);
}

Exemple: affichez le résultat à l'aide de l'instruction switchi basée sur la note.

char rank = 'A'; //rank(Grades)Déclarer une variable et initialiser avec «A»

String result; //result(résultat)Déclarer des variables
//Déterminer le rang de variable
switch(rank){
    case 'A': //Si le rang est A
       result = "Yu"; //結果にYuを入れる。
       break;
    case 'B': //Lorsque le rang est B
       result = "Bien"; //結果にBienを入れる。
       break;
    case 'C': //Si le rang est C
       result = "Oui";
       break;
    default: //Un lieu qui n'est ni A ni B ni C
       result = "Impossible"; //結果にImpossibleを入れる。
}
System.out.println("Le résultat est" + result + "est.");//Sorties Yu.

Structure itérative

Le processus spécifié est répété tant que les conditions définies sont remplies pendant le processus. Par exemple, s'il y a une personne qui fait 300 muscles abdominaux par jour, cette personne répète les muscles abdominaux jusqu'à ce que les muscles abdominaux soient terminés 300 fois, et les muscles abdominaux sont entraînés jusqu'à ce que les muscles abdominaux soient complétés 300 fois.

Instruction de contrôle de structure itérative ① (instruction while)

C'est une structure itérative qui répète le même processus pendant que les conditions sont remplies. Le processus est exécuté une fois la condition jugée. Le processus n'est pas exécuté une fois tant que l'expression conditionnelle n'est pas satisfaite. Le format et l'exemple sont les suivants. Dans l'exemple, une entrée standard est utilisée, mais pour l'instant, il est normal de simplement saisir le mot de passe à partir du clavier.

while(Expression conditionnelle){
En traitement
}

Exemple: répétez jusqu'à ce que les mots de passe correspondent

int hantei=0
String password;
while( hantei != 999 ){ //Jugement 999 = Répéter jusqu'à ce que le mot de passe corresponde
    System.out.println("S'il vous plait entrez votre mot de passe.");
    Scanner sc = new Scanner(System.in);//Saisissez des caractères à partir du clavier
    password = sc.next() //Transmettez les caractères saisis au mot de passe.
    if(password == “99999”){//Vérifiez les caractères et le mot de passe saisis.
       hantei =999; //S'ils sont égaux, mettez 999 dans le jugement et sortez à plusieurs reprises
       System.out.println("Connexion réussie");
    else{
       System.out.println("Erreur d'authentification")
    }
}

Instruction de contrôle de structure itérative ② (instruction do-while)

L'instruction while était une instruction qui exécute le traitement après avoir effectué un jugement de condition, mais l'instruction do-while exécute d'abord le traitement, puis exécute un jugement de condition. Le format et l'exemple sont les suivants.

do{
En traitement;
}

while(Expression conditionnelle);

Exemple: Répéter jusqu'à ce que 1 soit entré

int number;
do{
    System.out.println("Si vous entrez 1, vous pouvez quitter à plusieurs reprises.");
    Scanner sc = new Scanner(System.in);
    number = sc.nextInt();
}while(number !=1); //Répétez tant que le nombre n'est pas 1.

Instruction de contrôle de structure itérative ③ (pour instruction)

L'instruction for est une structure itérative qui répète le même processus jusqu'à ce que la variable de compteur définie dans l'expression initiale satisfasse l'expression conditionnelle. Une variable qui compte le nombre de répétitions est appelée une variable de compteur. Dans le paramètre initial, la valeur initiale est définie, dans l'expression conditionnelle, la condition de continuation est définie et dans l'expression, le traitement à effectuer chaque fois que le traitement itératif se produit est défini. Un; (point-virgule) est requis pour séparer les paramètres initiaux, les expressions conditionnelles et les expressions.

for(Réglage initial;Expression conditionnelle;formule){
En traitement;
}

Exemple Sortez le nombre de répétitions.

for( int i=1 ; i<4 ; i++ ){ //i commence à 1 et augmente de 1 et se répète moins de 4
    System.out.println(i+"Fois"); //1Fois、2Fois、3Foisと表示される。
}

• Parmi les instructions for et while, l'instruction for est utilisée plus fréquemment, et l'instruction while utilise souvent celle pour laquelle le nombre de répétitions n'est pas fixe et l'instruction for pour laquelle le nombre de répétitions est fixe.

Structure itérative ④ Étendue pour instruction L'instruction for étendue est une syntaxe permettant d'itérer sur un ensemble d'éléments tels qu'un tableau. Itérez en vous référant aux éléments dans l'ordre du début à la fin. Il est facile à décrire car il n'est pas nécessaire de définir des valeurs ou des formules initiales. Le format et l'exemple sont les suivants.

Format

for(Déclaration de variable:Nom de la séquence){
En traitement
}

Exemple: affiche tous les éléments du tableau de nombres.

int numbers[] = {1,2,3,4,5};
for(int number:numbers){
    System.out.println(number);
}

Exemple de tableau de combinaison, étendu pour instruction et instruction if

Exemple d'utilisation de l'instruction for dans l'instruction for

Résumé

Organiser la structure de données d'une collection de variables du même type

Avec un tableau, il est possible d'allouer de l'espace et d'utiliser des valeurs avec une seule déclaration.

Pour utiliser un tableau, vous devez spécifier le nom du tableau et le nombre d'éléments.

Sélectionnez la structure pour dériver le processus selon la condition et exécutez-la.

Spécifiez une plage dans la structure de sélection et utilisez l'instruction branch = if-else, instruction multi-branch = switch

Structure itérative qui répète le processus spécifié tout en satisfaisant les conditions définies au milieu du processus

Utilisez une instruction for avec un nombre fixe de répétitions dans la structure d'itération et un nombre indéfini de répétitions = instruction while

Cette fois, c'est fini. Merci d'avoir lu jusqu'au bout. La prochaine fois, j'expliquerai enfin l'orientation des objets.