Java-instans av operatör

1. Introduktion

I den här snabbhandboken lär vi oss om förekomsten av operatören i Java.

2. Vad är förekomsten av operatören?

instanceof är en binär operatör som används för att testa om ett objekt är av en viss typ. Resultatet av operationen är antingen sant eller falskt . Det är också känt som typjämförelseoperatör eftersom det jämför instansen med typen.

Innan du kastar ett okänt objekt ska förekomsten av kontroll alltid användas. Att göra detta hjälper till att undvika ClassCastException vid körning.

Den instanceof operatörens grundläggande syntax är:

(object) instanceof (type)

Låt oss se ett grundläggande exempel för förekomsten av operatören. Låt oss först skapa en klassomgång :

public class Round { // implementation details }

Nästa, låt oss skapa en klass ring som sträcker sig Round :

public class Ring extends Round { // implementation details }

Vi kan använda instans av för att kontrollera om en instans av Ring är av rund typ:

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

3. Hur fungerar förekomsten av operatören?

Den instanceof operatören arbetar på principen om är-en relation . Begreppet en is-a-relation är baserad på klassarv eller gränssnittsimplementering.

För att demonstrera detta, låt oss skapa ett Shape- gränssnitt:

public interface Shape { // implementation details }

Låt oss också skapa en klasscirkel som implementerar Shape- gränssnittet och också utökar Round- klassen:

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

Den instanceof Resultatet blir sann om objektet är en instans av typen:

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

Det kommer också att vara sant om objektet är en instans av en underklass av typen:

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

Om typen är ett gränssnitt, återgår sant om objektet implementerar gränssnittet:

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

Exempel på operatör kan inte användas om det inte finns något samband mellan objektet som jämförs och typen det jämförs med.

Låt oss skapa en ny klass triangel som implementerar form men har ingen relation med Circle :

public class Triangle implements Shape { // implementation details }

Om vi ​​använder instans av för att kontrollera om en cirkel är en förekomst av triangeln :

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

Vi får ett kompileringsfel eftersom det inte finns något samband mellan klasserna Cirkel och Triangel :

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

4. Använda instanceof med Object Type

I Java ärver varje klass implicit från Object- klassen. Att använda instansen av operator med objekttypen kommer därför alltid att utvärderas till sann :

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

5. Använda förekomsten av operatören när ett objekt är ogiltigt

Om vi ​​använder förekomsten av operatören på något objekt som är null returnerar det falskt . Ingen nullkontroll behövs också när du använder en instans av operatör.

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

6. instanceof och Generics

Instanstest och casts beror på att inspektera typinformationen vid körning. Därför kan vi inte använda instans av tillsammans med raderade generiska typer .

Om vi ​​till exempel försöker kompilera följande utdrag:

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

Sedan får vi detta kompileringsfel:

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

Tekniskt sett får vi bara använda instans av tillsammans med reifiedtyper i Java. En typ omformuleras om dess typinformation finns vid körning.

De reified-typerna i Java är som följer:

  • Primitiva typer som int
  • Icke-generiska klasser och gränssnitt som String eller Random
  • Generiska typer där alla typer är obegränsade jokertecken som Set eller Map
  • Råtyper som List eller HashMap
  • Arrayer av andra återställningsbara typer som sträng [], lista [] eller karta []

Eftersom generiska typparametrar inte reified kan vi inte heller använda dem:

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

Det är dock möjligt att testa mot något som List :

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

7. Slutsats

I den här handledningen har vi lärt oss om förekomsten av operatören och hur man använder den. De fullständiga kodproverna finns tillgängliga på GitHub.