Java-forekomst av operatør

1. Introduksjon

I denne raske opplæringen lærer vi om tilfelle av operatør i Java.

2. Hva er tilfelle av Operatør?

eksempel på er en binær operatør som brukes til å teste om et objekt er av en gitt type. Resultatet av operasjonen er enten ekte eller falsk. Det er også kjent som typesammenligningsoperatør fordi det sammenligner forekomsten med typen.

Før du støper et ukjent objekt, har tilfelle av sjekk skal alltid brukes. Å gjøre dette hjelper til med å unngå ClassCastException ved kjøretid.

De tilfelle av operatørens grunnleggende syntaks er:

(objekt) forekomst av (type)

La oss se et grunnleggende eksempel for tilfelle av operatør. La oss først lage en klasse Rund:

offentlig klasse runde {// implementeringsdetaljer}

La oss deretter lage en klasse Ringe som strekker seg Rund:

public class Ring utvider runde {// implementeringsdetaljer}

Vi kan bruke tilfelle av for å sjekke om en forekomst av Ringe er av Rund type:

@Test offentlig ugyldig givenWhenInstanceIsCorrect_thenReturnTrue () {Ring ring = ny ring (); Assert.assertTrue (ringinstans av runde); }

3. Hvordan fungerer tilfelle av Operatørarbeid?

De tilfelle av operatøren arbeider etter prinsippet om is-a-forholdet. Konseptet med et is-a-forhold er basert på klassearv eller implementering av grensesnitt.

For å demonstrere dette, la oss lage en Form grensesnitt:

offentlig grensesnittform {// implementeringsdetaljer}

La oss også lage en klasse Sirkel som implementerer Form grensesnitt og utvider også Rund klasse:

public class Circle utvider runde redskaper Shape {// implementeringsdetaljer}

De tilfelle av resultatet blir ekte hvis objektet er en forekomst av typen:

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

Det blir det også ekte hvis objektet er en forekomst av en underklasse av typen:

@Test offentlig ugyldig giveWhenInstanceIsOfSubtype_thenReturnTrue () {Circle circle = new Circle (); Assert.assertTrue (sirkelinstans av runde); }

Hvis typen er et grensesnitt, kommer den tilbake ekte hvis objektet implementerer grensesnittet:

@Test public void givenWhenTypeIsInterface_thenReturnTrue () {Circle circle = new Circle (); Assert.assertTrue (sirkelinstans av form); }

Forekomsten av operatør kan ikke brukes hvis det ikke er noe forhold mellom objektet som sammenlignes og typen det sammenlignes med.

La oss lage en ny klasse Triangel som implementerer Form men har ikke noe forhold til Sirkel:

offentlig klasse Triangle implementerer Shape {// implementeringsdetaljer}

Nå, hvis vi bruker tilfelle av for å sjekke om en Sirkel er en forekomst av Triangel:

@Test offentlig ugyldighet gittWhenComparingClassInDiffHierarchy_thenCompilationError () {Circle circle = new Circle (); Assert.assertFalse (sirkelinstans av trekant); }

Vi får en kompileringsfeil fordi det ikke er noe forhold mellom Sirkel og Triangel klasser:

java.lang.Error: uløst kompilasjonsproblem: inkompatible betingede operatyper Circle og Triangle

4. Bruke tilfelle av med Gjenstand Type

I Java arver hver klasse implisitt fra Gjenstand klasse. Derfor bruker du tilfelle av operatør med Gjenstand typen vil alltid evaluere til ekte:

@Test public void givenWhenTypeIsOfObjectType_thenReturnTrue () {Thread thread = new Thread (); Assert.assertTrue (trådforekomst av objekt); }

5. Bruke tilfelle av Operatør når et objekt er null

Hvis vi bruker tilfelle av operatøren på et hvilket som helst objekt null, kommer den tilbake falsk. Ingen nullkontroll er også nødvendig når du bruker en tilfelle av operatør.

@Test public void givenWhenInstanceValueIsNull_thenReturnFalse () {Circle circle = null; Assert.assertFalse (sirkelinstans av runde); }

6. tilfelle av og generiske stoffer

Forekomststester og kaster avhenger av inspeksjon av typeinformasjonen ved kjøretid. Derfor kan vi ikke bruke tilfelle av sammen med slettede generiske typer.

For eksempel hvis vi prøver å kompilere følgende kodebit:

offentlig statisk tomromssortering (Listesamling) {if (samlingsinstans av liste) {// sorterer strenger annerledes} // utelatt}

Så får vi denne kompileringsfeilen:

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

Teknisk sett har vi bare lov til å bruke tilfelle av sammen med reifiedtyper i Java. En type blir reified hvis dens typeinformasjon er til stede under kjøretiden.

De reified typene i Java er som følger:

  • Primitive typer som int
  • Ikke-generiske klasser og grensesnitt som String eller Tilfeldig
  • Generiske typer der alle typer er ubegrensede jokertegn som Sett eller Kart
  • Rå typer som Liste eller HashMap
  • Arrangementer av andre reifiserbare typer som Streng [], Liste [], eller Kart[]

Fordi generiske typeparametere ikke blir reifisert, kan vi heller ikke bruke dem:

public static boolean isOfType (Object input) {return input instanceof T; // vil ikke kompilere}

Det er imidlertid mulig å teste mot noe lignende Liste:

hvis (samlingsinstans av liste) {// gjør noe}

7. Konklusjon

I denne opplæringen har vi lært om tilfelle av operatøren og hvordan du bruker den. De komplette kodeeksemplene er tilgjengelige på GitHub.