Java: si-retour-si-retour si vs-retour-elseif-retour

Demandé à un question sans rapport où j'ai eu un code comme ceci:

public boolean equals(Object obj)
{
    if (this == obj)
        return true;

    if (obj == null)
        return false;

    if (getClass() != obj.getClass())
        return false;

    //Check property values
}

J'ai reçu un commentaire qui a affirmé que ce n'était pas la meilleure, et qu'à la place (si j'ai bien compris) doit faire ceci:

public boolean equals(Object obj)
{
    if (this == obj)
        return true;

    else if (obj == null)
        return false;

    else if (getClass() != obj.getClass())
        return false;

    //Check property values
}

En raison de la reprise des déclarations, je ne vois pas vraiment pourquoi l'un d'eux devrait être plus efficace ou plus rapide que les autres. Compte tenu d'un certain objet, les deux méthodes ont à faire un nombre égal de vérifications d'aussi loin que je peux voir. Et parce que le retour des déclarations, pas de code supplémentaire irait dans l'un d'eux.

Suis-je manqué quelque chose? Est-il quelque chose à cela? Y at-il des optimisations du compilateur ou de quelque chose qui se passe ou quoi que ce soit?

Je sais que c'est micro-optimisation, et je vais probablement rester avec le premier de toute façon, puisque je pense que c'est plus propre avec toutes les fi sur la même position. Mais je ne peux pas l'aider; je suis curieux!

Dites-moi le nom du mec qui a fait ce commentaire et je vais downvote lui 😉
Je vous conseille de ne pas se préoccuper de ces micro-niveau des optimisations. Vous pouvez toujours trouver les puristes qui divisent les cheveux. Ces optimations sont bien pris en compte par le compilateur et les chances sont le premier reçoit déjà réduit à la deuxième version (ou vice-versa, selon ce que votre compilateur est bonne).
Joshi - virtuelle (+1) au lieu d'élever votre main 🙂
Jigar post était tout à fait stupide. Je sais que nous sommes censés pour être poli et tout, mais c mon. Pas étonnant que la qualité du travail dans le logiciel est à la traîne. C'est de la merde les gens doivent apprendre dans leur première introduction cours de programmation. Pour ne pas savoir qu'une autre personne est simplement du sucre syntaxique pour un autre si (ce qui n'est qu'un autre saut/goto sous le capot), qui n'est pas acceptable de quelqu'un qui a passé son introduction programmation des cours. Il y a beaucoup de choses dans la programmation/CS qui sont très compliquées. Ce n'est pas l'un d'eux.
Ce que je pensais ceci Il était totalement en dehors de l'aspect, @Andreas_D @Swish Merci 🙂
Juste pour clearify, ce n'était pas de bash en aucune manière de vous! Était juste vraiment curieux 🙂
Tautologie la parole que deux fois la même chose en des termes différents, généralement considéré comme une faute de style

InformationsquelleAutor Svish | 2011-04-14

23

Généré le byte-code est identique pour ces deux cas, c'est donc purement une affaire de style.

J'ai produit deux méthodes e1 et e2 et à la fois la production de ce code octet (lecture à l'aide de javap -v):
```
public boolean e1(java.lang.D'un objet); 
Code: 
Pile=2, Les Habitants=2, Args_size=2 
0: aload_0 
1: aload_1 
2: if_acmpne 7 
5: iconst_1 
6: ireturn 
7: aload_1 
8: 13 ifnonnull 
11: iconst_0 
12: ireturn 
13: aload_0 
14: invokevirtual #25; //Méthode java/lang/Object.getClass:()Ljava/lang/Classe; 
17: aload_1 
18: invokevirtual #25; //Méthode java/lang/Object.getClass:()Ljava/lang/Classe; 
21: if_acmpeq 26 
24: iconst_0 
25: ireturn 
```
J'ai laissé de côté le code que j'ai mis après que de faire de la compilation.
- Il n'y a pas d'intelligence nécessaire ici, le compilateur n'avait pas réellement d'autre choix que de générer le même code pour tous les cas. Il n'y a pas de else déclaration en byte code, seulement un tas de if-condition-goto ceux.
- La seule intelligence nécessaire, c'est que le compilateur doit savoir que, après un ireturn il n'a pas besoin de mettre un jump-to-the-end-of-the-if-else-cascade déclaration. Et c'est assez trivial de vérifier.
- Compilateur est très intelligent." Vous en pensez? Des petites nouvelles pour vous Jigar. Tous les compilateurs ont fait depuis le début des temps, depuis la 3ème génération de langages de programmation ont été inventés (et même depuis que les gens ont commencé à l'aide de macro-instructions dans l'assemblage). Bienvenue à la technologie de compilation inventé près de 60 ans. Vous n'avez même pas besoin de savoir compilateur de la technologie. Simple logique dicte ces deux ensembles de si (et si l'autre) déclarations de de est équivalent.
- votre déclaration est factuellement vrai, mais je ne vois pas une raison pour le ton que vous utilisez. Pas tout le monde a étudié compilateur techniques.
- Ebermann , @Joachim Sauer Ce que je pensais ceci Il était totalement en dehors de l'aspect, @Andreas_D @Swish Merci 🙂 , supprimé le commentaire intentionnellement.
- Je recommande compilateur de la construction? Ce que nous cherchons à établir dans ces commentaires que certains sont juste certifiés, tandis que d'autres sont diplômés de l'université. Maintenant, que si les entreprises pouvaient voir la différence et de la verser à l'université smarta$$es mieux....lol
- vous n'avez pas à apprendre que de prendre une classe sur compilateur techniques. Vous apprendre qu'à partir de la programmation de base, les cours que nous apprenons de l'équivalence sémantique des structures de contrôle. Nous apprenons quand nous entrons à l'assemblée. Malheureusement, le plus tard n'est pas enseigné que plus beaucoup, mais l'ancien est appris à partir de base/fondamental de la programmation et de l'histoire de langages de programmation (qui est également couverte dans chaque sanglante collège manuel de programmation/CS/SIG.) Le ton est justifiable, et non, ce n'est pas spécifique à compilateur de la construction. Il n'est pas un obscur, ésotérique rubrique avancé.
- tout simplement parce que les deux formes sont évidemment identiques, n' pas implique que le compilateur génère un code identique.
- dans la plupart des les compilateurs modernes, il n'a, été pendant une longue période. Et même si l'on ignore le problème de compilateurs et nous supposons que l'improbable qu'un compilateur produira significativement différente de sortie), c'est l'une des choses que devrait (doit lire) être évident que ces deux cas (et si l'autre) les blocs sont sémantiquement équivalents.
InformationsquelleAutor Joachim Sauer

Ni l'un est plus efficace que l'autre. Le compilateur peut facilement voir que les deux sont identiques, et, en fait, des Soleils/Oracles javac produit identiques bytecode pour les deux méthodes.

Voici un IfTest classe:

class IfTest {

    public boolean eq1(Object obj) {
        if (this == obj)
            return true;

        if (obj == null)
            return false;

        if (getClass() != obj.getClass())
            return false;

        return true;
    }


    public boolean eq2(Object obj) {

        if (this == obj)
            return true;

        else if (obj == null)
            return false;

        else if (getClass() != obj.getClass())
            return false;

        return true;
    }
}

J'ai compilé avec javac et le démontage est comme suit:

public boolean eq1(java.lang.Object);
  Code:
   0:   aload_0
   1:   aload_1
   2:   if_acmpne   7
   5:   iconst_1
   6:   ireturn
   7:   aload_1
   8:   ifnonnull   13
   11:  iconst_0
   12:  ireturn
   13:  aload_0
   14:  invokevirtual   #2; //Method Object.getClass:()Ljava/lang/Class;
   17:  aload_1
   18:  invokevirtual   #2; //Method Object.getClass:()Ljava/lang/Class;
   21:  if_acmpeq   26
   24:  iconst_0
   25:  ireturn
   26:  iconst_1
   27:  ireturn

public boolean eq2(java.lang.Object);
  Code:
   0:   aload_0
   1:   aload_1
   2:   if_acmpne   7
   5:   iconst_1
   6:   ireturn
   7:   aload_1
   8:   ifnonnull   13
   11:  iconst_0
   12:  ireturn
   13:  aload_0
   14:  invokevirtual   #2; //Method Object.getClass:()Ljava/lang/Class;
   17:  aload_1
   18:  invokevirtual   #2; //Method Object.getClass:()Ljava/lang/Class;
   21:  if_acmpeq   26
   24:  iconst_0
   25:  ireturn
   26:  iconst_1
   27:  ireturn

Qui est, je vous conseille d'utiliser la première version (sans le else). Certains pourraient dire que c'est plus propre avec l'autre des parties, mais je dirais le contraire. Y compris la else indique que le programmeur ne savais pas que c'était inutile.

+1 pour l'analyse, je l'ai déjà relevé dans un commentaire ci-dessus à la question. Si vous essayez la déclaration unique version je crois qu'il serait à nouveau exactement le même que le compilateur l'habitude de se préoccuper de les tracas de la création d'une variable et faire mem opérations lorsqu'il sait tout, il est là pour renvoyer les résultats.
Intéressant que votre compilateur a len du 27 et le compilateur de @Joachim Sauer a 25. Quel JDK avez-vous utilisé?
Je suis d'accord, y compris l'autre indique le programmeur ne savais pas que c'était inutile.

InformationsquelleAutor aioobe

5

Je ne vois aucune raison pratique pour remplacer l'une de ces mises en oeuvre avec l'autre dans n'importe quelle direction.

Le deuxième exemple serait logique si vous avez voulu éviter la présence de plusieurs instructions return dans une méthode, - certaines personnes préfèrent cette façon de coder. Puis nous avons besoin de l'if-else if constructions:
```
public boolean equals(Object obj)
{
    boolean result = true;

    if (this == obj)
        result = true;

    else if (obj == null)
        result = false;

    else if (getClass() != obj.getClass())
        result = false;

    return result;
}
```
InformationsquelleAutor Andreas_D
3

Pensez-y de cette façon. Lorsqu'une instruction return est exécutée, le contrôle des feuilles de la méthode, de sorte que le else n'a pas vraiment d'ajouter de la valeur, sauf si vous voulez faire valoir qu'elle ajoute de la lisibilité (à laquelle je ne pense pas vraiment qu'il n', mais d'autres peuvent être en désaccord).

Ainsi, lorsque vous avez:
```
if (someCondition)
    return 42;

if (anotherCondition)
    return 43;
```
Il n'y a pas vraiment de valeur à l'ajout d'un else à la deuxième if.

En fait, j'utilise un outil lors de l'écriture de code C# appelé Resharper, et il sera en fait la marque de la else comme inutile le code dans ces situations. Donc je pense qu'en règle générale, il est préférable de les laisser. Et comme Joachim déjà mentionné, le compilateur optimise loin de toute façon.
- Je suis totalement d'accord avec Resharper là... Quand je vois de telles elses, j'ai tendance à les supprimer. De même, je grince des dents quand je vois de si (cond) return true; else return false; ...
InformationsquelleAutor dcp
0

Je pense que ce code peut être un peu améliorée (vous l'esprit, c'est très lisible):
```
  if (obj == null)
        return false;

  if (getClass() != obj.getClass())
        return false;
```
La instanceof opérateur est équivalent à ces deux combinés et est probablement plus rapide - moins de code, et pas des invocations de méthode:
```
  if (!(obj instanceof MyClass))
        return false;
```
Mais que sais-je.... Je suis trop paresseux pour analyser le byte code (n'ayant jamais fait avant). :-p
- Vous devez être conscient de ce que getClass() et instanceof sont pas équivalent. Si vous avez deux classes A et B où B extends A, puis getClass() est toujours false, alors que b instanceof A est true.
InformationsquelleAutor Julius Musseau

Vous devez vous connecter pour publier un commentaire.