0Pricing
Java Academy · Lección

El operador instanceof

Use instanceof para comprobar los tipos de objeto antes de realizar conversiones y evitar ClassCastException.

El operador instanceof es una lección gratuita de Java Academy en CoddyKit. Esta es la lección 3 de 4. Puedes leer la lección completa abajo gratuitamente — luego la practicas en el navegador con un editor de código integrado y un tutor de IA 24/7. Forma parte de la ruta de aprendizaje de Java Academy, y tu progreso se sincroniza en la web y la app de CoddyKit. El curso de Java Academy incluye 4 lecciones en total.

El operador instanceof

El operador instanceof comprueba en tiempo de ejecución si un objeto es una instancia de un tipo determinado. Devuelve true o false y evita ClassCastException antes de realizar la conversión.

Uso básico de instanceof

Use instanceof para comprobar el tipo de un objeto en tiempo de ejecución antes de realizar una conversión segura.

Object obj = "Hello, Java!";

if (obj instanceof String) {
    String s = (String) obj;
    System.out.println(s.toUpperCase()); // HELLO, JAVA!
}

Object num = Integer.valueOf(42);
System.out.println(num instanceof Integer); // true
System.out.println(num instanceof String);  // false

instanceof con herencia

instanceof devuelve true si el objeto es una instancia de la clase o de cualquier subclase (o de cualquier interfaz que implemente).

class Animal {}
class Dog extends Animal {}
class Cat extends Animal {}

Animal a = new Dog();

System.out.println(a instanceof Animal); // true
System.out.println(a instanceof Dog);    // true
System.out.println(a instanceof Cat);    // false

Pattern Matching con instanceof (Java 16+)

Java 16 introdujo el pattern matching para instanceof: puede declarar una variable de vinculación en la misma expresión, lo que elimina la conversión explícita.

Object shape = "circle";

// Old way
if (shape instanceof String) {
    String s = (String) shape;
    System.out.println(s.length());
}

// New way (Java 16+) — binding variable 's' is in scope
if (shape instanceof String s) {
    System.out.println(s.length()); // 6
}

Pattern Matching en un método

El pattern matching permite realizar una selección basada en tipos de forma clara y segura. La variable de vinculación solo está dentro del ámbito en el que se sabe que la condición es verdadera.

sealed interface Shape permits Circle, Rectangle {}
record Circle(double radius) implements Shape {}
record Rectangle(double width, double height) implements Shape {}

static double area(Shape s) {
    if (s instanceof Circle c) {
        return Math.PI * c.radius() * c.radius();
    } else if (s instanceof Rectangle r) {
        return r.width() * r.height();
    }
    throw new IllegalArgumentException("Unknown shape");
}

System.out.println(area(new Circle(5)));         // 78.53...
System.out.println(area(new Rectangle(4, 6)));   // 24.0

instanceof con null

null instanceof AnyType siempre devuelve false; nunca lanza una excepción. Esto hace que instanceof sea una forma segura frente a null de comprobar un tipo antes de realizar una conversión.

String s = null;
System.out.println(s instanceof String); // false (not NPE)

Object o = null;
if (o instanceof Number n) {
    System.out.println(n.intValue());
} else {
    System.out.println("Not a number (or null)"); // prints this
}

Expresiones switch y pattern matching

Java 21 amplía el pattern matching a las expresiones switch, lo que permite realizar una selección basada en tipos de forma clara, sin encadenar bloques if-else.

static String describe(Object obj) {
    return switch (obj) {
        case Integer i -> "Integer: " + i;
        case Double d  -> "Double: " + d;
        case String s  -> "String of length " + s.length();
        case null      -> "null value";
        default        -> "Unknown: " + obj.getClass().getSimpleName();
    };
}

System.out.println(describe(42));       // Integer: 42
System.out.println(describe(3.14));     // Double: 3.14
System.out.println(describe("hello")); // String of length 5
System.out.println(describe(null));     // null value

ClassCastException sin instanceof

Realizar una conversión sin comprobar antes el tipo provoca ClassCastException en tiempo de ejecución; es un error habitual en código heredado que el pattern matching ayuda a evitar.

Object obj = "I am a String";

try {
    Integer i = (Integer) obj; // ClassCastException!
} catch (ClassCastException e) {
    System.out.println("Cannot cast String to Integer");
}

// Safe version
if (obj instanceof Integer i) {
    System.out.println("Is integer: " + i);
} else {
    System.out.println("Not an integer");
}

Práctica: procesar una lista heterogénea

Un caso de uso real consiste en procesar una lista heterogénea de objetos mediante pattern matching.

import java.util.List;

List<Object> events = List.of(
    "User login", 42, 3.14, "Payment processed", 100
);

double numericSum = 0;
for (Object e : events) {
    if (e instanceof Integer n) numericSum += n;
    else if (e instanceof Double d) numericSum += d;
    else if (e instanceof String s) System.out.println("Log: " + s);
}
System.out.printf("Numeric sum: %.2f%n", numericSum); // 145.14

Clases selladas y coincidencia exhaustiva

Las clases selladas (Java 17+) restringen las clases que pueden extenderlas. Combinadas con un switch con pattern matching, permiten que el compilador verifique que se han contemplado todos los casos; no se necesita un caso default.

sealed interface Notification permits EmailNotification, SmsNotification {}
record EmailNotification(String to, String body) implements Notification {}
record SmsNotification(String phone, String text) implements Notification {}

static void send(Notification n) {
    switch (n) {
        case EmailNotification e ->
            System.out.println("Email to " + e.to() + ": " + e.body());
        case SmsNotification s ->
            System.out.println("SMS to " + s.phone() + ": " + s.text());
        // no default needed — compiler knows all cases are covered
    }
}

Patrones con guardas

El pattern matching admite guardas con when (Java 21) para añadir condiciones booleanas junto con las comprobaciones de tipo.

static String classify(Number n) {
    return switch (n) {
        case Integer i when i < 0  -> "negative int: " + i;
        case Integer i when i == 0 -> "zero";
        case Integer i             -> "positive int: " + i;
        case Double d              -> "double: " + d;
        default                    -> "other number";
    };
}

System.out.println(classify(-5));  // negative int: -5
System.out.println(classify(0));   // zero
System.out.println(classify(7));   // positive int: 7

Comprobación rápida

¿Qué devuelve la siguiente expresión?

Object obj = null;
boolean result = obj instanceof String;
System.out.println(result);

Resumen: operador instanceof

Ideas clave:

  • instanceof comprueba el tipo en tiempo de ejecución y evita ClassCastException
  • Devuelve false para null; nunca lanza NPE
  • Devuelve true para la propia clase y para todas sus subclases e interfaces
  • Pattern matching de Java 16+: if (x instanceof String s) combina la comprobación y la conversión
  • El switch con patrones de Java 21 permite seleccionar claramente por tipo, con guardas opcionales
  • Las clases selladas y el switch exhaustivo eliminan la necesidad de un caso default

Preguntas frecuentes

¿La lección «El operador instanceof» es gratis?

Sí — el texto completo de «El operador instanceof» es gratis para leer aquí en la web. Para practicarla de forma interactiva (editor de código integrado y tutor de IA 24/7) y desbloquear el resto del curso de Java Academy, actualiza a CoddyKit PRO. El curso de Java Academy incluye 4 lecciones en total.

¿Qué aprenderé en «El operador instanceof»?

Use instanceof para comprobar los tipos de objeto antes de realizar conversiones y evitar ClassCastException. Practicas Java Academy con código real que ejecutas directamente en el navegador, y un tutor de IA 24/7 responde tus preguntas mientras trabajas en la lección.

¿Necesito experiencia previa para empezar Java Academy?

No se requiere experiencia previa. Java Academy en CoddyKit está estructurado para principiantes hasta estudiantes avanzados, así que puedes empezar aquí o desde el inicio y avanzar a tu ritmo. Esta es la lección 3 de 4.

¿Cuánto tiempo toma la lección «El operador instanceof»?

La mayoría de las lecciones de CoddyKit toman alrededor de 5–10 minutos. Cada una es compacta e interactiva, así que avanzas constantemente y retomas exactamente por donde dejaste en la web y la app.

¿Puedo escribir y ejecutar código en esta lección de Java Academy?

Sí. Cada lección de Java Academy incluye un editor de código integrado, así que escribes y ejecutas código real directamente en tu navegador y obtienes retroalimentación instantánea de IA — sin configuración local necesaria.

Todas las lecciones de este curso

  1. Tipos primitivos frente a tipos de referencia
  2. Conversiones de ampliación y reducción
  3. El operador instanceof
  4. Conversiones de tipos en la práctica
← Volver a Java Academy