¿Alguna razón para preferir getClass () sobre instanceof al generar .equals ()?

Estoy usando Eclipse para generar .equals()y .hashCode(), y hay una opción etiquetada "Usar 'instancia de' para comparar tipos". El valor predeterminado es que esta opción no esté marcada y se use .getClass()para comparar tipos. ¿Hay alguna razón yo preferiría .getClass()más instanceof?

Sin usar instanceof:

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

Utilizando instanceof:

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

Por lo general, verifico la instanceofopción y luego entro y elimino el " if (obj == null)" cheque. (Es redundante ya que los objetos nulos siempre fallarán instanceof). ¿Hay alguna razón que sea una mala idea?

Si se utiliza instanceof, por lo que su equalsaplicación finalva a conservar el contrato de simetría del método: x.equals(y) == y.equals(x). Si finalparece restrictivo, examine cuidadosamente su noción de equivalencia de objetos para asegurarse de que sus implementaciones primordiales mantengan completamente el contrato establecido por la Objectclase.

Josh Bloch favorece su enfoque:

La razón por la que estoy a favor del instanceofenfoque es que cuando usa el getClassenfoque, tiene la restricción de que los objetos solo son iguales a otros objetos de la misma clase, el mismo tipo de tiempo de ejecución. Si extiende una clase y le agrega un par de métodos inocuos, verifique si algún objeto de la subclase es igual a un objeto de la superclase, incluso si los objetos son iguales en todos los aspectos importantes, obtendrá el sorprendente respuesta de que no son iguales. De hecho, esto viola una interpretación estricta del principio de sustitución de Liskov y puede conducir a un comportamiento muy sorprendente. En Java, es particularmente importante porque la mayoría de las colecciones (HashTable, etc.) se basan en el método igual. Si coloca un miembro de la superclase en una tabla hash como clave y luego lo busca utilizando una instancia de subclase, no lo encontrará, porque no son iguales.

Vea también esta respuesta SO .

El eficaz capítulo 3 de Java también cubre esto.

Angelika Langers Secrets of equals se mete en eso con una discusión larga y detallada de algunos ejemplos comunes y conocidos, incluidos Josh Bloch y Barbara Liskov, descubriendo un par de problemas en la mayoría de ellos. Ella también se mete en el instanceoffrente getClass. Alguna cita de ella

Conclusiones

Después de analizar los cuatro ejemplos elegidos arbitrariamente de implementaciones de equals (), ¿qué concluimos?

En primer lugar: hay dos formas sustancialmente diferentes de realizar la verificación de la coincidencia de tipos en una implementación de equals (). Una clase puede permitir la comparación de tipos mixtos entre objetos de superclases y subclases mediante el operador instanceof, o una clase puede tratar objetos de diferente tipo como no iguales mediante la prueba getClass (). Los ejemplos anteriores ilustran muy bien que las implementaciones de equals () usando getClass () son generalmente más robustas que aquellas implementaciones que usan instanceof.

La instancia de prueba es correcta solo para las clases finales o si al menos el método equals () es final en una superclase. Esto último implica esencialmente que ninguna subclase debe extender el estado de la superclase, sino que solo puede agregar funcionalidades o campos que son irrelevantes para el estado y el comportamiento del objeto, como los campos transitorios o estáticos.

Las implementaciones que utilizan la prueba getClass (), por otro lado, siempre cumplen con el contrato equals (); Son correctos y robustos. Sin embargo, son semánticamente muy diferentes de las implementaciones que usan la instancia de prueba. Las implementaciones que usan getClass () no permiten la comparación de objetos de subclase con superclase, ni siquiera cuando la subclase no agrega ningún campo y ni siquiera quisiera anular equals (). Tal extensión de clase "trivial" sería, por ejemplo, la adición de un método de impresión de depuración en una subclase definida exactamente para este propósito "trivial". Si la superclase prohíbe la comparación de tipo mixto mediante la comprobación getClass (), la extensión trivial no sería comparable a su superclase. Si este es un problema o no, depende completamente de la semántica de la clase y del propósito de la extensión.

La razón para usar getClasses garantizar la propiedad simétrica del equalscontrato. De igual a JavaDocs:

Es simétrico: para cualquier valor de referencia no nulo x e y, x.equals (y) debería devolver verdadero si y solo si y.equals (x) devuelve verdadero.

Al usar instanceof, es posible no ser simétrico. Considere el ejemplo: Perro extiende Animal. Animal's equalshace un instanceofchequeo de Animal. El perro equalshace un instanceofchequeo del perro. Dar Animal a y Perro d (con otros campos iguales):

a.equals(d) --> true
d.equals(a) --> false

Esto viola la propiedad simétrica.

Para seguir estrictamente el contrato de igualdad, se debe garantizar la simetría y, por lo tanto, la clase debe ser la misma.

Esto es algo de un debate religioso. Ambos enfoques tienen sus problemas.

• Use instanceof y nunca podrá agregar miembros significativos a las subclases.
• Usa getClass y violas el principio de sustitución de Liskov.

Bloch tiene otro consejo relevante en Effective Java Second Edition :

• Punto 17: Diseñe y documente para herencia o prohíbala

Corrígeme si estoy equivocado, pero getClass () será útil cuando quieras asegurarte de que tu instancia NO sea una subclase de la clase con la que estás comparando. Si usa instanceof en esa situación, NO puede saberlo porque:

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

Si desea asegurarse de que solo esa clase coincida, use getClass() ==. Si desea hacer coincidir las subclases, entonces instanceofes necesario.

Además, instanceof no coincidirá con un nulo, pero es seguro compararlo con un nulo. Por lo tanto, no tiene que comprobarlo nulo.

if ( ! (obj instanceof MyClass) ) { return false; }

Depende si considera si una subclase de una clase dada es igual a su padre.

class LastName
{
(...)
}


class FamilyName
extends LastName
{
(..)
}

aquí usaría 'instanceof', porque quiero que se compare un Apellido con un Nombre de Familia

class Organism
{
}

class Gorilla extends Organism
{
}

aquí usaría 'getClass', porque la clase ya dice que las dos instancias no son equivalentes.

instanceof funciona para instencias de la misma clase o subclases

Puede usarlo para probar si un objeto es una instancia de una clase, una instancia de una subclase o una instancia de una clase que implementa una interfaz particular.

ArryaList y RoleList son instancias de List

Mientras

getClass () == o.getClass () será verdadero solo si ambos objetos (this y o) pertenecen exactamente a la misma clase.

Entonces, dependiendo de lo que necesite comparar, podría usar uno u otro.

Si su lógica es: "Un objeto es igual a otro solo si ambos son de la misma clase", debe elegir "igual", que creo que es la mayoría de los casos.

Ambos métodos tienen sus problemas.

Si la subclase cambia la identidad, entonces necesita comparar sus clases reales. De lo contrario, viola la propiedad simétrica. Por ejemplo, diferentes tipos de Persons no deben considerarse equivalentes, incluso si tienen el mismo nombre.

Sin embargo, algunas subclases no cambian de identidad y deben usarse instanceof. Por ejemplo, si tenemos un montón de Shapeobjetos inmutables , entonces un Rectanglecon longitud y ancho de 1 debería ser igual a la unidad Square.

En la práctica, creo que el primer caso es más probable que sea cierto. Por lo general, la subclasificación es una parte fundamental de su identidad y ser exactamente como su padre, excepto que puede hacer una pequeña cosa, no lo hace igual.

En realidad, instancia de comprobar dónde pertenece un objeto a alguna jerarquía o no. Ej: El objeto del automóvil pertenece a la clase Vehical. Entonces, "nueva instancia de Car () de Vehical" devuelve verdadero. Y "new Car (). GetClass (). Equals (Vehical.class)" devuelve falso, aunque el objeto Car pertenece a la clase Vehical pero está categorizado como un tipo separado.