Quelles sont les trois instructions de contrôle de base en Java ?

Les trois instructions de contrôle de base de Java sont : la structure de séquence, la structure de sélection et la structure de boucle. L'article suivant vous guidera à travers cela, j'espère qu'il vous sera utile.

Structure séquentielle

La structure séquentielle est le contrôle de processus le plus simple et le plus basique du programme As. tant qu'il est résolu selon l'ordre des questions, écrivez les instructions correspondantes, puis exécutez-les dans l'ordre des codes, la plupart des codes du programme sont exécutés de cette manière ;

L'ordre d'exécution est de haut en bas, dans l'ordre.

package Test3;

public class OrderDemo {
    public static void main(String[] args) {
        System.out.println(1);
        System.out.println(2);
        System.out.println(3);
    }
}

Sortie séquentielle : 1 2 3

Structure de sélection

La structure de sélection est utilisée pour juger des conditions données, selon Le résultat du jugement détermine certaines conditions, et le déroulement du programme est contrôlé sur la base du résultat du jugement. Lorsque vous utilisez une instruction de structure de sélection, utilisez des expressions conditionnelles pour décrire les conditions.

Java a deux types d'instructions conditionnelles :

●　instruction if

● instruction switch

instruction if

Une instruction if contient une expression booléenne et une ou plusieurs instructions. Si la valeur de l'expression booléenne est vraie, le bloc de code de l'instruction if est exécuté, sinon le code suivant le bloc d'instruction if est exécuté.

Syntaxe

if (布尔表达式) {        
  // 如果布尔表达式为true将执行的语句
}

L'instruction if peut être suivie d'une instruction else. Lorsque la valeur de l'expression booléenne de l'instruction if est fausse, le bloc d'instruction else sera exécuté. Syntaxe :

if(布尔表达式){
   //如果布尔表达式的值为true
}else{
   //如果布尔表达式的值为false
}

Exemple :

public class Test {
 
   public static void main(String args[]){      int x = 30; 
      if( x < 20 ){
         System.out.print("这是 if 语句");
      }else{
         System.out.print("这是 else 语句");
      }
   }
}

Sortie :

这是 else 语句

instruction switch

jugement de l'instruction switch Si une variable est égale à une valeur dans une série de valeurs, chaque valeur est appelée une branche.

Syntaxe

switch(expression){
    case value :
       //语句
       break; //可选
    case value :
       //语句
       break; //可选
    //你可以有任意数量的case语句
    default : //可选
       //语句
}

L'instruction switch a les règles suivantes :

● Le type de variable dans l'instruction switch peut être : byte, short, int ou char. À partir de Java SE 7, le commutateur prend en charge le type de chaîne et les étiquettes de casse doivent être des constantes de chaîne ou des littéraux.

● L'instruction switch peut avoir plusieurs instructions case. Chaque cas est suivi d'une valeur à comparer et de deux points.

●　Le type de données de la valeur dans l'instruction case doit être le même que le type de données de la variable, et il ne peut s'agir que d'une constante ou d'une constante littérale.

●Lorsque la valeur de la variable est égale à la valeur de l'instruction case, alors les instructions après l'instruction case commencent à s'exécuter et l'instruction switch ne sautera pas tant que l'instruction break n'apparaîtra pas.

● Lorsque vous rencontrez une instruction break, l'instruction switch se termine. Le programme passe à l'instruction qui suit l'instruction switch pour l'exécution. L'instruction case n'a pas besoin de contenir une instruction break. Si aucune instruction break ne se produit, le programme continue l'exécution de l'instruction case suivante jusqu'à ce qu'une instruction break se produise.

● L'instruction switch peut contenir une branche par défaut, qui doit être la dernière branche de l'instruction switch. default est exécuté lorsqu'aucune instruction case n'est égale à la valeur de la variable. La branche par défaut ne nécessite pas d'instruction break.

Exemple :

public class Test {
   public static void main(String args[]){      //char grade = args[0].charAt(0);
      char grade = 'C'; 
      switch(grade)
      {         case 'A' :
            System.out.println("优秀"); 
            break;         case 'B' :         case 'C' :
            System.out.println("良好");            break;         case 'D' :
            System.out.println("及格");         case 'F' :
            System.out.println("你需要再努力努力");            break;         default :
            System.out.println("未知等级");
      }
      System.out.println("你的等级是 " + grade);
   }
}

Sortie :

良好
你的等级是 C

Structure de boucle

Instructions de programme de structure séquentielle uniquement Peut être exécuté une fois. Si vous souhaitez effectuer plusieurs fois la même opération, vous devez utiliser une structure en boucle.

La structure en boucle peut réduire la charge de travail d'écriture répétée du programme source et est utilisée pour décrire le problème de l'exécution répétée d'un certain algorithme. Il s'agit de la structure de programme qui utilise le mieux l'expertise de l'ordinateur en programmation. La structure de boucle peut être considérée comme une combinaison d’une instruction conditionnelle et d’une instruction de retournement.

Les langages de programmation ont généralement trois structures de boucle principales :

● while boucle

● do...while boucle

Quantity　boucle for

boucle while

while est la boucle la plus basique, sa structure est :

while( 布尔表达式 ) {
    // 循环内容
}

Tant que l'expression booléenne est vraie , La boucle continuera à s'exécuter.

Exemple :

int x = 10;while( x < 15 ) {
     System.out.println("value of x : " + x );
      x++;
}

Sortie :

value of x : 10
value of x : 11
value of x : 12
value of x : 13
value of x : 14

do...while boucle

For while instruction , if les conditions ne sont pas remplies, la boucle ne peut pas être réalisée. Mais parfois, nous devons l’exécuter au moins une fois même si les conditions ne sont pas remplies. La boucle do...while est similaire à la boucle while, sauf que la boucle do...while est exécutée au moins une fois.

do {
        //代码语句
}while(布尔表达式);

Remarque : L'expression booléenne se trouve après le corps de la boucle, le bloc d'instructions a donc été exécuté avant de surveiller l'expression booléenne. Si l’expression booléenne est évaluée à vrai, le bloc d’instructions est exécuté jusqu’à ce que l’expression booléenne soit évaluée à faux.

Exemple :

int x = 10; 
do{
   System.out.println("value of x : " + x );
   x++;
}while( x < 15 );

Sortie :

value of x : 10
value of x : 11
value of x : 12
value of x : 13
value of x : 14

for boucle

Le nombre de fois que la boucle for est exécutée c'est avant l'exécution C'est sûr. Le format de la syntaxe est le suivant :

for(初始化; 布尔表达式 ; 更新) {
        // 代码语句
}

Il existe plusieurs instructions pour la boucle for :

● L'étape d'initialisation est exécutée en premier. Un type peut être déclaré, mais une ou plusieurs variables de contrôle de boucle peuvent être initialisées, ou il peut s'agir d'une instruction vide.

Quantity　Ensuite, vérifiez la valeur de l'expression booléenne. Si c'est vrai, le corps de la boucle est exécuté ; si c'est faux, la boucle se termine et les instructions qui suivent le corps de la boucle commencent à être exécutées.

●Après avoir exécuté la boucle une fois, mettez à jour la variable de contrôle de boucle.

● Surveillez à nouveau l'expression booléenne. Effectuez le processus ci-dessus en boucle.

Exemple :

for(int x = 10; x < 15; x = x+1) {
   System.out.println("value of x : " + x );
}

Sortie :

value of x : 10
value of x : 11
value of x : 12
value of x : 13
value of x : 14

Ce qui précède est le contenu détaillé de. pour plus d'informations, suivez d'autres articles connexes sur le site Web de PHP en chinois!