streamalism.org

1. Introduktion

I denne hurtige vejledning skal vi se på råtyper, hvad de er, og hvorfor vi skal undgå dem.

2. Rå typer

En rå type er et navn til en generisk grænseflade eller klasse uden dens type argument:

Liste liste = ny ArrayList (); // rå type

I stedet for:

List listIntgrs = new ArrayList (); // parametreret type

Liste er en parametreret type af grænsefladen Liste mens Liste er en rå type af grænsefladen Liste.

Rå typer kan være nyttige, når de grænseflader med ikke-generisk ældre kode.

Ellers dog det er modløs. Dette er fordi:

1. De er ikke udtryksfulde
2. De mangler typesikkerhed, og
3. Problemer observeres ved kørselstid og ikke på kompileringstidspunktet

3. Inexpressive

En rå type dokumenterer ikke og forklarer sig selv, som en parametreret type gør.

Vi kan let udlede, at en parametreret type Liste er en liste, der indeholder Snors. En rå type mangler imidlertid denne klarhed, hvilket gør det vanskeligt at arbejde med den og med dens API-metoder.

Lad os se metodens signatur få (int-indeks) i Liste interface for at forstå dette bedre:

/ ** * Returnerer elementet på den angivne position på denne liste. * * @paramindeksindeks for elementet, der skal returneres * @returelementet på den angivne position i denne liste * @kaster IndexOutOfBoundsException, hvis indekset er uden for området * (index = størrelse ()) * / E get (int index) ;

Metoden få (int-indeks) returnerer a Snor ved position indeks i parametreret type Liste.

Dog for en rå type Liste, det returnerer en Objekt. Således kræves det, at vi gør en ekstra indsats for at inspicere og identificere typen af ​​element i den rå type Liste og tilføj en passende type-casting. Dette kan introducere bugs i løbetid, som rå type er ikke skrive sikkert.

4. Ikke typesikker

Vi får præ-generisk adfærd med rå typer. Derfor en rå type Liste accepterer Objekt og kan indeholde et element af enhver datatype. Dette kan føre til typesikkerhedsproblemer, når vi blander parametriserede og rå typer.

Lad os se dette ved at oprette en kode, der instantierer en Liste før du sender det til en metode, der accepterer rå type Liste og tilføjer en Heltal til det:

public void methodA () {List parameterizedList = new ArrayList (); parameterizedList.add ("Hej folk"); metode B (parameteriseret liste); } public void methodB (List rawList) {// raw type! rawList.add (1); }

Koden bliver samlet (med en advarsel) og Heltal bliver føjet til den rå type Liste når de udføres. Det Liste det blev vedtaget som et argument indeholder nu en Snor og en Heltal.

Compileren udskriver en advarsel på grund af brugen af ​​råtyper:

Bemærk: RawTypeDemo.java bruger ukontrollerede eller usikre handlinger. Bemærk: Kompiler igen med -Xlint: ikke markeret for detaljer.

5. Problemer ved kørsel

Manglende typesikkerhed på en rå type har en årsagseffekt, der kan føre til undtagelser ved kørsel.

Lad os ændre det foregående eksempel, så det metode A. får elementet i indeksposition 1 i vores Liste efter at have ringet metodeB:

public void methodA () {List parameterizedList = new ArrayList (); parameterizedList.add ("Hej folk"); metode B (parameteriseret liste); Streng s = parameterizedList.get (1); } public void methodB (Liste rawList) {rawList.add (1); }

Koden bliver samlet (med samme advarsel) og kaster en ClassCastException når de udføres. Dette sker som metoden få (int-indeks) returnerer en Heltal, som ikke kan tildeles en variabel af typen Snor:

Undtagelse i tråden "main" java.lang.ClassCastException: java.lang.Integer kan ikke kastes til java.lang.String

6. Konklusion

Rå typer er svære at arbejde med og kan introducere bugs i vores kode.

Brug af dem kan føre til konsekvenser, der kan være katastrofale, og desværre sker de fleste af disse katastrofer i løbetid.

Tjek alle uddrag i denne vejledning over på GitHub.