Java Academy · Lekcja

Operator instanceof

Używaj instanceof do sprawdzania typów obiektów przed rzutowaniem i unikaj ClassCastException.

Operator instanceof to bezpłatna lekcja Java Academy na CoddyKit. To lekcja 3 z 4. Możesz przeczytać całą lekcję poniżej za darmo — a potem ćwiczyć ją interaktywnie w przeglądarce z wbudowanym edytorem kodu i tutorem AI dostępnym 24/7. To część ścieżki edukacyjnej Java Academy, a Twój postęp synchronizuje się między webem a aplikacją CoddyKit. Kurs Java Academy zawiera 4 lekcji w sumie.

Operator instanceof

Operator instanceof sprawdza w czasie działania programu, czy obiekt jest instancją danego typu. Zwraca true lub false i pozwala zapobiec wystąpieniu ClassCastException przed rzutowaniem.

Podstawowe użycie instanceof

Należy użyć instanceof, aby sprawdzić rzeczywisty typ obiektu przed wykonaniem bezpiecznego rzutowania.

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 a dziedziczenie

instanceof zwraca true, jeśli obiekt jest instancją danej klasy lub dowolnej klasy pochodnej (albo implementuje dany interfejs).

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

Dopasowywanie wzorców instanceof (Java 16+)

Java 16 wprowadziła dopasowywanie wzorców dla instanceof: można zadeklarować zmienną wiążącą w tym samym wyrażeniu, eliminując jawne rzutowanie.

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
}

Dopasowywanie wzorców w metodzie

Dopasowywanie wzorców pozwala w przejrzysty i bezpieczny sposób wybierać obsługę na podstawie typu. Zmienna wiążąca jest dostępna tylko w zakresie, w którym wiadomo, że warunek jest spełniony.

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 a null

null instanceof AnyType zawsze zwraca false — nigdy nie zgłasza wyjątku. Dzięki temu instanceof jest bezpiecznym dla wartości null sposobem sprawdzania typu przed rzutowaniem.

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
}

Wyrażenia switch i dopasowywanie wzorców

Java 21 rozszerza dopasowywanie wzorców na wyrażenia switch, umożliwiając przejrzyste kierowanie na podstawie typu bez łańcuchów 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 bez instanceof

Rzutowanie bez wcześniejszego sprawdzenia prowadzi w czasie działania programu do ClassCastException — jest to częsty błąd w starszym kodzie, któremu pomaga zapobiegać dopasowywanie wzorców.

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");
}

Praktyka: przetwarzanie mieszanej listy

Praktyczny przypadek użycia: przetwarzanie heterogenicznej listy obiektów za pomocą dopasowywania wzorców.

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

Klasy zapieczętowane i wyczerpujące dopasowanie

Klasy zapieczętowane (Java 17+) ograniczają zbiór klas, które mogą po nich dziedziczyć. W połączeniu z przełącznikiem switch wykorzystującym dopasowywanie wzorców pozwalają kompilatorowi sprawdzić kompletność przypadków — przypadek default nie jest potrzebny.

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

Wzorce z warunkami ochronnymi

Dopasowywanie wzorców obsługuje warunki ochronne za pomocą when (Java 21), umożliwiając dodawanie warunków logicznych obok sprawdzania typu.

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

Szybki test

Co zwróci poniższe wyrażenie?

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

Podsumowanie: operator instanceof

Najważniejsze informacje:

instanceof sprawdza typ w czasie działania programu i zapobiega ClassCastException
Dla null zwraca false — nigdy nie zgłasza NPE
Zwraca true dla danej klasy oraz wszystkich jej klas pochodnych i interfejsów
Dopasowywanie wzorców Java 16+: if (x instanceof String s) łączy sprawdzenie z rzutowaniem
switch z wzorcami w Java 21 przejrzyście kieruje obsługę na podstawie typu i opcjonalnych warunków ochronnych
Klasy zapieczętowane i wyczerpujący switch eliminują potrzebę użycia przypadku default

Często zadawane pytania

Czy lekcja „Operator instanceof” jest bezpłatna?

Tak — pełny tekst „Operator instanceof” jest dostępny za darmo tutaj w sieci. Aby ćwiczyć ją interaktywnie (wbudowany edytor kodu i tutor AI dostępny 24/7) i odblokować resztę kursu Java Academy, przejdź na CoddyKit PRO. Kurs Java Academy zawiera 4 lekcji w sumie.

Co nauczysz się w „Operator instanceof”?

Używaj instanceof do sprawdzania typów obiektów przed rzutowaniem i unikaj ClassCastException. Ćwiczysz Java Academy z praktycznym kodem, który uruchamiasz bezpośrednio w przeglądarce, a tutor AI dostępny 24/7 odpowiada na Twoje pytania podczas pracy nad lekcją.

Czy potrzebuję doświadczenia, aby zacząć Java Academy?

Nie wymagamy żadnego doświadczenia. Java Academy w CoddyKit jest strukturyzowany dla początkujących i zaawansowanych użytkowników, więc możesz zacząć tutaj lub od początku i uczyć się w swoim tempie. To lekcja 3 z 4.

Ile czasu zajmuje lekcja „Operator instanceof”?

Większość lekcji CoddyKit trwa około 5–10 minut. Każda lekcja to mały, interaktywny krok, dzięki czemu robisz systematyczne postępy i zawsze wracasz dokładnie do tego samego miejsca — na webie i w aplikacji.

Czy mogę pisać i uruchamiać kod w tej lekcji Java Academy?

Tak. Każda lekcja Java Academy zawiera wbudowany edytor kodu, więc piszesz i uruchamiasz prawdziwy kod bezpośrednio w przeglądarce i od razu otrzymujesz sprzężenie zwrotne od AI — bez konfiguracji na komputerze.

Wszystkie lekcje w tym kursie

← Powrót do Java Academy