¿Para qué se utiliza el operador ‘instanceof’ en Java?

¿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.

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 reactjsr 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 encoding.

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 checkbox, y si lo está, transfiéralo a una checkbox y verifique sus propiedades.

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

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!

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

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 

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 comstackrá 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 comstackr 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 comstack 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); } } 

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.

 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 } } 

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) { } 

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

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 sum 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 sum 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 encoding errónea. Sin embargo, este ejemplo lo ayuda a comprender el uso de la instancia de la misma.

La mayoría de las personas explicaron correctamente el “qué” de esta pregunta, pero nadie explicó “cómo” correctamente.

Así que aquí hay una ilustración simple:

 String s = new String("Hello"); if (s instanceof String) System.out.println("s is instance of String"); // True if (s instanceof Object) System.out.println("s is instance of Object"); // True //if (s instanceof StringBuffer) System.out.println("s is instance of StringBuffer"); // Compile error Object o = (Object)s; if (o instanceof StringBuffer) System.out.println("o is instance of StringBuffer"); //No error, returns False else System.out.println("Not an instance of StringBuffer"); // if (o instanceof String) System.out.println("o is instance of String"); //True 

Productos:

 s is instance of String s is instance of Object Not an instance of StringBuffer o is instance of String 

El motivo del error del comstackdor al comparar s con StringBuffer está bien explicado en documentos :

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.

lo que implica que LHS debe ser una instancia de RHS o de una Clase que implementa RHS o extiende RHS.

¿Cómo usar el uso de instanceof entonces?
Dado que cada Clase extiende Objeto, el tipo de conversión LHS al objeto siempre funcionará a su favor:

 String s = new String("Hello"); if ((Object)s instanceof StringBuffer) System.out.println("Instance of StringBuffer"); //No compiler error now :) else System.out.println("Not an instance of StringBuffer"); 

Productos:

 Not an instance of StringBuffer 

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

 private final Map> actions = new HashMap<>(); 

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

 actions.put(String.class, new Consumer() { @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) 
 class Test48{ public static void main (String args[]){ Object Obj=new Hello(); //Hello obj=new Hello; System.out.println(Obj instanceof String); System.out.println(Obj instanceof Hello); System.out.println(Obj instanceof Object); Hello h=null; System.out.println(h instanceof Hello); System.out.println(h instanceof Object); } } 

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!

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.