Solution pour le Nombre Magique de problème...?

Considérer le segment de code suivant...

 public static UserStatus getEnum(int code) {
    switch (code) {
        case 0:
            return PENDING;
        case 1:
            return ACTIVE;
        case 2:
            return SUSPENDED;
        case 3:
            return DELETED;
        case 4:
            return LOGIN_DISABLED;
        default:
            return null;
        }

}

Aujourd'hui au nombre de 3 et 4 dans le cas(cas 3 et 4) sont détectés comme des numéros de magie par le SONAR.

Pour éviter ce problème, j'ai changé mon code segment comme suit...

 public static UserStatus getEnum(int code) {        
    final int Pending=0;
    final int Active=1;
    final int Suspended=2;
    final int Deleted= 3;
    final int Login_details=4;

    switch (code) {
        case Pending:
            return PENDING;
        case Active:
            return ACTIVE;
        case Suspended:
            return SUSPENDED;
        case Deleted:
            return DELETED;
        case Login_details:
            return LOGIN_DISABLED;
        default:
            return null;
    }
}

Est-ce une bonne façon de résoudre le nombre magique problème dans ce genre de scénario ?.

Que voulez-vous dire que 3 et 4 sont "détectés comme des numéros de magie"? Quel est le "nombre magique problème"?
Je suppose que vous parlez de SONAR les détecter comme Magic Numbers?
oui, votre avez raison: cochez cette autre question de référence: stackoverflow.com/questions/47882/...
Une meilleure option serait d'avoir une classe, avec static valeurs, de sorte que fréquemment utilisé Magic les nombres peuvent être déplacés, ne qu'ils peuvent être utilisés n'importe où dans le projet.
C'est en ce qui concerne le SONAR. SONAR de détecter ceux que des Numéros de Magie

OriginalL'auteur Ruchira Gayan Ranaweera | 2013-03-21

  1. 7

    Je suppose que vous souhaitez éviter d'utiliser les littéraux entiers dans le code. Votre solution n'est pas particulièrement efficace, car il se déplace simplement les littéraux au sommet de la méthode. Il gagne un petit peu, parce qu'il donne des noms significatifs pour les constantes, mais ces noms sont privés de la méthode.

    Une meilleure approche serait de définir les numéros de champs dans une interface. Vous pouvez ensuite statiquement importer les champs et de les utiliser comme des noms symboliques pour les constantes.

    Si l'enum est déclaré dans le même ordre que les constantes:

    enum UserStatus {PENDING, ACTIVE, SUSPENDED, DELETED, LOGIN_DISABLED}

    vous pouvez faire un autre truc:

    public static UserStatus getEnum(int code) {
    UserStatus[] values = UserStatus.values();
    return (code >= 0 && code < values.length) ? values[code] : null;
}

    Cependant, cela crée un lien entre les valeurs de constante et de la déclaration de l'enum. Ce sera peut-être possible, selon l'endroit où les valeurs de paramètre sont générés dans les appels à getEnum.

    Interface constantes est l'anti-modèle en Java.
    Oui, ces jours, il est considéré comme meilleur style pour utiliser une classe de déclarer des constantes symboliques. De toute façon serait une amélioration par rapport à l'OP du code actuel.
    Je pense qu'il n'est pas à propos de mettre la constante dans la "classe" ou "interface". L'anti-modèle est : création d'une interface juste pour mettre des constantes. Les constantes doivent va à la classe/interface/le type qui est adapté à la contenir. Si rien, puis l'utilisation finale de l'onu-classe instanciable au lieu de cela, pour éviter de donner incorrect sémantique du sens à l'affichage de type
    Les vrais anti-modèle est d'amener les constantes dans une classe de l'espace de noms par la mise en œuvre d'une interface. Pour cette raison, la "classe "et "interface" est une distinction importante. (Vous étendre, plutôt que de mettre en œuvre, les classes.) À l'aide de import static et de déclarer les constantes dans un (non-instanciable) de la classe au lieu d'une interface prend-il pour sortir de l'univers d'un anti-modèle. (Voir, par exemple, l'article de Wikipedia Constante de l'interface.)
    L'anti-modèle est application une des constantes de l'interface, de ne pas déclarer un et statiquement importer les noms de constantes.

    OriginalL'auteur Ted Hopp

  2. 1

    Le problème est simple et évidente: quand les gens est la lecture de votre code, il n'est pas évident pourquoi 1 en ATTENTE. Quel est le sens de 1?

    Vous devriez donner la sémantique du sens à cela. À l'aide de constantes est ce qui normalement devrait être fait:

    (À supposer la getEnum() fait partie de la UserService, le code devrait ressembler à quelque chose comme)

    public interface UserService {
   public static final int USER_STATUS_VAL_PENDING = 1;
   public static final int USER_STATUS_VAL_ACTIVE = 2;

   UserStatus getUserStatus(int userStatusVal);
}

public class SimpleUserService implements UserService {
   public UserStatus getUserStatus(int userStatusVal) {
      switch userStatusVal {
      case USER_STATUS_VAL_PENDING:
         return UserStatus.PENDING;
      case USER_STATUS_VAL_ACTIVE:
         return UserStatus.ACTIVE;
      //.....
   }
}

    Comme l'a suggéré une autre réponse, vous pouvez compter sur l'ordinal de la valeur de l'enum pour faire le int-enum cartographie. Cependant, vous devez être conscient qu'une telle manière peut entraîner des problèmes si vous rearraged les valeurs de l'enum, ou l'ajout de nouvelles valeurs à la position à part la fin. Les valeurs ordinales sera changé, et vous n'avez aucun moyen de passer outre.

    Une autre chose à payer attention, il y a quelque chose qu'on ne fait à droite dans votre code:

    1. Que le but est de donner sens sémantique à l'entier littéral qui en fait une constante, il devrait être quelque chose de visible à l'appelant, donc locale dernière variable n'est pas la bonne façon de le faire.
    2. vous devez utiliser ALL_CAP_UNDERSCORE_DELIMITED pour les constantes nom

    OriginalL'auteur Adrian Shum