Discussion :

[boboss123]

bonjour,

J'ai une classe, qui me génère un tableau de bytes. Dans cette classe je peux récupérer la valeur d'un champs spécifique du tableau à l'aide de getCmd().

Le problème est que je voudrais pour des question de lisibilité dans mon code source pouvoir faire une concordance entre la valeur de ce champs et une chaine de caractère compréhensible pour un humain.

Voici ce que j'ai commencé à faire mais ça ne fonctionne pas (erreur de compilation):

Code :

Sélectionner tout - Visualiser dans une fenêtre à part

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
43
44
45
46
47
48
49
50
51
52
 
		public class CMD {
			public final static byte DATA = 0x00;	// contient des données (0x00)
			public final static byte EOF = 0x01;	// fin du fichier (0x01)
			public final static byte JUMP = 0x04;	// saut d'adresse (0x04)
		}
 
		class MaClass {
			Byte[] pTabByte = new Byte[32];
 
			// ....
			// ....
 
			// Traitement de pTabByte
 
			// ....
			// ....
 
 
			// recupération d'un champs spécifique
			public CMD getCmd(){
				return pTabByte[3];
				// => ne fonctionne pas car CMD n'est un byte
				// => si je mets byte à la place de CMD, ça n'ira pas car l'utilisateur ne verra pas 
				//     la correspondance entre cette valeur et mon enum.
				//     Je veux qu'il puisse voir tout de suite ce que représente la valeur retournée
			}
		}
 
 
		// ************************
		// Utilisation de la classe 
 
		MaClass obj = new MaClass();
 
		switch(obj.getCmd()){
			case CMD.DATA:
				// traitement
				// ...
				break;
 
			case CMD.EOF:
				// traitement
				// ...
				break;
 
			default :
				// traitement
				// ...
		}
 
		// ************************

=> comment puis-je faire ? ...En gros, j'aimerais pourvoir faire un enum en langage C (enum en java n'a pas l'air d'être une bonne solution pour ce cas)

[tchize_]

les enums en C sont des int déguisés, ce qui fait que ton code "pourrait" passer en C.


En java, t'as deux possibilités:

Code :

Sélectionner tout - Visualiser dans une fenêtre à part

1
2
3
4
5
6
7
			public byte getCmd(){
				return pTabByte[3];
			}
//.....
switch(obj.getCmd()){
			case CMD.DATA:
				// traitement

ou avec des enums java

Code :

Sélectionner tout - Visualiser dans une fenêtre à part

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
		public enum CMD {
			DATA(0x00),EOF(0x01),JUMP(0x04),UNKNOWN(0xFF);	
                        private byte commandFlag;
                        public CMD(byte flag){commandFlag=flag);
                        public byte getCommandFlag() {return flag;}
                        public static CMD findCommand(int flag){
                            for (CMD c : CMD.values() ){
                                if (c.getCommandFlag == flag)
                                   return c;
                            }
                            return UNKNOWN
                        }
		}
//........................
			public CMD getCmd(){
				return CMD.findCommand(pTabByte[3]);
			}
//.....
switch(obj.getCmd()){
			case DATA:
				// traitement

[boboss123]

Merci pour ta réponse.

Je trouve que la solution 1 n'est pas très explicite pour le programmeur qui va utiliser getCmd() car il ne ferra pas forcément l'analogie entre la valeur retournée et ma classe CMD.

Quand à la seconde solution 2, bien qu'au niveau utilisation de getCmd() ça correspond à ce que je recherchais, ça me semble vraiment très lourd car à chaque appel de getCmd() il y a un parcours en boucle de l'enum
=> vu que c'est une fonction qui va être appelée très souvent, j'aurais aimé un traitement le plus rapide possible ... mais a priori ce n'est pas possible en java :'( ...

C'est bien la solution 2 qui est généralement utilisée dans les libraires comme Swing, non ?

[le y@m's]

Pour éviter de parcourir la boucle des enums à chaque appel de getCmd() tu peux mettre cette valeur dans un attribut de ta classe;

Code :

Sélectionner tout - Visualiser dans une fenêtre à part

1
2
3
4
5
6
7
8
9
10
11
12
13
14
class MaClasse {
 
    private byte[] pTabByte = new byte[32];
    private CMD cmd;
 
    public void setTabByte(byte[] pTabByte) {
        this.pTabByte = pTabByte;
        cmd = CMD.findCommand(pTabByte[3]);
    }
 
    public CMD getCmd() {
        return cmd;
    }
}

[boboss123]

ok merci pour l'info
... mais le problème est que getCmd() est souvent appelé car sa valeur change souvent => donc bufferiser la valeur ne servira à rien

[tchize_]

tu peux très bien adapter findCommand pour qu'elle ne parcoure pas la liste mais un tableau ordonné que tu aurais créé avant, ou une map clé->valeur. Ou si il n'y a pas de "trou" dans les valeur, utiliser directement ordinal qui correspond à l'ordre de déclaration des enums. Ce ne sont pas les choix qui manquent.

Quand à swing, les librairies ont été écrite avant l'arrivée en java des enum -> on utilsie beaucoup des ints à gauche et à droite, ce qui est parfois problématique car les erreurs ne se detectent pas.