Operador de instancia de Java

Programación

1. Introducción

En este tutorial rápido, aprenderemos sobre el operador instanceof en Java.

2. ¿Cuál es la instancia de Operador?

instanceof es un operador binario que se usa para probar si un objeto es de un tipo determinado. El resultado de la operación es verdadero o falso . También se conoce como operador de comparación de tipos porque compara la instancia con el tipo.

Antes de lanzar un objeto desconocido, siempre debe usarse la instancia de verificación. Hacer esto ayuda a evitar ClassCastException en tiempo de ejecución.

La instancia de la sintaxis básica del operador es:

(object) instanceof (type)

Veamos un ejemplo básico para el operador instanceof . Primero, creemos una clase Round :

public class Round { // implementation details }

A continuación, creemos una clase Ring que se extienda Round :

public class Ring extends Round { // implementation details }

Podemos usar instanceof para verificar si una instancia de Ring es de tipo Round :

@Test public void givenWhenInstanceIsCorrect_thenReturnTrue() { Ring ring = new Ring(); Assert.assertTrue(ring instanceof Round); }

3. ¿Cómo funciona la instancia de Operador?

El operador instanceof funciona según el principio de la relación es-a . El concepto de una relación es-a se basa en la herencia de clases o la implementación de la interfaz.

Para demostrar esto, creemos una interfaz Shape :

public interface Shape { // implementation details }

Creemos también una clase Circle que implemente la interfaz Shape y también extienda la clase Round :

public class Circle extends Round implements Shape { // implementation details }

El resultado de la instancia será verdadero si el objeto es una instancia del tipo:

@Test public void givenWhenObjectIsInstanceOfType_thenReturnTrue() { Circle circle = new Circle(); Assert.assertTrue(circle instanceof Circle); }

También será cierto si el objeto es una instancia de una subclase del tipo:

@Test public void giveWhenInstanceIsOfSubtype_thenReturnTrue() { Circle circle = new Circle(); Assert.assertTrue(circle instanceof Round); }

Si el tipo es una interfaz, devolverá verdadero si el objeto implementa la interfaz:

@Test public void givenWhenTypeIsInterface_thenReturnTrue() { Circle circle = new Circle(); Assert.assertTrue(circle instanceof Shape); }

El operador instanceof no se puede utilizar si no hay relación entre el objeto que se está comparando y el tipo con el que se está comparando.

Creemos una nueva clase Triangle que implemente Shape pero no tenga relación con Circle :

public class Triangle implements Shape { // implementation details }

Ahora, si usamos instanceof para verificar si un círculo es una instancia de Triángulo :

@Test public void givenWhenComparingClassInDiffHierarchy_thenCompilationError() { Circle circle = new Circle(); Assert.assertFalse(circle instanceof Triangle); }

Obtendremos un error de compilación porque no hay relación entre las clases Circle y Triangle :

java.lang.Error: Unresolved compilation problem: Incompatible conditional operand types Circle and Triangle

4. Usando instanceof con el tipo de objeto

En Java, cada clase hereda implícitamente de la clase Object . Por lo tanto, el uso del operador instanceof con el tipo de objeto siempre se evaluará como verdadero :

@Test public void givenWhenTypeIsOfObjectType_thenReturnTrue() { Thread thread = new Thread(); Assert.assertTrue(thread instanceof Object); }

5. Uso del operador instanceof cuando un objeto es nulo

Si usamos el operador instanceof en cualquier objeto que sea nulo , devuelve falso . Además, no se necesita una verificación nula cuando se usa un operador instanceof .

@Test public void givenWhenInstanceValueIsNull_thenReturnFalse() { Circle circle = null; Assert.assertFalse(circle instanceof Round); }

6. instancia de y genéricos

Las pruebas de instancia y las conversiones dependen de la inspección de la información de tipo en tiempo de ejecución. Por lo tanto, no podemos usar instanceof junto con tipos genéricos borrados .

Por ejemplo, si intentamos compilar el siguiente fragmento:

public static  void sort(List collection) { if (collection instanceof List) { // sort strings differently } // omitted }

Entonces obtenemos este error de compilación:

error: illegal generic type for instanceof if (collection instanceof List) { ^

Técnicamente hablando, solo podemos usar instanceof junto con reifiedtipos en Java. Un tipo se reifica si su información de tipo está presente en tiempo de ejecución.

Los tipos reificados en Java son los siguientes:

  • Tipos primitivos como int
  • Clases e interfaces no genéricas como String o Random
  • Tipos genéricos en los que todos los tipos son comodines ilimitados como Set o Map
  • Tipos sin formato como List o HashMap
  • Matrices de otros tipos confiables como String [], List [] o Map []

Debido a que los parámetros de tipo genérico no están reificados, tampoco podemos usarlos:

public static  boolean isOfType(Object input) { return input instanceof T; // won't compile }

Sin embargo, es posible probar con algo como List :

if (collection instanceof List) { // do something }

7. Conclusión

En este tutorial, hemos aprendido sobre el operador instanceof y cómo usarlo. Los ejemplos de código completos están disponibles en GitHub.