Java Academy · Lección

Pattern Matching para instanceof

Asigne una variable mientras comprueba el tipo

Pattern Matching para instanceof es una lección gratuita de Java Academy en CoddyKit. Esta es la lección 1 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.

Coincidencia de patrones con instanceof

La forma antigua de utilizar instanceof consistía en comprobar y después convertir el tipo. La coincidencia de patrones combina la comprobación y la conversión en un solo paso, vinculando una variable tipada cuando la comprobación tiene éxito.

El código repetitivo de antes

El código clásico comprueba el tipo y después lo convierte en una variable nueva. Es repetitivo y fácil de hacer mal.

public class Main {
    public static void main(String[] args) {
        Object obj = "hello";
        if (obj instanceof String) {
            String s = (String) obj;
            System.out.println(s.length());
        }
    }
}

La nueva forma

Un patrón de tipo declara la variable en línea: if (obj instanceof String s). Cuando el resultado es verdadero, s ya contiene el valor convertido.

public class Main {
    public static void main(String[] args) {
        Object obj = "hello";
        if (obj instanceof String s) {
            System.out.println(s.length());
        }
    }
}

La variable vinculada

La variable s se denomina variable de patrón. Está dentro del ámbito allí donde el compilador puede demostrar que el patrón coincidió, lo que hace que el código sea más corto y seguro.

Usarla en condiciones

Dentro de la misma condición if, puede utilizar la variable de patrón después de &&, porque la coincidencia está garantizada en esa rama.

public class Main {
    public static void main(String[] args) {
        Object obj = "developer";
        if (obj instanceof String s && s.length() > 5) {
            System.out.println("Long string: " + s);
        }
    }
}

Negación y ámbito de flujo

Con la negación, el ámbito cambia de forma inteligente. Después de if (!(obj instanceof String s)) return;, la variable s está dentro del ámbito durante el resto del método, porque el código solo continúa cuando la coincidencia se cumple.

public class Main {
    static int safeLength(Object obj) {
        if (!(obj instanceof String s)) {
            return -1;
        }
        return s.length();
    }

    public static void main(String[] args) {
        System.out.println(safeLength("abc"));
        System.out.println(safeLength(42));
    }
}

Sustituir equals y la conversión

Un uso clásico es una implementación clara de equals: compruebe el tipo y vincule la variable en una sola línea; después, compare los campos.

public class Main {
    static final class Point {
        final int x, y;
        Point(int x, int y) { this.x = x; this.y = y; }
        public boolean equals(Object o) {
            return o instanceof Point p && p.x == x && p.y == y;
        }
        public int hashCode() { return x * 31 + y; }
    }

    public static void main(String[] args) {
        System.out.println(new Point(1, 2).equals(new Point(1, 2)));
        System.out.println(new Point(1, 2).equals(new Point(3, 4)));
    }
}

Gestionar tipos mixtos

Las ramas else if encadenadas con patrones le permiten seleccionar de forma clara entre varios tipos posibles.

public class Main {
    static String describe(Object obj) {
        if (obj instanceof Integer i) {
            return "int " + (i * 2);
        } else if (obj instanceof String s) {
            return "string of length " + s.length();
        } else {
            return "unknown";
        }
    }

    public static void main(String[] args) {
        System.out.println(describe(21));
        System.out.println(describe("hello"));
        System.out.println(describe(3.14));
    }
}

null nunca coincide

Un patrón instanceof es false para null, igual que el operador clásico. Por lo tanto, la variable del patrón nunca queda vinculada a null, lo que elimina una causa común de NPE.

public class Main {
    public static void main(String[] args) {
        Object obj = null;
        if (obj instanceof String s) {
            System.out.println("matched: " + s);
        } else {
            System.out.println("null or not a String");
        }
    }
}

Código más claro y seguro

La coincidencia de patrones elimina la conversión de tipos redundante, restringe el ámbito para que no pueda usar la variable de forma incorrecta y se lee casi como una frase en inglés. Es el estilo preferido en Java moderno.

Integración

Un pequeño distribuidor que da formato a diferentes entradas mediante patrones.

public class Main {
    static String format(Object o) {
        if (o instanceof Double d) return String.format("%.1f", d);
        if (o instanceof Integer i) return Integer.toString(i);
        if (o instanceof String s && !s.isBlank()) return s.trim();
        return "n/a";
    }

    public static void main(String[] args) {
        System.out.println(format(3.14159));
        System.out.println(format(99));
        System.out.println(format("  spaced  "));
        System.out.println(format(null));
    }
}

Comprobación rápida

Compruebe su comprensión de los patrones instanceof.

Recapitulación

Ha aprendido la coincidencia de patrones para instanceof.

Combina la comprobación de tipos y la conversión en una sola expresión.
El ámbito de la variable del patrón se limita al lugar donde se ha demostrado la coincidencia.
Los patrones son false para null, lo que evita los NPE.
Simplifica las redefiniciones de equals y la selección por tipo.

Preguntas frecuentes

¿La lección «Pattern Matching para instanceof» es gratis?

Sí — el texto completo de «Pattern Matching para 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 «Pattern Matching para instanceof»?

Asigne una variable mientras comprueba el tipo 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 1 de 4.

¿Cuánto tiempo toma la lección «Pattern Matching para 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

← Volver a Java Academy