que - ¿Para qué se utiliza el operador ''instanceof'' en Java?

interfaz java

Question

¿Para qué se utiliza el operador instanceof ? He visto cosas como

if (source instanceof Button) {
//...
} else {
//...
}

Pero nada de eso tenía sentido para mí. Hice mi investigación, pero surgió solo con ejemplos sin ninguna explicación.

Answer 1

El operador instanceof compara un objeto con un tipo especificado. 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.

http://download.oracle.com/javase/tutorial/java/nutsandbolts/op2.html

Answer 2

Como se describe en este sitio :

El operador instanceof se puede usar para probar si un objeto es de un tipo específico ...

if (objectReference instanceof type)

Un ejemplo rápido:

String s = "Hello World!"
return s instanceof String;
//result --> true

Sin embargo, la aplicación de instanceof en una variable / expresión de referencia nula devuelve falso.

String s = null;
return s instanceof String;
//result --> false

Como una subclase es un ''tipo'' de su superclase, puede usar el instanceof para verificar esto ...

class Parent {
public Parent() {}
}
class Child extends Parent {
public Child() {
super();
}
}
public class Main {
public static void main(String[] args) {
Child child = new Child();
System.out.println( child instanceof Parent );
}
}
//result --> true

¡Espero que esto ayude!

Answer 3

Como se menciona en otras respuestas, el uso típico canónico de instanceof es para verificar si un identificador se refiere a un tipo más específico. Ejemplo:

Object someobject = ... some code which gets something that might be a button ...
if (someobject instanceof Button) {
// then if someobject is in fact a button this block gets executed
} else {
// otherwise execute this block
}

Sin embargo, tenga en cuenta que el tipo de expresión de la izquierda debe ser un tipo principal de la expresión de la mano derecha (consulte JLS 15.20.2 y Puzzlers de Java, # 50, pp114 ). Por ejemplo, no se compilará lo siguiente:

public class Test {
public static void main(String [] args) {
System.out.println(new Test() instanceof String); // will fail to compile
}
}

Esto no se puede compilar con el mensaje:

Test.java:6: error: inconvertible types
System.out.println(t instanceof String);
^
required: String
found: Test
1 error

Como Test no es una clase principal de String . OTOH, esto compila perfectamente e imprime false como se esperaba:

public class Test {
public static void main(String [] args) {
Object t = new Test();
// compiles fine since Object is a parent class to String
System.out.println(t instanceof String);
}
}

Answer 4

Ejemplo de código muy simple:

If (object1 instanceof Class1) {
// do something
} else if (object1 instanceof Class2) {
// do something different
}

Ten cuidado aquí. En el ejemplo anterior, si Class1 es Object, la primera comparación siempre será verdadera. Entonces, al igual que con las excepciones, ¡el orden jerárquico importa!

Answer 5

El operador instanceof se usa para verificar si el objeto es una instancia del tipo especificado. (clase o subclase o interfaz).

El instanceof también se conoce como operador de comparación de tipos porque compara la instancia con el tipo. Devuelve verdadero o falso.

class Simple1 {
public static void main(String args[]) {
Simple1 s=new Simple1();
System.out.println(s instanceof Simple1); //true
}
}

Si aplicamos el operador instanceof con cualquier variable que tenga valor nulo, devuelve falso.

Answer 6

Es un operador que devuelve verdadero si el lado izquierdo de la expresión es una instancia del nombre de clase en el lado derecho.

Piensa en ello de esta manera. Supongamos que todas las casas de su bloque se construyeron con los mismos planos. Diez casas (objetos), un conjunto de planos (definición de clase).

instanceof es una herramienta útil cuando tienes una colección de objetos y no estás seguro de cuáles son. Supongamos que tiene una colección de controles en un formulario. Desea leer el estado comprobado de las casillas de verificación que están allí, pero no puede pedir un objeto antiguo simple para su estado verificado. En su lugar, verá si cada objeto es una casilla de verificación, y si lo está, transfiéralo a una casilla de verificación y verifique sus propiedades.

if (obj instanceof Checkbox)
{
Checkbox cb = (Checkbox)obj;
boolean state = cb.getState();
}

Answer 7

Este operador le permite determinar el tipo de un objeto. Devuelve un valor boolean .

Por ejemplo

package test;
import java.util.Date;
import java.util.Map;
import java.util.HashMap;
public class instanceoftest
{
public static void main(String args[])
{
Map m=new HashMap();
System.out.println("Returns a boolean value "+(m instanceof Map));
System.out.println("Returns a boolean value "+(m instanceof HashMap));
System.out.println("Returns a boolean value "+(m instanceof Object));
System.out.println("Returns a boolean value "+(m instanceof Date));
}
}

la salida es:

Returns a boolean value true
Returns a boolean value true
Returns a boolean value true
Returns a boolean value false

Answer 8

Este operador se usa solo para las variables de referencia del objeto. El operador verifica si el objeto es de un tipo particular (tipo de clase o tipo de interfaz). instanceof operador de instanceof está escrito como:

( Object reference variable ) instanceof (class/interface type)

Si el objeto referido por la variable en el lado izquierdo del operador pasa el control "IS-A" para el tipo de clase / interfaz en el lado derecho, entonces el resultado será verdadero.

Answer 9

La instancia de palabra clave es útil cuando desea conocer la instancia de un objeto particular.

Suponga que está lanzando una excepción y cuando tiene captura, realice una operación personalizada de suma y luego continúe según su lógica (tira o registra, etc.)

Ejemplo: 1) Excepción personalizada creada por el usuario "InvalidExtensionsException" y lanzarla según la lógica

2) Ahora en la captura del bloque catch (Exception e) {realiza la lógica de suma si el tipo de excepción es "InvalidExtensionsException"

InvalidExtensionsException InvalidException =(InvalidExtensionsException)e;

3) Si no está verificando la instancia y el tipo de excepción es la excepción de puntero nulo, su código se romperá.

Por lo tanto, su lógica debe estar dentro de la instancia de if (instancia e InvalidExtensionsException) {InvalidExtensionsException InvalidException = (InvalidExtensionsException) e; }

El ejemplo anterior es la práctica de codificación errónea. Sin embargo, este ejemplo lo ayuda a comprender el uso de la instancia de la misma.

Answer 10

Puede usar Map para hacer una mayor abstracción en la instancia de

private final Map<Class, Consumer<String>> actions = new HashMap<>();

Luego, tener ese mapa le agrega algo de acción:

actions.put(String.class, new Consumer<String>() {
@Override
public void accept(String s) {
System.out.println("action for String");
}
};

Luego tener un Objeto de tipo desconocido podría obtener acción específica de ese mapa:

actions.get(someObject).accept(someObject)

Answer 11

Puede usarse como una taquigrafía en el control de igualdad.

Entonces este código

if(ob != null && this.getClass() == ob.getClass) {
}

Se puede escribir como

if(ob instanceOf ClassA) {
}

Answer 12

Si source es una variable de object , instanceof es una forma de verificar si es un Button o no.

Answer 13

instanceof palabra clave instanceof es un operador binario que se usa para probar si un objeto (instancia) es un subtipo de un tipo dado.

Imagina:

interface Domestic {}
class Animal {}
class Dog extends Animal implements Domestic {}
class Cat extends Animal implements Domestic {}

Imagine un objeto de dog , creado con Object dog = new Dog() , luego:

dog instanceof Domestic // true - Dog implements Domestic
dog instanceof Animal // true - Dog extends Animal
dog instanceof Dog // true - Dog is Dog
dog instanceof Object // true - Object is the parent type of all objects

Sin embargo, con Object animal = new Animal(); ,

animal instanceof Dog // false

porque Animal es un supertipo de Dog y posiblemente menos "refinado".

Y,

dog instanceof Cat // does not even compile!

Esto se debe a que Dog no es un subtipo ni un supertipo de Cat , y tampoco lo implementa.

Tenga en cuenta que la variable utilizada para el dog arriba es de tipo Object . Esto es para mostrar instanceof es una operación en tiempo de ejecución y nos lleva a un / el caso de uso: para reaccionar de manera diferente en función de un tipo de objetos en tiempo de ejecución .

Cosas a tener en cuenta: expressionThatIsNull instanceof T es falso para todos los tipos T

Feliz codificación.

Answer 14

public class Animal{ float age; }
public class Lion extends Animal { int claws;}
public class Jungle {
public static void main(String args[]) {
Animal animal = new Animal();
Animal animal2 = new Lion();
Lion lion = new Lion();
Animal animal3 = new Animal();
Lion lion2 = new Animal(); //won''t compile (can''t reference super class object with sub class reference variable)
if(animal instanceof Lion) //false
if(animal2 instanceof Lion) //true
if(lion insanceof Lion) //true
if(animal3 instanceof Animal) //true
}
}