Pause café #117. Java Enum - énumération avec des exemples spécifiques. Boucle While en Java : syntaxe et utilisations

Java Enum - énumération avec exemples en Java

Source : FreeCodeCamp Une énumération (énumération ou enum en abrégé) en Java est un type de données spécial qui contient un ensemble de constantes prédéfinies. En règle générale, l'énumération est utilisée lorsque vous travaillez avec des valeurs qui n'ont pas besoin d'être modifiées, telles que les jours de la semaine, les saisons, les couleurs, etc. Dans cet article, nous verrons comment créer une énumération et comment attribuer sa valeur à d'autres variables. Nous apprendrons également comment utiliser une énumération dans une instruction switch ou parcourir ses valeurs.

Comment créer une énumération en Java

Pour créer une énumération, nous utilisons le mot-clé enum . Ceci est similaire à la façon dont vous créez une classe à l’aide du mot-clé class . Voici un exemple :

enum Colors {
  RED,
  BLUE,
  YELLOW,
  GREEN
}

Dans ce code, nous avons créé une énumération appelée Colors . Vous remarquerez peut-être que toutes les valeurs d'énumération ici sont écrites en majuscules - mais ce n'est qu'une convention générale. Si les valeurs sont écrites en minuscules, il n'y aura pas d'erreur. Chaque valeur d' énumération est séparée par une virgule. Ensuite, nous allons créer une nouvelle variable et lui attribuer l'une des valeurs de notre énumération .

enum Colors {
  RED,
  BLUE,
  YELLOW,
  GREEN
}

public class Main {
  public static void main(String[] args) {

    Colors red = Colors.RED;

    System.out.println(red);
    // RED
  }
}

Ceci est similaire à l’initialisation de n’importe quelle autre variable. Ici, dans le code, nous avons initialisé la variable Colors et lui avons attribué l'une des valeurs d'énumération en utilisant la syntaxe par points : Colors red = Colors.RED ; . Notez que nous pouvons créer notre énumération dans la classe Main et que le code fonctionnera toujours :

public class Main {
  enum Colors {
  RED,
  BLUE,
  YELLOW,
  GREEN
}
  public static void main(String[] args) {

    Colors red = Colors.RED;

    System.out.println(red);
  }
}

Si nous voulons obtenir le numéro ordinal de l’une des valeurs, nous devrons utiliser la méthode ordinal() . Voici un autre exemple :

enum Colors {
  RED,
  BLUE,
  YELLOW,
  GREEN
}

public class Main {
  public static void main(String[] args) {

    Colors red = Colors.RED;

    System.out.println(red.ordinal());
    // 0
  }
}

red.ordinal() du code ci-dessus renvoie 0.

Comment utiliser Enum dans une instruction Switch

Nous allons maintenant apprendre comment utiliser enum dans une instruction switch :

public class Main {
      enum Colors {
      RED,
      BLUE,
      YELLOW,
      GREEN
  }
  public static void main(String[] args) {

    Colors myColor = Colors.YELLOW;

    switch(myColor) {
      case RED:
        System.out.println("The color is red");
        break;
      case BLUE:
         System.out.println("The color is blue");
        break;
      case YELLOW:
        System.out.println("The color is yellow");
        break;
      case GREEN:
        System.out.println("The color is green");
        break;
    }
  }
}

Ceci est un exemple très simple de la façon dont nous pouvons utiliser enum dans une instruction switch . Nous pouvons afficher "La couleur est jaune" sur la console car c'est le seul cas qui correspond à la condition de l' instruction switch .

Comment parcourir les valeurs enum

Pour enum, Java a une méthode values() qui renvoie un tableau de valeurs enum . Nous allons utiliser une boucle foreach pour parcourir et imprimer les valeurs de notre énumération . Vous pouvez procéder ainsi :

enum Colors {
  RED,
  BLUE,
  YELLOW,
  GREEN
}

public class Main {
  public static void main(String[] args) {

      for (Colors allColors : Colors.values()) {
      System.out.println(allColors);

      /*
      RED
      BLUE
      YELLOW
      GREEN
      */
    }

  }
}

Conclusion

Dans cet article, nous avons appris ce qu'est une énumération en Java, comment en créer une et comment attribuer ses valeurs à d'autres variables. Nous avons également vu comment utiliser le type enum avec une instruction switch et comment parcourir les valeurs enum . Bon codage !

Boucle While en Java : syntaxe et utilisations

Source : Dev.to Aujourd'hui, nous allons comprendre le concept et la syntaxe d'une boucle while en Java et voir également comment utiliser cette boucle pour parcourir un tableau.

Concept de boucle while

La boucle while est l'un des types de boucles de base en Java et peut être utilisée à plusieurs fins dans un programme. Comme la boucle for , la boucle while peut être utilisée pour effectuer des opérations basées sur une condition. Dans une boucle while , le compteur ne s'allume pas toujours. Le nombre d'itérations de la boucle while dépend de la fréquence à laquelle la condition de boucle renvoie true . L'initialisation dans une boucle while peut être facultative dans la plupart des cas, contrairement à une boucle for . Parfois, la boucle while n'est pas toujours exécutée dans une boucle. Prenons un exemple concret :

System.out.println("You Input a wrong number");
       int i = input.nextInt();
       while(i==1||i==2||i==3||i==4){
           System.out.println("inside the while loop block");
       }
       //if the user chooses any number different from 1,2,3 and 4.
       System.out.println("outside the while loop block")

Ici, le code utilise une boucle while pour valider les entrées de l'utilisateur en fonction de certaines conditions, il ne se répète donc qu'une seule fois.

Syntaxe de la boucle While

while(condition){
//Statements
}

La condition de boucle while prend un argument qui renvoie la valeur booléenne true ou false . Lorsqu'il est vrai, le code de la boucle while est exécuté, mais lorsqu'il est faux , la boucle se termine.

Flux de chaque boucle while

La boucle while a un flux accepté : initialisation > condition > exécution des instructions. La première étape est la phase d'initialisation. Cela peut être accompli en déclarant une variable et en l'initialisant également. La deuxième étape est l'étape de condition, cette étape doit renvoyer true ou false . S'il renvoie true , l'instruction de la boucle while est exécutée, mais si elle renvoie false , la boucle se termine.

Utiliser une boucle while comme compteur

Comme la boucle for , la boucle while peut également être utilisée comme compteur. Le programme ci-dessous utilise une boucle while pour parcourir de 2 à 20. Il s'agit d'imprimer des nombres pairs.

int j = 2;
       while(j <=20){
           System.out.println(j);
           j+=2;
       }

Comme vous pouvez le voir, dans le programme, j est initialisé à 2, la condition est testée si j est inférieur ou égal à 20. Si elle renvoie true , l'instruction est exécutée, mais si elle renvoie false , la boucle while se termine.

Une boucle while peut être utilisée pour parcourir un tableau

int[] age = {20, 30, 40, 40, 90};
        int i = 0;
        while (i < age.length)
        {
            System.out.println(age[i]);
            i++;
        }

Dans ce code, nous avons un tableau age et une boucle while est utilisée pour parcourir le tableau et imprimer chaque élément du tableau. Pour vérifier le nombre total d'éléments dans un tableau, age.length est utilisé , dans le programme ci-dessus, i sert d'index.

Instruction Break dans une boucle while

L' instruction break peut également être utilisée dans une boucle while , tout comme une boucle for :

int i = 1;
        while (true)
        {
            System.out.println(i);
            if (i == 20)
            {
                break;
            }
            i++;
        }

Dans le programme ci-dessus, l' instruction break a été utilisée pour empêcher l'exécution du programme indéfiniment. While(true) signifie que le programme retournera toujours true .

La boucle while peut être utilisée pour valider la saisie de l'utilisateur

System.out.println("Select an option\n"+
         "1.Add Users\n"+
         "2.Delete Users");
         int x = input.nextInt();
         while(x==1||x==2){
         //Do something
         }
System.out.println("You Input a wrong number");

Dans le programme ci-dessus, une boucle while est utilisée pour vérifier la saisie de l'utilisateur et s'assurer que l'utilisateur sélectionne 1 ou 2. Si l'utilisateur sélectionne un nombre différent, alors System.out.println("Vous avez saisi un mauvais numéro"); .

Instruction conditionnelle avec boucle while

int i = 0;
        while(i<10){

            i++;
            if(i==5){
                continue;
            }             System.out.println(i);
        }

L'instruction conditionnelle peut également être utilisée dans une boucle while pour ignorer une itération spécifique. Dans le programme ci-dessus, si l'instruction est utilisée pour vérifier i==5 , si elle renvoie vrai , cette itération particulière sera ignorée.

conception de la boucle while

Créons un jeu de devinettes en utilisant une boucle while .

import java.util.*;

public class Main
{
    static Scanner input = new Scanner(System.in);

    static boolean hasWon;
    static int count;
    static int guess;

    public static void main (String[] args)
    {
        System.out.println("Welcome to guess world");

        System.out.println("Do you want to start the game? ");
        System.out.println("1.Yes\n" +
                           "2.No");
        int option= input.nextInt();
        int guessNumber = (int) Math.floor(Math.random() * 10 + 1);
        if (!( option == 2 ))
        {
            System.out.println("Welcome, choose a guess between 1 and 10\n" +
                               "you have only ten trials");


            while (count <= 10)
            {
                int userGuess = input.nextInt();
                if (userGuess == guessNumber)
                {
                    hasWon = true;
                    System.out.println("Congratulation, you guessed right at " + count + " count");

                    count++;
                    break;
                }
                else if (userGuess < guessNumber)
                {
                    hasWon = false;
                    System.out.println("Oops, you guessed a lower number, try an higher one");
                    count++;
                }
                else if (userGuess > guessNumber)
                {
                    System.out.println("Oops, you guessed an high number, try an lower one");
                    hasWon = false;
                }
            }
            if (hasWon == false)
            {
                System.out.println("You trials exceeds 10");
            }
        }


    }
}

Dans ce programme, nous créons un jeu de devinettes en utilisant une boucle while . Le joueur ne dispose que de 10 tentatives. Une fois que le nombre de fois où il a joué au jeu dépasse 10, la partie se termine. Si le joueur devine le bon numéro, un message de félicitations s'affiche sur la console.

Conclusion

La boucle while peut paraître compliquée, mais elle n'est pas si difficile à maîtriser. C'est également la deuxième boucle la plus couramment utilisée en Java et peut être utilisée à diverses fins.