Onbewerkte typen in Java

1. Inleiding

In deze korte tutorial gaan we kijken naar onbewerkte soorten, wat ze zijn en waarom we ze zouden moeten vermijden.

2. Ruwe soorten

Een onbewerkt type is een naam voor een generieke interface of klasse zonder het type-argument:

Lijstlijst = nieuwe ArrayList (); // onbewerkt type

In plaats van:

Lijst listIntgrs = nieuwe ArrayList (); // geparametriseerd type

Lijst is een geparametriseerd type van interface Lijst terwijl Lijst is een ruw type van interface Lijst.

Raw-typen kunnen handig zijn bij het communiceren met niet-generieke verouderde code.

Anders echter, het is ontmoedigd. Dit is zo omdat:

  1. Ze zijn niet expressief
  2. Ze missen typeveiligheid, en
  3. Er worden problemen waargenomen tijdens de uitvoering en niet tijdens het compileren

3. Onuitsprekelijk

Een onbewerkt type documenteert niet en legt zichzelf uit zoals een geparametriseerd type dat doet.

We kunnen gemakkelijk concluderen dat een geparametriseerd type Lijst is een lijst met Draads. Een onbewerkt type mist deze duidelijkheid echter, waardoor het moeilijk is om ermee en met zijn API-methoden te werken.

Laten we eens kijken naar de handtekening van de methode get (int index) in de Lijst interface om dit beter te begrijpen:

/ ** * Retourneert het element op de opgegeven positie in deze lijst. * * @param index index van het element dat moet worden geretourneerd * @return het element op de opgegeven positie in deze lijst * @throws IndexOutOfBoundsException als de index buiten bereik is * (index = size ()) * / E get (int index) ;

De methode get (int index) geeft een terug Draad op positie inhoudsopgave in geparametriseerd type Lijst.

Echter, voor een rauw type Lijst, het retourneert een Voorwerp. We moeten dus extra moeite doen om het type element in het onbewerkte type te inspecteren en te identificeren Lijst en voeg een geschikt type-casting toe. Dit kan bugs introduceren tijdens runtime zoals het ruwe type is niet type veilig.

4. Niet type-veilig

We krijgen pre-generiek gedrag met onbewerkte soorten. Daarom een ​​rauw type Lijst accepteert Voorwerp en kan een element van elk gegevenstype bevatten. Dit kan leiden tot typeveiligheidsproblemen wanneer we geparametriseerde en onbewerkte typen combineren.

Laten we dit eens bekijken door een code te maken die een Lijst alvorens het door te geven aan een methode die onbewerkt type accepteert Lijst en voegt een Geheel getal naar het:

public void methodA () {List parameterizedList = nieuwe ArrayList (); parameterizedList.add ("Hallo mensen"); methodB (parameterizedList); } public void methodB (List rawList) {// raw type! rawList.add (1); }

De code wordt gecompileerd (met een waarschuwing) en de Geheel getal wordt toegevoegd aan het onbewerkte type Lijst wanneer uitgevoerd. De Lijst dat werd aangenomen als argument bevat nu een Draad en een Geheel getal.

De compiler drukt een waarschuwing af vanwege het gebruik van onbewerkte typen:

Opmerking: RawTypeDemo.java gebruikt ongecontroleerde of onveilige bewerkingen. Opmerking: hercompileren met -Xlint: niet aangevinkt voor details.

5. Problemen tijdens runtime

Gebrek aan typeveiligheid op een onbewerkt type heeft een oorzakelijk effect dat tijdens runtime tot uitzonderingen kan leiden.

Laten we het vorige voorbeeld aanpassen zodat methode A. haalt het element op indexpositie 1 van onze Lijst na het bellen methode B.:

public void methodA () {List parameterizedList = nieuwe ArrayList (); parameterizedList.add ("Hallo mensen"); methodB (parameterizedList); String s = parameterizedList.get (1); } public void methodB (List rawList) {rawList.add (1); }

De code wordt gecompileerd (met dezelfde waarschuwing) en gooit een ClassCastException wanneer uitgevoerd. Dit gebeurt als de methode get (int index) geeft een Geheel getal, die niet kan worden toegewezen aan een variabele van het type Draad:

Uitzondering in thread "main" java.lang.ClassCastException: java.lang.Integer kan niet worden gecast naar java.lang.String

6. Conclusie

Raw-typen zijn moeilijk om mee te werken en kunnen bugs in onze code introduceren.

Het gebruik ervan kan rampzalige gevolgen hebben, en helaas gebeuren de meeste van deze rampen tijdens de uitvoering.

Bekijk alle fragmenten in deze tutorial op GitHub.