Instanță Java a Operatorului

1. Introducere

În acest tutorial rapid, vom afla despre instanța operatorului în Java.

2. Care este instanța Operatorului?

instanceof este un operator binar folosit pentru a testa dacă un obiect este de un anumit tip. Rezultatul operației este fie adevărat, fie fals . Este, de asemenea, cunoscut sub numele de operator de comparare a tipului, deoarece compară instanța cu tipul.

Înainte de a arunca un obiect necunoscut, instanța verificării ar trebui să fie întotdeauna utilizată. Acest lucru vă ajută să evitați ClassCastException în timpul rulării.

Instanceof sintaxa de bază operatorului este:

(object) instanceof (type)

Să vedem un exemplu de bază pentru instanța operatorului. Mai întâi, să creăm o rundă de clasă :

public class Round { // implementation details }

Apoi, să creăm un Inel de clasă care extinde Runda :

public class Ring extends Round { // implementation details }

Putem folosi instanceof pentru a verifica dacă o instanță a Ring este de tip Round :

@Test public void givenWhenInstanceIsCorrect_thenReturnTrue() { Ring ring = new Ring(); Assert.assertTrue(ring instanceof Round); }

3. Cum funcționează instanța operatorului?

Instanceof Operatorul funcționează pe principiul este-o relație . Conceptul de relație is-a se bazează pe moștenirea clasei sau implementarea interfeței.

Pentru a demonstra acest lucru, să creăm o interfață Shape :

public interface Shape { // implementation details }

Să creăm, de asemenea, un cerc de clasă care implementează interfața Shape și, de asemenea, extinde clasa Round :

public class Circle extends Round implements Shape { // implementation details }

Rezultatul instanței va fi adevărat dacă obiectul este o instanță de tipul:

@Test public void givenWhenObjectIsInstanceOfType_thenReturnTrue() { Circle circle = new Circle(); Assert.assertTrue(circle instanceof Circle); }

De asemenea, va fi adevărat dacă obiectul este o instanță a unei subclase de tipul:

@Test public void giveWhenInstanceIsOfSubtype_thenReturnTrue() { Circle circle = new Circle(); Assert.assertTrue(circle instanceof Round); }

Dacă tipul este o interfață, va reveni adevărat dacă obiectul implementează interfața:

@Test public void givenWhenTypeIsInterface_thenReturnTrue() { Circle circle = new Circle(); Assert.assertTrue(circle instanceof Shape); }

Instanța operatorului nu poate fi utilizată dacă nu există nicio relație între obiectul care este comparat și tipul cu care este comparat.

Să creăm un nou triunghi de clasă care implementează Shape, dar nu are nicio relație cu Circle :

public class Triangle implements Shape { // implementation details }

Acum, dacă folosim instanceof pentru a verifica dacă un cerc este o instanță a triunghiului :

@Test public void givenWhenComparingClassInDiffHierarchy_thenCompilationError() { Circle circle = new Circle(); Assert.assertFalse(circle instanceof Triangle); }

Vom primi o eroare de compilare, deoarece nu există nicio relație între clasele Cerc și Triunghi :

java.lang.Error: Unresolved compilation problem: Incompatible conditional operand types Circle and Triangle

4. Utilizarea instanceof cu obiect de tip

În Java, fiecare clasă moștenește implicit din clasa Object . Prin urmare, folosind operatorul instanceof cu tipul de obiect se va evalua întotdeauna la adevărat :

@Test public void givenWhenTypeIsOfObjectType_thenReturnTrue() { Thread thread = new Thread(); Assert.assertTrue(thread instanceof Object); }

5. Utilizarea instanței Operator atunci când un obiect este nul

Dacă folosim operatorul instanceof pe orice obiect care este nul , acesta returnează false . De asemenea, nu este necesară nicio verificare nulă atunci când se utilizează o instanță de operator.

@Test public void givenWhenInstanceValueIsNull_thenReturnFalse() { Circle circle = null; Assert.assertFalse(circle instanceof Round); }

6. instanceof și Generics

Testele de instanță și distribuțiile depind de inspectarea informațiilor de tip în timpul rulării. Prin urmare, nu putem folosi instanceof împreună cu tipurile generice șterse .

De exemplu, dacă încercăm să compilăm următorul fragment:

public static  void sort(List collection) { if (collection instanceof List) { // sort strings differently } // omitted }

Apoi vom obține această eroare de compilare:

error: illegal generic type for instanceof if (collection instanceof List) { ^

Din punct de vedere tehnic, ni se permite să folosim doar instanceof împreună cu reifiedtipuri în Java. Un tip este reificat dacă informațiile sale despre tip sunt prezente în timpul rulării.

Tipurile reificate în Java sunt după cum urmează:

  • Tipuri primitive precum int
  • Clase și interfețe non-generice precum String sau Random
  • Tipuri generice în care toate tipurile sunt metacaractere nelimitate, cum ar fi Set sau Map
  • Tipuri brute, cum ar fi List sau HashMap
  • Matrice de alte tipuri reifificabile, cum ar fi String [], List [] sau Map []

Deoarece parametrii de tip generic nu sunt reificați, nu îi putem folosi nici:

public static  boolean isOfType(Object input) { return input instanceof T; // won't compile }

Cu toate acestea, este posibil să testați împotriva a ceva precum List :

if (collection instanceof List) { // do something }

7. Concluzie

În acest tutorial, am aflat despre instanța operatorului și cum să-l folosim. Exemplele complete de coduri sunt disponibile pe GitHub.