# Aprenda a usar o operador instanceof em Java

Ao fazer uso do [operador em Java](https://www.ionos.com/digitalguide/websites/web-development/java-operators/ "Operadores em Java") instanceof, você consegue verificar a correspondência entre um objeto e uma classe de um código. O resultado fornecido por esse tipo de operação é booleano, ou seja, os valores retornados são sempre “true” (verdadeiros) ou “false” (falsos). Realize verificações instanceof em Java para evitar a geração de mensagens de erro.

## O que é instanceof em Java?

Nem todas as variáveis em Java são tão óbvias: a natureza de algumas é difícil de ser identificada de imediato. Especialmente durante o desenvolvimento de projetos extensos e com numerosas variáveis em [linguagens de programação](https://www.ionos.com/digitalguide/websites/web-development/web-programming-languages/ "Linguagens de programação web"), dados de entrada podem fazer com que variáveis sejam confundidas com um ou vários objetos. Para evitar que isso ocorra, o operador Java instanceof deve ser aplicado. Ele comprova se **a instância de uma variável de referência corresponde à classe, subclasse ou interface desejada**. Se ela corresponder, o operador instanceof retorna o valor booleano “true”. Se não houver correspondência, contudo, o resultado apresentado será “false”.

Antes de manipular um objeto desconhecido, recomendamos que você execute uma operação instanceof em Java, para se ter certeza de que o objeto em questão pertence à classe presumida. Se essa verificação de segurança não for realizada, uma ***ClassCastException*** (exceção de tempo de execução) poderá ser lançada. Essa exceção ocorre quando se tenta converter um objeto para uma outra classe. A mensagem de erro pode causar confusão e problemas, especialmente em códigos mais longos, por isso aconselhamos a tomada desse tipo de precaução.

## Funcionamento e sintaxe de instanceof em Java

Quando você executa uma operação instanceof em Java, o operador **compara uma variável de referência com uma classe específica**, também por você indicada. Ele não faz qualquer outra afirmação sobre a natureza do objeto ou da classe, apenas determina se há ou não uma correspondência. A sintaxe, bastante simples, pode ser observada abaixo:

```java
(objeto) instanceof (classe)
```

Se (objeto) for uma instância de (classe), o resultado obtido será “true”. Caso contrário, o código retornará “false”.

## Exemplos de aplicação de instanceof em Java

Para explicarmos como o operador instanceof em Java age, o aplicaremos a um código de exemplo. Para começar, criamos uma classe em Java chamada “Animal”.

```java
public class Animal {
}
```

Depois, estendemos essa classe com a criação de uma subclasse chamada “Gato”.

```java
public class Gato extends Animal {
}
```

Agora, vamos usar o operador Java instanceof para verificar se uma instância de “Gato“ pertence à classe “Animal”. Para fazer isso, pediremos ajuda ao [comando em Java](https://www.ionos.com/digitalguide/websites/web-development/java-commands/ "Comandos em Java") System.out.println:

```java
public class Animal {}
public class Gato extends Animal {
public static void main(String args []{
Gato Gato = new Gato ();
System.out.println(Gato instanceof Animal);
}
}
```

O resultado obtido pela execução deste código será:

```java
true
```

## Instanceof em múltiplos níveis e na classe Object

O operador instanceof em Java também pode ser aplicado a classes principais e a outras subclasses. Para ilustrarmos isso, elaboramos um exemplo com múltiplos níveis e expandimos o operador instanceof por meio da instrução `if-else` — os textos entre duas barras (`//`) dizem respeito a comentários que apenas explicam cada etapa, mas que não têm nem executam qualquer função no código.

```java
// Classe 1
// Superclasse
public class Animal {
}
// Classe 2
// Subclasse
class Gato extends Animal {
}
// Classe 3
// Classe principal
class Main {
public static void main(String[] args)
Gato Gato1 = new Gato ();
if (Gato1 instanceof Gato)
	System.out.println("Gato1 é uma instância de Gato");
else
	System.out.println ("Gato1 NÃO é uma instância de Gato");
if (Gato1 instanceof Animal)
	System.out.println ("Gato1 é uma instância de Animal");
else
	System.out.println ("Gato1 NÃO é uma instância de Animal");
if (Gato1 instanceof Object)
	System.out.println (“Gato1 é uma instância de Object”);
else
	System.out.println (“Gato1 NÃO é uma instância de Object”);
	}
}
```

Uma vez que, no nosso exemplo, “Gato1” é uma instância da classe “Gato” e da superclasse “Animal”, ambas as perguntas são respondidas com “true”. Como a classe “Object”, ou “java.lang.Object”, está no topo da hierarquia, “Gato1” também é considerada uma instância de “Object”. Assim, o operador instanceof em Java também retorna “true” quando aplicado à classe “Object”. Observe o resultado:

```java
Gato1 é uma instância de Gato
Gato1 é uma instância de Animal
Gato1 é uma instância de Object
```

## Resultado instanceof de valor nulo

Quando uma variável tiver o valor 0, ou seja, não contiver nenhum objeto, o operador instanceof em Java automaticamente retornará o resultado “false”. O exemplo abaixo ilustra a situação:

```java
class Gato {
}
class Main {
public static void main(String[] args)
{
Gato Gato2 = null;
if (Gato2 instanceof Gato)
	System.out.println ("Gato2 é uma instância de Gato");
else
	System.out.println ("Gato2 NÃO é uma instância de Gato");
	}
}
```

O resultado desde código é o seguinte:

```java
Gato1 NÃO é uma instância de Gato
```

## Superclasses não são instâncias de subclasses

Embora, na hierarquia, objetos de subclasses também pertençam às respectivas superclasses, o princípio não é inversamente proporcional. O próximo exemplo comprova a afirmação:

```java
class Animal {
}
class Gato extends Animal {
}
class Main {
public static void main(String[] args)
{
Animal Bello = new Animal ();
if (Bello instanceof Gato)
	System.out.println ("Bello é uma instância de Gato");
else
	System.out.println ("Bello NÃO é uma instância de Gato");
	}
}
```

O resultado, neste caso, corresponde a:

```java
Bello NÃO é uma instância de Gato
```

## Mensagens de erro por falta de correspondência

Quando não existir uma correspondência entre o objeto e a classe em comparação, uma mensagem de erro será exibida — tal ocorrência poderá ser observada no nosso próximo código de exemplo. Nele, criamos uma nova classe chamada “Cachorro”, que pertence à superclasse “Animal”. “Cachorro”, contudo, não possui qualquer relação com a classe “Gato”.

```java
class Cachorro implements Animal {
}
class Main {
public static void main(String[] args)
{
Gato Gato3 = new Gato ();
System.out.println (Gato3 instanceof Cachorro);
    }
}
```

Como você pode observar, ao executarmos o código, recebemos uma mensagem de erro nos informando que não há nenhuma correspondência entre as classes “Gato” e “Cachorro”:

```java
java.lang.Error: Unresolved compilation problem:
Incompatible conditional operand types Gato and Cachorro
```

Dica Nosso Digital Guide tem muitos outros tutoriais sobre Java. Descubra, por exemplo, o que diferencia [Java e JavaScript](https://www.ionos.com/digitalguide/websites/web-development/java-vs-javascript/ "Java vs. Javascript"), e [Java e Python](https://www.ionos.com/digitalguide/websites/web-development/python-vs-java/ "Python vs. Java"). Se também for do seu interesse, explore as possibilidades dos [operadores Java bitwise](https://www.ionos.com/digitalguide/websites/web-development/java-instanceof-operator/).


This is a markdown version of: [https://www.ionos.com/pt-br/digitalguide/sites-de-internet/desenvolvimento-web/java-instanceof/](https://www.ionos.com/pt-br/digitalguide/sites-de-internet/desenvolvimento-web/java-instanceof/) for AI/LLM consumption.