[Java] Type d'énumération

• N'utilisez pas final static avec des constantes qui n'ont aucune signification dans la valeur elle-même et qui ont une signification en tant que symboles
• public final static int SPRING = 0; est un type int, donc tous les nombres peuvent être reçus.
• Si la saison est exprimée numériquement et le mois est exprimé numériquement, il est possible que les arguments, etc. soient erronés.
• → *** Utiliser le type d'énumération **
• Noms séparés avec nom de modèle enum
• L'argument n'est pas un int, mais un type de nom défini par ** enum! ** **

//Lors de l'accès au type de saison PRINTEMPS, Saison.SPRING
public enum Season {
  SPRING,
  SUMMER,
  AUTUMN,
  WINTER,
}

public class EnumConstClient {

  public static void main(String[] args) {
    var ecs = new EnumConstSeason();
    ecs.processSeason(EnumConstSeason.SPRING);
    ecs.processSeason(4);
    ecs.processSeason(EnumConstMonth.JANUARY);
  }
}

```java
public class EnumSeason {
  public void processSeason(Season season) {
    System.out.println(season);
  }

  public static void main(String[] args) {
    var es = new EnumSeason();
    es.processSeason(Season.SPRING);
 //Season型で定義されてない定数はエラー
 // es.processSeason (4); // Erreur de compilation
 // es.processSeason (EnumConstMonth.JANUARY); // Erreur de compilation
  }
}
``

# Membres énumérés
 * ** name () **: Récupère le nom de la constante d'énumération
 * ** original () **: Obtenir l'ordre des constantes d'énumération
 * ** toString () **: Obtenez le nom de la constante d'énumération, il peut avoir été remplacé par la représentation sous forme de chaîne appropriée pour chaque type
 * ** values () **: Récupère toutes les constantes d'énumération
 * ** valueOf (String name) **: Récupère la constante d'énumération à partir du nom

```java
public class EnumMethod {
  public static void main(String[] args) {
    for (var se : Season.values()) {
      //Numéro d'index:Sortie par nom q
      System.out.println(se.ordinal() + ":" + se.toString());
    }
    //Obtenir le type d'énumération à partir de la chaîne de caractères
    var s = Season.valueOf("SPRING");
    System.out.println(s instanceof Season); //true
  }
}

Définition de membre

• Définition du champ: lorsque vous voulez que le type d'énumération ait une valeur avec une signification spécifique telle que l'afficher à l'écran / l'enregistrer dans la base de données séparément de son propre nom.
• Définition du constructeur
• Le modificateur d'accès est privé
• Le type d'énumération ne peut pas créer une instance avec ** nouvel opérateur **
• Création d'objet implicite de références constantes d'énumération telles que Season.SPRING
• Le qualificatif d'accès est privé lors de la définition de votre propre constructeur
• Impossible d'appeler super dans le constructeur
• Champ statique non constant non accessible du même type
• La fin de la constante d'énumération doit être ; pour séparer la constante du membre

//Constructeur d'appel avec constante d'énumération
public enum Season {
    SPRING(0, "printemps"),
    SUMMER(1, "été"),
    AUTUMN(2, "l'automne"),
    WINTER(4, "hiver");

  //Déclaration de terrain
  private int code; //Code de saison
  private String jpName; //Afficher un nom
  //constructeur
  private Season(int code, String jpName) {
    this.code = code;
    this.jpName = jpName;
  }
  //Méthode
  public int toSeasonValue() {
    return this.code;
  }
  //Préparez-vous
  @Override
  public String toString() {
    return this.jpName;
  }

  //public abstract void show();
}

public class EnumBasic {
  public static void main(String[] args) {
    System.out.println(Season.SPRING); //printemps
    System.out.println(Season.SPRING.toString());　//printemps
    System.out.println(Season.SPRING.toSeasonValue()); //0
  }
}

Ayez votre propre implémentation de chaque constante d'énumération

• Préparer les fonctions à implémenter par des constantes d'énumération individuelles avec des méthodes abstraites
• Remplacer les méthodes abstraites avec des blocs constants d'énumération

public enum Season {
  //Constante d'énumération
  SPRING(0, "printemps") {
    @Override
    public void show() {
      System.out.println("Le printemps est Akebono");
    }
  },
  SUMMER(1, "été") {
    @Override
    public void show() {
      System.out.println("L'été est la nuit");
    }
  },
  AUTUMN(2, "l'automne") {
    @Override
    public void show() {
      System.out.println("L'automne est le crépuscule");
    }
  },
  WINTER(4, "hiver") {
    @Override
    public void show() {
      System.out.println("Travaillez dur en hiver");
    }
  };
  //Déclaration de terrain
  private int code; //Code de saison
  private String jpName; //Afficher un nom
  //constructeur
  private Season(int code, String jpName) {
    this.code = code;
    this.jpName = jpName;
  }
  //Méthode
  public int toSeasonValue() {
    return this.code;
  }

  @Override
  public String toString() {
    return this.jpName;
  }
  //Fonctions que les constantes d'énumération devraient implémenter (méthodes abstraites)
  public abstract void show();
}

public class EnumMethod {
  public static void main(String[] args) {
    for (var se: Season.values()) {
      se.show(); //Le printemps est nouveau, l'été est la nuit, l'automne est le crépuscule et l'hiver est"
    }
  }
}

Bitfield

• Représentant plusieurs drapeaux comme une séquence de bits
• Résumer avec l'opérateur de somme logique bit

//Mode multiligne insensible à la casse activé
var ptn = Pattern.compile("^[a-z0-9._-]*",
Pattern.CASE_INSENSITIVE | Pattern.MULTILINE);`

• ** Valable pour l'inspection marche / arrêt **
• & Tous les bits sont désactivés (0) sauf si le bit correspondant est activé (1) avec l'opérateur logique bit

import java.util.regex.Pattern;

public class EnumBit {
  public static void main(String[] args) {
    var flags = Pattern.CASE_INSENSITIVE | Pattern.MULTILINE;
    if ((flags & Pattern.COMMENTS) != 0) {
      System.out.println("COMMENTAIRES est valide.");
    }
  }
}

• Combinez avec EnumSet pour améliorer la lisibilité

//Définition du type d'énumération
public enum PatternFlag {
  UNIX_LINES,
  CASE_INSENSITIVE,
  COMMENTS,
  MULTILINE,
}

//Recevoir le type d'énumération
Pattern.compile("^[a-z0-9._-]*",
EnumSet.of(PatternFlag.CASE_INSENSITIVE, PatternFlag.MULTILINE));