Aucune raison de préférer getClass() sur instanceof lors de la génération .equals()?

J'utilise Eclipse pour générer .equals() et .hashCode(), et il y a une option intitulée "Utilisation" instanceof "pour comparer les types". La valeur par défaut pour cette option pour être désactivée et l'utilisation .getClass() de comparer les types. Est-il une raison que je préférerais .getClass() sur instanceof?

Sans l'aide de instanceof:

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

À l'aide de instanceof:

if (obj == null)
  return false;
if (!(obj instanceof MyClass))
  return false;

J'ai l'habitude de vérifier la instanceof option, puis retirer le "if (obj == null)" vérifier. (Il est superflu, puisque les objets nuls échouera toujours instanceof.) Est-il une raison que c'est une mauvaise idée?

L'expression x instanceof SomeClass est faux si x est null. Par conséquent, la deuxième syntaxe se complique pas besoin de la valeur null est à vérifier.
Oui, le paragraphe immédiatement après l'extrait de code dit cela ainsi. C'est dans l'extrait de code parce que c'est ce que Eclipse génère.

InformationsquelleAutor Kip | 2009-02-27

95

Si vous utilisez instanceof, ce qui rend votre equals mise en œuvre final permettra de conserver la symétrie du contrat de la méthode: x.equals(y) == y.equals(x). Si final semble restrictif, examinez soigneusement votre notion de l'objet d'équivalence assurez-vous que votre principale implémentations de maintenir intégralement le contrat établi par la Object classe.
- exactement qui est venu à mon esprit quand j'ai lu le josh bloch citation ci-dessus. +1 🙂
- certainement la clé de la décision. la symétrie doit s'appliquer, et instanceof, il est très facile d'être asymétrique accidentellement
- Je voudrais aussi ajouter que "si final semble restrictif" (sur les deux equals et hashCode) puis utiliser getClass() l'égalité au lieu de instanceof afin de préserver la symétrie et la transitivité des exigences de la equals contrat.
InformationsquelleAutor erickson
167

Josh Bloch favorise votre approche:

La raison que je préfère la instanceof approche est que lorsque vous utilisez le getClass approche, vous avez la restriction que les objets ne sont égaux à d'autres objets de la même classe, le même type de temps. Si vous étendre une classe et ajouter un couple de méthodes inoffensives, puis vérifier pour voir si un objet de la sous-classe est égale à un objet de la classe supérieure, même si les objets sont égaux dans tous les aspects importants, vous obtiendrez une réponse surprenante qu'ils ne sont pas égaux. En fait, il y a violation d'une interprétation stricte de la principe de substitution de Liskov, et peut conduire à de très surprenant comportement. En Java, il est particulièrement important parce que la plupart des collections (HashTable, etc.) sont basés sur la méthode equals. Si vous mettez un membre de la super-classe dans une table de hachage de la clé et de le rechercher à l'aide d'une sous-classe de l'instance, vous ne le trouverez pas, parce qu'ils ne sont pas égaux.

Voir aussi cette SORTE de réponse.

Efficace Java chapitre 3 couvre aussi cette.
- +1 tout le monde fait java devrait lire ce livre au moins 10 fois!
- Le problème avec le instanceof approche est qu'elle casse l' "symétrique" de la propriété de l'Objet.equals() qu'il devient possible que x.equals(y) == true mais y'.est égal à(x) == faux si x.getClass() != y.getClass(). Je préfère ne pas briser cette propriété, sauf si absolument nécessaire (c'est à dire, en remplaçant equals() à la gestion des proxy ou des objets).
- Le instanceof approche est correcte si et seulement si la classe de base, définit ce qu'est l'égalité entre la sous-classe des objets devrait signifier. À l'aide de getClass ne viole pas le LSP, depuis le LSP simplement se rapporte à ce qui peut être fait avec les instances existantes--pas ce genre de cas peut être construit. La classe retournée par getClass est immuable la propriété d'une instance d'objet. Le LSP n'implique pas qu'il devrait être possible de créer une sous-classe lorsque cette propriété indique une autre catégorie que celle qui l'a créé.
InformationsquelleAutor Michael Myers
64

Angelika Langers Secrets d'égal à s'attire des ennuis avec une longue et détaillée pour quelques communes et les exemples bien connus, y compris par Josh Bloch et Barbara Liskov, la découverte d'un couple de problèmes dans la plupart d'entre eux. Elle a également fait dans la instanceof vs getClass. Certains n'en citer

Conclusions

Avoir disséqué les quatre arbitrairement choisi des exemples de mises en œuvre de equals() , que faisons-nous en conclure?

Tout d'abord: il y a deux substantiellement différentes façons d'effectuer la vérification pour le type de match dans une mise en œuvre de equals() . Une classe peut permettre mixte-type de comparaison entre les super - et la sous-classe d'objets à l'aide de l'opérateur instanceof, ou une classe peut traiter des objets de type différent que la non-égalité par le biais de la getClass() de test. Les exemples ci-dessus illustre bien que les implémentations de equals() à l'aide de getClass() sont généralement plus robustes que ceux des implémentations à l'aide de instanceof .

La instanceof test est correct uniquement pour la finale de classes ou si au moins la méthode equals() est définitive dans une super-classe. Le dernier essentiellement implique qu'aucune sous-classe doit étendre la classe mère de l'etat, mais peut seulement ajouter des fonctionnalités ou des champs qui ne sont pas pertinents pour l'état de l'objet et du comportement, comme transitoires ou des champs statiques.

Implémentations à l'aide de la getClass() test sur l'autre main toujours se conformer à la equals() contrat; ils sont corrects et robuste. Cependant, ils sont sémantiquement très différentes implémentations utiliser le instanceof test. Implémentations utilisant getClass() ne permet pas la comparaison des sous - avec de la super-classe des objets, pas même lorsque le sous-classe ne pas ajouter de champs et ne serait même pas de vouloir remplacer equals() . Tel un "trivial" extension de classe serait, par exemple, l'ajout d'un debug-méthode d'impression dans une sous-classe définie pour exactement ce "trivial" but. Si la superclasse interdit mixte-type de comparaison via le getClass() vérifier, puis le trivial extension ne serait pas comparable à sa super-classe. Si oui ou non il s'agit d'un problème dépend entièrement de la sémantique de la classe et le but de l'extension.

InformationsquelleAutor Johannes Schaub - litb
56

La raison d'utiliser des getClass est d'assurer la propriété symétrique de la equals contrat. D'égal à' la documentation Javadoc:

Elle est symétrique: pour toute non-null
les valeurs de référence x et y, x.equals(y)
doit retourner true si et seulement si
y.est égal à(x) renvoie la valeur true.

En utilisant instanceof, il est possible de ne pas être symétrique. Prenons l'exemple:
Le chien s'étend de l'Animal.
Animal equals un instanceof contrôle de l'Animal.
Chien equals un instanceof case du Chien.
Donner des Animaux un et le Chien d (avec d'autres champs de la même):
```
a.equals(d) --> true
d.equals(a) --> false
```
Cela viole la propriété symétrique.

De suivre strictement l'égalité du contrat, la symétrie doit être assurée, et donc de la classe doit être la même.
- C'est le premier clair et concis de réponse à cette question. Un exemple de code est une image vaut mille mots.
- J'ai été en passant par tous les autres détaillé des réponses util vous avez sauvé la journée.Simple, concis, élégant, et absolument la meilleure réponse à cette question.
- Il y a l'exigence de symétrie comme vous l'avez mentionné. Mais il y a aussi la "transitivité" exigence. Si a.equals(c) et b.equals(c), puis a.equals(b) (l'approche naïve de faire Dog.equals juste return super.equals(object) quand !(object instanceof Dog), mais vérifier les champs supplémentaires lorsque c'est un Chien instance ne serait pas en violation de la symétrie, mais serait en violation de transitivité)
- Pour être sûr, vous pouvez utiliser un getClass() contrôle d'égalité, ou vous pouvez utiliser un instanceof vérifier si faire de votre equals et hashCode méthodes final.
InformationsquelleAutor Steve Kuo
26

C'est quelque chose d'un débat religieux. Les deux approches ont leurs problèmes.
- Utilisation instanceof et vous ne pouvez pas ajouter beaucoup de membres de sous-classes.
- Utilisation getClass et vous violer le principe de substitution de Liskov.
Bloch a un autre morceau de conseils en Efficace Java Deuxième Édition:
- Article 17: la Conception et le document de l'héritage ou de l'interdire
- Rien sur l'utilisation de getClass contreviendrait à la LSP, à moins que la classe de base documenté un moyen par lequel il devrait être possible de faire les instances des différentes sous-classes qui permettent de comparer l'égalité. Ce LSP violation voyez-vous?
- Peut-être que devrait être reformulé comme Utiliser getClass et que vous le laissez sous-types en danger de LSP violations. Bloch a un exemple dans l'efficacité de Java a également discuté de ici. Sa justification est largement qu'il peut entraîner un comportement étonnant pour les développeurs, la mise en œuvre de sous-types qui n'ajoutez pas de l'état. Je prends le point de la documentation est essentielle.
- Le seul moment où les deux instances de classes distinctes devraient jamais se déclarer est égal si elles héritent d'une classe de base commune ou de l'interface qui définit la signification de l'égalité [une philosophie de Java appliquée, d'un air dubitatif à mon humble avis, pour certaines interfaces de collection]. À moins que la classe de base contrat dit que getClass() ne doit pas être considérée comme significative au-delà du fait que la classe en question est convertible à la classe de base, le retour de getClass() doit être considéré comme n'importe quel autre propriété qui doit correspondre pour les instances à l'égalité.
- Vous mélangé! Vous signifiait exactement le face: Utilisez getClass et vous ne pouvez pas ajouter des membres significatifs pour les sous-classes ; Utiliser instanceof et vous violer le principe de substitution de Liskov.
- Où instanceof_ est utilisé si une sous-classe membres ajoutés à l'est égal à contrat, ce serait violer le symétrique de l'égalité exigence. À l'aide de getClass sous-classes ne peut jamais être égal au type parent. Non pas que vous devriez être primordial est égal de toute façon, mais c'est le compromis si vous ne.
- "La conception et le document de l'héritage ou de l'interdire", je pense, est très important. Ma compréhension est que le seul moment où vous devez remplacer égale est si vous créez une valeur immuable type, auquel cas la classe doit être déclarée final. Depuis il n'y aura pas d'héritage, vous êtes libre d'implémenter equals en tant que de besoin. Dans le cas où vous permettant d'héritage, les objets doivent comparer par référence à l'égalité.
- Il n'y a rien de mal à avoir un héritables type dont l'héritage contrat spécifie que les références qui se déclarer égale les uns des autres, à partir de la classe point de vue, de se comporter de façon interchangeable; une telle exigence contractuelle interdirait encapsulé visible mutable état à n'importe quel niveau de la hiérarchie d'héritage si la classe est final.
InformationsquelleAutor McDowell

Corrigez-moi si je me trompe, mais getClass() sera utile lorsque vous voulez vous assurer que votre exemple n'est PAS une sous-classe de la classe que vous comparez avec les. Si vous utiliser instanceof dans cette situation, vous ne pouvez PAS le savoir car:

class A { }

class B extends A { }

Object oA = new A();
Object oB = new B();

oA instanceof A => true
oA instanceof B => false
oB instanceof A => true //<================ HERE
oB instanceof B => true

oA.getClass().equals(A.class) => true
oA.getClass().equals(B.class) => false
oB.getClass().equals(A.class) => false //<===============HERE
oB.getClass().equals(B.class) => true

Pour moi, c'est la raison

InformationsquelleAutor TraderJoeChicago

5

Si vous voulez vous assurer seulement que la classe correspondra alors utiliser getClass() ==. Si vous souhaitez faire correspondre les sous-classes puis instanceof est nécessaire.

Aussi, instanceof ne correspondent pas à l'encontre d'un nul mais il est sûr à comparer à une valeur null. Si vous n'avez pas à null vérifier.
```
if ( ! (obj instanceof MyClass) ) { return false; }
```
- Re votre deuxième point: Il a déjà été mentionné que dans la question. "J'ai l'habitude de vérifier la instanceof option, puis retirer le" if (obj == null)' vérifier."
- Oui, la prochaine fois, plus de lecture et de moins en moins de réponse.
InformationsquelleAutor Clint
5

Cela dépend si vous considérez si une sous-classe d'une classe donnée est égale à celle de son parent.
```
class LastName
{
(...)
}


class FamilyName
extends LastName
{
(..)
}
```
ici, je voudrais utiliser "instanceof", parce que je veux un Nom d'être comparé à Nomdefamille
```
class Organism
{
}

class Gorilla extends Organism
{
}
```
ici, je voudrais utiliser 'getClass", parce que la classe déjà dit que les deux instances ne sont pas équivalentes.

InformationsquelleAutor Pierre
3

instanceof fonctionne pour les instences de la même classe ou ses sous-classes

Vous pouvez l'utiliser pour tester si un objet est une instance d'une classe, une instance d'une sous-classe ou d'une instance d'une classe qui implémente une interface particulière.

ArryaList et RoleList sont à la fois instanceof Liste

Tout

getClass() == o.getClass() n'est vrai que si les deux objets ( ce et o ) appartient à la même classe.

Donc, en fonction de ce que vous avez besoin de comparer vous pouvez utiliser l'un ou l'autre.

Si votre logique est: "l'Un des objets est égale à d'autres que s'ils sont tous les deux de la même classe" vous devriez aller pour le "égaux", qui je pense est la plupart des cas.

InformationsquelleAutor OscarRyz
2

Les deux méthodes ont leurs problèmes.

Si la sous-classe des modifications de l'identité, alors vous avez besoin de comparer leurs classes réelles. Sinon, vous violez la propriété symétrique. Par exemple, les différents types de Persons ne doivent pas être considérées comme équivalentes, même si elles ont le même nom.

Cependant, certaines sous-classes ne changent pas d'identité, et il faut utiliser instanceof. Par exemple, si nous avons un tas de immuable Shape objets, puis un Rectangle avec la longueur et la largeur de 1 doit être égal à l'unité Square.

Dans la pratique, je pense que le premier cas est plus susceptible d'être vrai. Généralement, le sous-classement est une partie fondamentale de votre identité et d'être exactement comme votre parent, sauf que vous pouvez faire une petite chose ne vous rend pas égaux.

InformationsquelleAutor James
-1

Fait instanceof vérifier si un objet appartient à une hiérarchie ou pas. ex: la Voiture, l'objet appartient à Vehical classe. Donc, "new Voiture() de l'instance de Vehical" renvoie la valeur true. Et "new Voiture().getClass().equals(Vehical.class)" return false, si la Voiture objet appartient à Vehical classe, mais il est classé comme un type distinct.

InformationsquelleAutor Akash5288

Vous devez vous connecter pour publier un commentaire.