¿Cuál es la instanceof operador y para que sirve? He visto cosas como

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

Pero nada de eso tenía sentido para mí. He hecho mi investigación, sino que vino solamente con ejemplos sin ningún tipo de explicaciones.

  • No hay nada de malo con preguntas aquí, pero si usted está aprendiendo Java es posible que desee obtener un libro. Cualquier decente Java libro tiene la respuesta a esta pregunta y la siguiente 1000 vas a tener.
  • Un operador tiene muchos usos específicos. Esta sería una pregunta específica si se le pidió una explicación de uno de los ejemplos que no tienen sentido para usted.
  • Las siguientes respuestas son correctas, sin embargo tenga en cuenta que instanceof es una abusado de operador de 9 de cada 10 veces que puede ser reemplazada por un adecuado uso de polimorfismo (no siempre, pero a menudo)
  • Me gustaría ir a uno más que Richard: yo NUNCA he visto un uso válido de instanceof. Sólo es útil para una rápida hacks en la parte superior de mal diseñado código. Si no te gusta la programación orientada a objetos, escribir en otro idioma (hay un montón). Simplemente diga «no» a instanceof!
  • Hay una buena alternativa a instanceof al reemplazar equals?
  • Creo que Scott y Richard están tomando una regla específica de escritura religiosa y de su aplicación demasiado amplia de la vida cotidiana. 🙂 Instanceof sólo debe ser utilizado cuando se está obligado a trabajar con objetos de tipo desconocido. Si usted tiene que utilizar instanceof con los tipos conocidos, entonces es un signo de mal diseño. Como de costumbre, los textos religiosos, se olvidan de que a veces la vida nos obliga a utilizar mal el código escrito por la gente mala y no hay absolutamente nada que podamos hacer al respecto (aparte de usar instanceof). Por lo tanto, instanceof está bien dentro de el método equals.

InformationsquelleAutor Ben | 2011-09-05

15 Comentarios

  1. 222

    instanceof palabra clave es una operador binario utiliza para comprobar si un objeto (instancia) es un subtipo de un Tipo dado.

    Imaginar:

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

    Imaginar un dog objeto, creado con Object dog = new Dog(), entonces:

    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 es debido a que Dog no es ni un subtipo ni un supertipo de Cat, y también no implementarlo.

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

    Cosas a tener en cuenta: expressionThatIsNull instanceof T es falsa para todos los Tipos de T.

    Feliz codificación.

    • Sólo traté de – Object dog = new Dog(); System.out.println(dog instanceof Cat);. Esto compila bien y se imprime false. El compilador no permite determinar en tiempo de compilación que dog puede ser un Gato (por las reglas de la JLS)
    • Usted cometió un error cuando trató de eso. Para aquel que se pregunta: JLS Sección 15.20.2 es el que usted está buscando. Por poco no laborable ejemplo: boolean b = "foo" instanceof Integer;
    • Usted necesita leer la respuesta de nuevo. La respuesta es Object indirect = ...; if (indirect instanceof Something). No se trata de if (literal instanceof Something) como usted parece estar asumiendo.
    • Oh, justo, debo haber saltado la Object dog parte. Mi mal!
    • dog instanceof Cat // does not even compile!(porque es una clase). Si Cat fueron una interfaz sería compilar.
  2. 44

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

    Piense en ello de esta manera. Dicen que todas las casas de la cuadra fueron construidos a partir de los mismos planos. Diez casas (objetos), un conjunto de planos (definición de la clase).

    instanceof es una herramienta útil cuando tienes una colección de objetos y no está seguro de lo que son. Supongamos que tenemos una colección de controles en un formulario. Quieres leer el estado de activación de cualquier casillas de verificación están ahí, pero no se puede pedir a un viejo y simple objeto para su estado de activación. En su lugar, tendría que ver si cada objeto es una casilla de verificación, y si es que, fundido a una casilla de verificación y comprobación de sus propiedades.

    if (obj instanceof Checkbox)
    {
        Checkbox cb = (Checkbox)obj;
        boolean state = cb.getState();
    }
    • Es decir, el uso de instanceof puede hacer es seguro abatido.
  3. 29

    Como se describe en la este sitio:

    La instanceof operador puede ser utilizado 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 referencia nula variable/expresión
    devuelve false.

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

    Desde una subclase es un ‘tipo’ de su superclase, puede utilizar la
    instanceof para comprobar 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!

  4. 14

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

    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
  5. 4

    Como se ha mencionado en otras respuestas, el canónico, el uso típico de instanceof es para comprobar si un identificador de referencia a una más tipo 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
    }

    Nota sin embargo, que el tipo de la parte izquierda de la expresión debe ser un padre tipo de la mano derecha de la expresión (ver JLS 15.20.2 y Java Puzzlers, #50, pp114). Por ejemplo, el siguiente error de compilación:

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

    Esta falla al 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 padre de String. OTOH, esto compila perfectamente y se 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); 
        }
    }
    • Gracias por el enlace a la especificación!
  6. 1
    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 
    
        }
    }
  7. 1

    Puede ser utilizado como una abreviación en igualdad de verificación.

    Por lo que este código

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

    Puede ser escrito como

    if(ob instanceOf ClassA) {
    }
  8. 1

    La mayoría de la gente tiene correctamente explicó el «Qué» de esta cuestión, pero nadie se explica el «Cómo» correctamente.

    Así que aquí está un ejemplo 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

    Salidas:

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

    La razón de error del compilador cuando se comparan s con StringBuffer está muy bien explicado en docs:

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

    que implica la LHS, debe ser una instancia de RHS o de una Clase que sea implementa RHS o se extiende RHS.

    Cómo usar instanceof entonces?

    Ya que cada Clase se extiende Objeto, tipo de fundición de la LHS a objeto siempre trabajar en 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");

    Salidas:

    Not an instance of StringBuffer
    • En el último ejemplo, ¿por qué es retornar «No de una instancia de StringBuffer»? Desde que typecasted s a Objeto en la PREPA y la comprobación de si se trata de una instanceof RHS, if ((Object)s instanceof StringBuffer) System.out.println("Instance of StringBuffer"); //shouldn't this be true, ya que somos el encasillamiento s a Objeto?
    • Porque s es una referencia a objeto String (Java emplea polimorfismo dinámico a diferencia de C++) y la Cadena no es una subclase de StringBuffer.
  9. 0

    Instancia de la palabra clave es útil cuando usted desea saber objeto en particular de la instancia .

    Supongamos que se lance la excepción, y cuando tienes la captura, a continuación, realizar la suma de operación personalizados y, a continuación, seguir de nuevo como por su lógica (lanza o de registro, etc)

    Ejemplo :
    1) el Usuario personalizado creado excepción «InvalidExtensionsException» y tirar como por la lógica de

    2) Ahora en el bloque catch
    catch (Exception e) {
    realizar la suma lógica si tipo de excepción es «InvalidExtensionsException»

    InvalidExtensionsException InvalidException =(InvalidExtensionsException)e;

    3) Si usted no está de comprobación de instancia y tipo de excepción es la excepción de puntero Nulo el código se va a romper.

    Por lo que su lógica debe estar en el interior de la instancia de
    si (e instanceof InvalidExtensionsException){
    InvalidExtensionsException InvalidException =(InvalidExtensionsException)e;
    }

    Ejemplo anterior es incorrecta codificación de la práctica, sin Embargo, este ejemplo es ayudarle a comprender el uso de la instancia de ella.

  10. -1
    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);
    }
    }  
    • No publiques código sólo respuestas en StackOverflow. Por favor, seguir adelante y añadir una explicación.
  11. -2

    Muy sencillo ejemplo de código:

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

    Tener cuidado aquí. En el ejemplo anterior, si Class1 es Objeto, la primera comparación siempre será verdad. Así que, como con excepciones, en orden jerárquico los asuntos!

  12. -2

    Usted puede utilizar el Mapa para hacer superior de abstracción sobre la instancia de

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

    Luego de haber dicho mapa añadir algunas líneas de acción para ti:

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

    A continuación, tener un Objeto del que no se conoce el tipo que usted podría conseguir de acción específicos a partir de ese mapa:

    actions.get(someObject).accept(someObject)
  13. -2

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

    La instanceof es también conocido como el tipo de operador de comparación debido a que se 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 tiene valor null, se devuelve false.

Dejar respuesta

Please enter your comment!
Please enter your name here