0Pricing
Java Academy · Aula

O Operador instanceof

Use instanceof para verificar os tipos de objetos antes de converter tipos e evitar ClassCastException.

O Operador instanceof é uma aula grátis de Java Academy no CoddyKit. Esta é a aula 3 de 4. Você pode ler a aula completa abaixo gratuitamente — depois pratica ao vivo no navegador com um editor de código integrado e um tutor de IA 24/7. Faz parte do caminho de aprendizado de Java Academy, e seu progresso é sincronizado entre a web e o app CoddyKit. O curso de Java Academy inclui 4 aulas no total.

O operador de verificação de instância

O operador instanceof verifica, em tempo de execução, se um objeto é uma instância de determinado tipo. Ele retorna true ou false e evita ClassCastException antes da conversão de tipo.

Uso básico da verificação de instância

Use instanceof para verificar o tipo de um objeto em tempo de execução antes de realizar uma conversão 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

Verificação de instância com herança

instanceof retorna true se o objeto for uma instância da classe ou de qualquer subclasse (ou de qualquer interface implementada).

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

Correspondência de padrões com verificação de instância (Java 16+)

O Java 16 introduziu a correspondência de padrões para instanceof: é possível declarar uma variável de associação na mesma expressão, eliminando a conversão 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
}

Correspondência de padrões em um método

A correspondência de padrões torna o encaminhamento baseado em tipos claro e seguro. A variável de associação só está no escopo em que se sabe que a condição é verdadeira.

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

Verificação de instância com nulo

null instanceof AnyType sempre retorna false — nunca lança uma exceção. Isso torna instanceof uma forma segura para nulos de verificar um objeto antes da conversão.

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
}

Expressões de seleção e correspondência de padrões

O Java 21 estende a correspondência de padrões às expressões de seleção, permitindo um encaminhamento claro baseado em tipos sem uma cadeia de condições 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 sem verificação de instância

Fazer uma conversão sem verificar primeiro causa ClassCastException em tempo de execução — um erro comum em código legado que a correspondência de padrões ajuda 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ática: processamento de uma lista heterogênea

Um caso de uso real: processar uma lista heterogênea de objetos usando correspondência de padrões.

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

Classes seladas e correspondência exaustiva

Classes seladas (Java 17+) restringem quais classes podem estendê-las. Combinadas com uma seleção baseada em padrões, permitem que o compilador verifique se todos os casos foram cobertos — não é necessário um caso padrão.

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

Padrões com guarda

A correspondência de padrões aceita guardas com when (Java 21) para adicionar condições booleanas às verificações 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

Verificação rápida

O que a expressão a seguir retorna?

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

Recapitulação: operador de verificação de instância

Principais conclusões:

  • A verificação de instância verifica o tipo em tempo de execução e evita ClassCastException
  • Retorna false para nulo — nunca lança NPE
  • Retorna true para a própria classe e para todas as suas subclasses e interfaces
  • A correspondência de padrões do Java 16+ combina a verificação e a conversão em uma única expressão
  • A seleção do Java 21 com padrões encaminha os objetos de forma clara pelo tipo, com guardas opcionais
  • Classes seladas e seleção exaustiva eliminam a necessidade de um caso padrão

Perguntas Frequentes

A aula “O Operador instanceof” é grátis?

Sim — o texto completo de “O Operador instanceof” é grátis para ler aqui na web. Para praticá-la interativamente (um editor de código integrado e um tutor de IA 24/7) e desbloquear o restante do curso de Java Academy, atualize para CoddyKit PRO. O curso de Java Academy inclui 4 aulas no total.

O que vou aprender em “O Operador instanceof”?

Use instanceof para verificar os tipos de objetos antes de converter tipos e evitar ClassCastException. Você pratica Java Academy com código prático que executa diretamente no navegador, e um tutor de IA 24/7 responde suas dúvidas enquanto trabalha na aula.

Preciso ter experiência prévia para começar Java Academy?

Nenhuma experiência prévia é necessária. Java Academy no CoddyKit é estruturado para alunos iniciantes até avançados, então você pode começar aqui ou desde o início e aprender no seu ritmo. Esta é a aula 3 de 4.

Quanto tempo leva a aula “O Operador instanceof”?

A maioria das aulas CoddyKit leva cerca de 5–10 minutos. Cada uma é compacta e interativa, então você faz progresso constante e retoma exatamente de onde parou entre web e app.

Posso escrever e executar código nesta aula de Java Academy?

Sim. Cada aula de Java Academy inclui um editor de código integrado, então você escreve e executa código real direto no navegador e recebe feedback de IA instantaneamente — nenhuma configuração local necessária.

Todas as aulas deste curso

  1. Tipos Primitivos versus Tipos de Referência
  2. Conversões de Alargamento e Redução
  3. O Operador instanceof
  4. Conversão de Tipos na Prática
← Voltar para Java Academy