switch avec un Enum

Version imprimable

19/02/2010, 23h06
rtg57

switch avec un Enum
Bonsoir,

quelqu'un peut-il m'expliquer comment faire pour utiliser un switch qui compare un int, a des valeur d'énumération ?
Exemple:

L'énumération:
Code:

1 2 3 4 5 6 7 public enum enumChamps { C1 ("Champ1"), C2 ("Champ2"), C3 ("Champ3"); /.../ }
Puis dans une méthode d'une classe:
Code:

1 2 3 4 5 6 7 8 9 public methodeX(int x) { switch (x) { case C1: Bla bla pour c1; break; case C2: /.../
L'idée est de savoir à quel élément d'énumération correspond 'x'.
Je ne sais pas comment récupérer le fait que C1 est le 1er élément de l'énumération, C2 le deuxième...

ordinal() me donne la position de chaque éléments de l'énumération. Mais lorsque je tente la syntaxe:

Code:

case enumChamps.C1.ordinal():

on me répond que Les expressions de case doivent correspondre à des constantes.
Et je tourne en rond :roll:

Déjà ça sert ne sert à rien d'appeler ta fonction ordinal() dans le case vu que ta méthode reçoit un entier.

Donc tu devrais faire ça :

Code:

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
	int i = enumChamps.C1.ordinal();
 
		MethodeX(i);
 
public  void MethodeX(int i){
 
		switch (i) {
	      case 0:
	         System.out.println("************");
	         break;
	      case 1:
	    	   System.out.println("************");
	         break;
	      case 3:
	    	   System.out.println("************");
	         break;
	      case 4:
	    	   System.out.println("************");
	         break;
	   }
	}

Mais bon c'est une autre façon, et ça ne répond pas tout à fait à la question.

pourquoi travailler avec un entier. Les switch/case enum, ca marche comme ça
Code:

1 2 3 4 5 6 7 8 9 public methodeX(MonEnum x) { switch (x) { case MonEnum.C1: Bla bla pour c1; break; case MonEnum.C2: /.../
Si pour des raisons obscures et impénétrable t'es obligé à tout prix de travailler avec un int (ce qui est une peu suicidaire dans beaucoup de cas, car l'ordre des enums peut avoir changé avec le temps et le but est justement d'éviter de repasser sur tout le code et à rajouter que le int n'est pas typé donc on peux facilement confondre les valeurs qu'on envoir), tu peux tenter ça
Code:

1 2 3 4 5 6 7 8 9 public methodeX(int x) { switch (MonEnum.values()[x]) { // rajouter un peu de code our tester que x est bien dans le range ;) case MonEnum.C1: Bla bla pour c1; break; case MonEnum.C2: /.../

20/02/2010, 12h16
rtg57

Merci pour vos réponses,

pour être plus précis puisque la solution ne coule pas de source apparemment, cela se passe dans une classe qui étends AbstractTableModel

La méthode en question est la surcharge de Object getValueAt(int, int)
Le soucis est que cette méthode ne me passe pas des arguments de type de mon Enum.
Le code présenté par azerty.123.450 est bien sympa, mais cela suppose que l'on sache quel élément de l'Enum on travaille. Or dans mon cas, je n'en sais rien.

Par contre les colonnes de la table sont construites sur le modèle de l'Enum, et sont donc liées à celui-ci. getValueAt() me renvoie la colonne, et je n'ai pas envie de faire un switch avec des 1, 2, 3, mais avec les éléments de mon Enum.
Ainsi si un jour, je décide de changer l'arrangement des mes colonnes, je le ferai au niveau de l'Enum.

J'espère que ce n'est pas trop brouillon ce que je raconte :mrgreen:

Alors je teste

Code:

switch (MonEnum.values()[x])

, et je vous tiens au courant...

Marci et @ bientôt

Ouf ! La solution de tchize fonctionne :ccool:
Et le code est propre est clair, pour ceux que ça intéresse:

Le code de l'énumération

Code:

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
public enum enumChamps
{
  NMR_OP ("N°"),
  NMR_DATE ("DATE"), 
  ETAT_OP ("P"), 
  MONTANT_C ("CREDIT"),
  MONTANT_D ("DEBIT"),
  SOLDE_PREVU ("SOLDE PREVU"),
  SOLDE_REEL ("SOLDE REEL"),
  OBSERVATION ("OBSERVATIONS");
 
  private final String Libelle;
 
  // CONSTRUCTEUR:
  private enumChamps(String Texte)  { this.Libelle = Texte; }
 
  // INTERFACE:
  public String donneLibelle()  { return this.Libelle; }
}

Puis, dans la classe qui gère les données et qui étends AbstractTableModel:

Code:

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
@Override
public Object getValueAt(int ligne, int colonne)
{
  if (ligne >= getRowCount())
  {
    return null; // Index hors limite
  }
  else
  {
    switch(enumChamps.values()[colonne])
    {
    case NMR_OP:
      return m_Operations.get(ligne).donneNmrOP();
 
    case  NMR_DATE:
      return m_Operations.get(ligne).donneDate();
 
    case  ETAT_OP:
      return m_Operations.get(ligne).donneEtatOP();
 
    case  MONTANT_C:
      return m_Operations.get(ligne).donneMontantC();
 
    case  MONTANT_D:
      return m_Operations.get(ligne).donneMontantD();
 
    case  SOLDE_PREVU:
      return m_Operations.get(ligne).donneSoldePrevu();
 
    case  SOLDE_REEL:
      return m_Operations.get(ligne).donneSoldeReel();
 
    case  OBSERVATION:
      return m_Operations.get(ligne).donneObservation();
 
    default: // Arrivé ici signifie PROBLEME
      JOptionPane.showMessageDialog(null, "Erreur d'énumération, veuillez contacter le programmeur.", "ERREUR CTableDonnees.getValueAt", JOptionPane.WARNING_MESSAGE); 
      return null;
 
    }
  }
}

Si je change un jour mon énumération, je n'aurais pas à me préoccuper de l'ordre des colonnes...

Merci encore