web-dev-qa-db-fra.com

En ce qui concerne les instructions de commutation Java - utiliser return et omettre les sauts dans chaque cas

Compte tenu de cette méthode, cela représente-t-il des faux pas flagrants stylistiques ou sémantiques:

private double translateSlider(int sliderVal) {
    switch (sliderVal) {
        case 0:
            return 1.0;
        case 1:
            return .9;
        case 2:
            return .8;
        case 3:
            return .7;
        case 4:
            return .6;
        default:
            return 1.0;
    }
}

Cela ne correspond clairement pas aux tutoriels Java ici . 

Cependant, c’est clair, concis et jusqu’à présent, c’est exactement ce dont j’ai besoin. Existe-t-il une raison convaincante et pragmatique de créer une variable locale, de lui attribuer une valeur dans chaque cas, d'ajouter une rupture à chaque cas et de renvoyer la valeur à la fin de la méthode? 

javareturnswitch-statementcasebreak
40
NickAbbey

Assigner une valeur à une variable locale puis renvoyer cela à la fin est considéré comme une bonne pratique. Les méthodes avec plusieurs sorties sont plus difficiles à déboguer et peuvent être difficiles à lire.

Cela dit, c’est le seul point positif qui reste à ce paradigme. Il a été créé à l'époque où il n'y avait que des langages procéduraux de bas niveau. Et cela avait beaucoup plus de sens à cette époque.

Pendant que nous sommes sur le sujet, vous devez vérifier ceci . C'est une lecture intéressante.

48
rocketboy

De l'intelligence humaine, votre code va bien. Dans la vue des outils d'analyse de code statique, il existe plusieurs déclarations, ce qui rend le débogage plus difficile. Par exemple, vous ne pouvez pas définir un seul et unique point d'arrêt immédiatement avant le retour.

De plus, vous ne coderiez pas de manière stricte les 4 étapes du curseur dans une application professionnelle . Calculez les valeurs en utilisant max - min, etc.

public static final double[] SLIDER_VALS = {1.0, 0.9, 0.8, 0.7, 0.6};
public static final double SLIDER_DEFAULT = 1.0;


private double translateSlider(int sliderval) {
  double ret = SLIDER_DEFAULT;
  if(sliderval >= 0 && sliderval < SLIDER_VALS.length) {
      ret = SLIDER_VALS[sliderval];
  } 
  return ret;
}
6
AlexWien

Le meilleur des cas pour la logique humaine en code-octets générés par ordinateur serait d'utiliser le code suivant:

private double translateSlider(int sliderVal) {
  float retval = 1.0;

  switch (sliderVal) {
    case 1: retval = 0.9;
    case 2: retval = 0.8;
    case 3: retval = 0.7;
    case 4: retval = 0.6;
    case 0:
    default: break;
  }
  return retval;
}

Ainsi, la suppression du multible est terminée et le langage utilisé logiquement. (c’est-à-dire que si sliderVal est une plage d’interféreurs comprise entre 1 et 4, changez la valeur float sinon, si sliderVal vaut 0 et toutes les autres valeurs, retval conserve la même valeur float de 1,0)

Cependant, quelque chose comme ceci avec chaque valeur entière de sliderVal étant (n-(n/10)), on pourrait vraiment faire un lambda et obtenir un résultat plus rapide:

private double translateSlider = (int sliderVal) -> (1.0-(sliderVal/10));

Modifier: Un module de 4 peut être nécessaire pour conserver la logique (ie (n-(n/10))%4))

1
Dwight Spencer

Cela convient parfaitement si vous n'avez aucun code après votre bloc de commutateurs dans la méthode.

Cependant, en tant que bonne pratique générale en matière de programmation, vous devriez éviter d'avoir trop d'instructions de retour car cela réduirait la lisibilité de votre code.

1
Juned Ahsan

Je pense que ce que vous avez écrit est parfaitement correct. Je ne vois pas non plus de problème de lisibilité à avoir plusieurs déclarations de retour. Je préférerais toujours revenir du point dans le code quand je saurai le retourner et cela évitera d’exécuter une logique en dessous du retour Cependant, il peut être argumenté d'avoir un seul point de retour pour le débogage et également la journalisation, le cas échéant. Mais dans votre code, il n’ya pas de problème de débogage et de journalisation si nous l’utilisons. c'est très simple et lisible comme vous l'avez écrit. 

0
Kevin Bhuva

Non, ce que vous avez va bien. Vous pouvez également le faire sous forme de formule (sliderVal < 5 ? (1.0 - 0.1 * sliderVal) : 1.0) ou utiliser un Map<Integer,Double>, mais ce que vous avez suffit.

0
yshavit

Je vous suggère de ne pas utiliser de littéraux.

Autre que cela le style lui-même semble bien.

0
William Morrison

Si vous souhaitez utiliser une méthode qui n'exécute que le commutateur, puis renvoie une valeur, cette méthode fonctionne. Mais si vous voulez un commutateur avec d'autres éléments dans une méthode, vous ne pouvez pas utiliser return ou le reste du code dans la méthode ne sera pas exécuté. Notez dans le tutoriel comment il a une impression après le code? Le vôtre ne serait pas capable de faire cela.

0
DanielD

Pourquoi pas juste 

private double translateSlider(int sliderval) {
if(sliderval > 4 || sliderval < 0)
    return 1.0d;
return (1.0d - ((double)sliderval/10.0d));
}

Ou similaire?

0
SubSevn

Oui, c’est bon ... Les didacticiels ne sont pas toujours consize et ordonnés ..__ Non seulement cela, créer des variables locales est un gaspillage d’espace et inefficace

0
Xperiaz X