In­s­ta­n­ceof en Java: descubre cómo funciona el operador

El operador Java in­s­ta­n­ceof se puede usar para verificar la coin­ci­de­n­cia de un objeto y una clase y, de esta forma, evitar los mensajes de error. El operador pro­po­r­cio­na esta in­fo­r­ma­ción en forma de sentencia booleana, es decir, “verdadero” o “falso”. Se puede utilizar la co­m­pro­ba­ción para evitar mensajes de error.

¿Qué es in­s­ta­n­ceof en Java?

No todas las variables en Java son lo su­fi­cie­n­te­me­n­te es­pe­cí­fi­cas como para que se pueda discernir su na­tu­ra­le­za de inmediato. Sobre todo, cuando se utiliza el lenguaje de pro­gra­ma­ción para crear proyectos extensos con un gran número de variables, los datos de entrada, por ejemplo, pueden hacer que una variable al final se muestre como uno de varios objetos. Por esta razón, Java pone a di­s­po­si­ción el operador in­s­ta­n­ceof, el cual permite mostrar si la instancia de una variable de re­fe­re­n­cia co­rre­s­po­n­de realmente a una clase, subclase o interfaz. Si es así, el operador devuelve el valor booleano “true”. Si no coincide, la salida es “false” (falso).

Es fu­n­da­me­n­tal, sobre todo antes de convertir un objeto de­s­co­no­ci­do, realizar una ve­ri­fi­ca­ción con in­s­ta­n­ceof de Java. De este modo, se garantiza que el objeto pertenece a la clase asumida. Si se omite esta ve­ri­fi­ca­ción, puede pro­du­ci­r­se un Cla­s­s­Ca­s­tE­x­ce­p­tion, un error que resulta de convertir un objeto en una clase diferente. El mensaje de error puede generar confusión y co­m­pli­ca­cio­nes, es­pe­cia­l­me­n­te en código más largo, por lo que es aco­n­se­ja­ble realizar una ve­ri­fi­ca­ción pre­ve­n­ti­va.

Fu­n­cio­na­li­dad y sintaxis

Al ejecutar el operador in­s­ta­n­ceof en Java, se compara una variable de re­fe­re­n­cia con una clase es­pe­cí­fi­ca también indicada. El operador se limita a de­te­r­mi­nar si hay coin­ci­de­n­cia o no, sin incluir más in­fo­r­ma­ción sobre la na­tu­ra­le­za del objeto o de la clase. La sintaxis es muy sencilla. Muestra el siguiente aspecto:

(objeto) instanceof (clase)

Si (objeto) es una instancia de (clase), se muestra “true”. Si no lo es, se muestra “false”.

Ejemplo simple de un operador in­s­ta­n­ceof en Java

La forma más sencilla de mostrar el fu­n­cio­na­mie­n­to de in­s­ta­n­ceof en Java es con un breve ejemplo. Para ello, primero se crea una clase llamada “Animal”.

public class Animal {
}

En el siguiente paso, se amplía esta clase con una subclase llamada “Gato”.

public class Gato extends Animal {
}

Ahora puedes utilizar in­s­ta­n­ceof de Java para comprobar si una instancia de “Gato” pertenece a la clase “Animal”. Para ello, se utilizan las si­guie­n­tes líneas, que se imprimen con el comando de Java System.out.println:

public class Animal {}
public class Gato extends Animal {
public static void main(String args []{
Gato Gato = new Gato();
System.out.println(Gato instanceof Animal);
}
}

En la consola, se debería leer lo siguiente:

true

Múltiples niveles y la clase objeto

Este principio también funciona con la clase Main y otras subclases. Se muestra en un ejemplo con varios niveles, en el que el operador in­s­ta­n­ceof de Java se amplía con if-else. El texto tras las dos barras son co­me­n­ta­rios Java que sirven úni­ca­me­n­te para aclarar cada paso del proceso, pero que no tienen impacto en el resultado final del código.

// Clase 1
// Superclase
public class Animal {
}
// clase 2
// subclase
class Gato extends Animal {
}
// clase 3
// Clase Main
class Main {
public static void main(String[] args)
Gato Gato1 = new Gato();
if (Gato1 instanceof Gato)
	System.out.println ("Gato1 es una instancia de Gato");
else
	System.out.println ("Gato1 NO es una instancia de Gato");
if (Gato1 instanceof Animal)
	System.out.println ("Gato1 es una instancia de Animal");
else
	System.out.println ("Gato1 NO es una instancia de Animal");
if (Gato1 instanceof Object)
	System.out.println ("Gato1 es una instancia de Object");
else
	System.out.println ("Gato1 NO es una instancia de Object");
	}
}

En el ejemplo, se quiere saber si “Gato1” es una instancia de la clase “Gato” y de la su­pe­r­cla­se “Animal”. En las dos consultas se obtiene “true”. Como Object o la clase “java.lang.Object” está en la parte superior de la jerarquía, “Gatot1” también es una instancia de Object. Por tanto, el operador in­s­ta­n­ceof de Java siempre mostrará “true” si se utiliza con la clase Object. El resultado final del código se muestra:

Gato1 es una instancia de Gato
Gato1 es una instancia de Animal
Gato1 es una instancia de Object

Salida para un valor nulo

Si una variable tiene el valor 0, es decir, no contiene ningún objeto, el operador in­s­ta­n­ceof de Java muestra “false” au­to­má­ti­ca­me­n­te. En el siguiente ejemplo, lo puedes comprobar:

class Gato {
}
class Main {
public static void main(String[] args)
{
Gato Gato2 = null;
if (Gato2 instanceof Gato)
	System.out.println ("Gato2 es una instancia de Gato");
else
	System.out.println ("Gato2 NO es una instancia de Gato");
	}
}

El resultado final del código se muestra:

Gato2 NO es una instancia de Gato

Las su­pe­r­cla­ses no son una instancia de una clase inferior

Mientras que en la jerarquía los objetos de las subclases también pe­r­te­ne­cen a las clases su­pe­rio­res, este principio no funciona a la inversa. Se puede ver en el siguiente ejemplo:

class Animal {
}
class Gato extends Animal {
}
class Main {
public static void main(String[] args)
{
Animal Bello = new Animal ();
if (Bello instanceof gato)
	System.out.println ("Bello es una instancia de Gato");
else
	System.out.println ("Bello NO es una instancia de Gato");
	}
}

La salida en este caso es

Bello NO es una instancia de Gato

Mensaje de error por falta de relación

Si no hay relación entre el objeto y la clase, se muestra un mensaje de error. Para mostrarlo, se crea a co­n­ti­nua­ción una clase llamada “Perro”, que pertenece a la su­pe­r­cla­se “Animal”, pero no tiene relación con “Gato”.

class Perro implements Animal {
}
class Main {
public static void main(String[] args)
{
Gato Gato3 = new Gato ();
System.out.println (Gato3 instanceof Perro);
	}
}

En este caso, recibimos un mensaje de error que indica que no hay conexión entre las clases “Gato”“ y “Perro”. Este mensaje tiene el siguiente aspecto:

java.lang.Error: Unresolved compilation problem:
Incompatible conditional operand types Gato and Perro