Aprenda a usar o operador ins­tan­ceof em Java

Ao fazer uso do operador em Java ins­tan­ceof, você consegue verificar a cor­res­pon­dên­cia entre um objeto e uma classe de um código. O resultado fornecido por esse tipo de operação é booleano, ou seja, os valores re­tor­na­dos são sempre “true” (ver­da­dei­ros) ou “false” (falsos). Realize ve­ri­fi­ca­ções ins­tan­ceof em Java para evitar a geração de mensagens de erro.

O que é ins­tan­ceof em Java?

Nem todas as variáveis em Java são tão óbvias: a natureza de algumas é difícil de ser iden­ti­fi­cada de imediato. Es­pe­ci­al­mente durante o de­sen­vol­vi­mento de projetos extensos e com numerosas variáveis em lin­gua­gens de pro­gra­ma­ção, dados de entrada podem fazer com que variáveis sejam con­fun­di­das com um ou vários objetos. Para evitar que isso ocorra, o operador Java ins­tan­ceof deve ser aplicado. Ele comprova se a instância de uma variável de re­fe­rên­cia cor­res­ponde à classe, subclasse ou interface desejada. Se ela cor­res­pon­der, o operador ins­tan­ceof retorna o valor booleano “true”. Se não houver cor­res­pon­dên­cia, contudo, o resultado apre­sen­tado será “false”.

Antes de manipular um objeto des­co­nhe­cido, re­co­men­da­mos que você execute uma operação ins­tan­ceof em Java, para se ter certeza de que o objeto em questão pertence à classe presumida. Se essa ve­ri­fi­ca­ção de segurança não for realizada, uma Clas­s­Cas­tEx­cep­tion (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, es­pe­ci­al­mente em códigos mais longos, por isso acon­se­lha­mos a tomada desse tipo de precaução.

Fun­ci­o­na­mento e sintaxe de ins­tan­ceof em Java

Quando você executa uma operação ins­tan­ceof em Java, o operador compara uma variável de re­fe­rên­cia com uma classe es­pe­cí­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 cor­res­pon­dên­cia. A sintaxe, bastante simples, pode ser observada abaixo:

(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 ins­tan­ceof em Java

Para ex­pli­car­mos como o operador ins­tan­ceof em Java age, o apli­ca­re­mos a um código de exemplo. Para começar, criamos uma classe em Java chamada “Animal”.

public class Animal {
}

Depois, es­ten­de­mos essa classe com a criação de uma subclasse chamada “Gato”.

public class Gato extends Animal {
}

Agora, vamos usar o operador Java ins­tan­ceof para verificar se uma instância de “Gato“ pertence à classe “Animal”. Para fazer isso, pediremos ajuda ao comando em Java System.out.println:

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á:

true

Ins­tan­ceof em múltiplos níveis e na classe Object

O operador ins­tan­ceof em Java também pode ser aplicado a classes prin­ci­pais e a outras sub­clas­ses. Para ilus­trar­mos isso, ela­bo­ra­mos um exemplo com múltiplos níveis e ex­pan­di­mos o operador ins­tan­ceof por meio da instrução if-else — os textos entre duas barras (//) dizem respeito a co­men­tá­rios que apenas explicam cada etapa, mas que não têm nem executam qualquer função no código.

// 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 su­per­classe “Animal”, ambas as perguntas são res­pon­di­das com “true”. Como a classe “Object”, ou “java.lang.Object”, está no topo da hi­e­rar­quia, “Gato1” também é con­si­de­rada uma instância de “Object”. Assim, o operador ins­tan­ceof em Java também retorna “true” quando aplicado à classe “Object”. Observe o resultado:

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

Resultado ins­tan­ceof de valor nulo

Quando uma variável tiver o valor 0, ou seja, não contiver nenhum objeto, o operador ins­tan­ceof em Java au­to­ma­ti­ca­mente retornará o resultado “false”. O exemplo abaixo ilustra a situação:

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:

Gato1 NÃO é uma instância de Gato

Su­per­clas­ses não são ins­tân­cias de sub­clas­ses

Embora, na hi­e­rar­quia, objetos de sub­clas­ses também pertençam às res­pec­ti­vas su­per­clas­ses, o princípio não é in­ver­sa­mente pro­por­ci­o­nal. O próximo exemplo comprova a afirmação:

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, cor­res­ponde a:

Bello NÃO é uma instância de Gato

Mensagens de erro por falta de cor­res­pon­dên­cia

Quando não existir uma cor­res­pon­dên­cia entre o objeto e a classe em com­pa­ra­ção, uma mensagem de erro será exibida — tal ocor­rên­cia poderá ser observada no nosso próximo código de exemplo. Nele, criamos uma nova classe chamada “Cachorro”, que pertence à su­per­classe “Animal”. “Cachorro”, contudo, não possui qualquer relação com a classe “Gato”.

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 exe­cu­tar­mos o código, recebemos uma mensagem de erro nos in­for­mando que não há nenhuma cor­res­pon­dên­cia entre as classes “Gato” e “Cachorro”:

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