Wrapperklassen in Java

Hoi! Je bent al goed bekend met primitieve typen en hebt er al veel mee gewerkt. Bij het programmeren (en Java in het bijzonder) hebben primitieven veel voordelen: ze gebruiken weinig geheugen (en maken het programma dus efficiënter) en hebben een duidelijk afgebakend waardenbereik. Tijdens het leren van Java hebben we echter al vaak de mantra "alles in Java is een object" herhaald. Maar primitieven zijn rechtstreeks in tegenspraak met die woorden. Het zijn geen voorwerpen. Dus, is ons "alles is een object"-principe onjuist? Eigenlijk is het dat niet. In Java heeft elk primitief type een tweelingbroer, een wrapper-klasse.

Wat is een Wrapper-klasse?

Een wrapper is een speciale klasse die een primitief intern opslaat. Maar omdat het een klasse is, kunt u er instanties van maken. Ze slaan de primitieve waarden intern op, maar zijn nog steeds echte objecten. De namen van de Wrapper-klassen lijken erg op (of zijn precies hetzelfde als) de namen van hun overeenkomstige primitieven. Ze zijn dus gemakkelijk te onthouden. Wrapper-objecten worden op dezelfde manier gemaakt als elk ander object:

public static void main(String[] args) {

   Integer i = new Integer(682);
  
   Double d = new Double(2.33);
  
   Boolean b = new Boolean(false);
}

Met wrapperklassen kunnen we de tekortkomingen van primitieve typen verminderen. Het meest voor de hand liggende is dat primitieven geen methoden hebben. Ze hebben bijvoorbeeld geen toString() methode, dus je kunt bijvoorbeeld een int niet converteren naar een String . Maar de Integer- wrapperklasse maakt dit gemakkelijk.

public static void main(String[] args) {

   Integer i = new Integer(432);
  
   String s = i.toString();
}

Het omzetten in de andere richting kan echter lastiger zijn. Laten we zeggen dat we een String hebben , waarvan we zeker weten dat deze een nummer bevat. Hoe dan ook, er is geen native manier om een ​​primitieve int te gebruiken om het getal uit de string te extraheren en om te zetten in een getal. Maar dat kunnen we met de wrapper-klassen.

public static void main(String[] args) {

   String s = "1166628";

   Integer i = Integer.parseInt(s);

   System.out.println(i);
}

Uitgang:

1166628

We hebben met succes een nummer uit de String gehaald en toegewezen aan de Integer- referentievariabele i . Trouwens, wat referenties betreft. U weet al dat argumenten op verschillende manieren aan methoden worden doorgegeven: primitieven op waarde en objecten op verwijzing. U kunt deze kennis gebruiken bij het maken van uw eigen methoden: als uw methode bijvoorbeeld breukgetallen gebruikt, maar u logica nodig hebt om door verwijzing door te geven, kunt u Double / Float- argumenten aan de methode doorgeven in plaats van double / float . Naast de methoden van wrapperklassen kunnen hun statische velden ook erg handig zijn. Stel je bijvoorbeeld voor dat je de volgende taak hebt: het maximaal mogelijke weergevenint waarde, gevolgd door de minimaal mogelijke waarde. Dit probleem lijkt vrij eenvoudig. Maar zonder Google is het onwaarschijnlijk dat u het zou kunnen doen. Maar met wikkels kunt u dergelijke "alledaagse taken" gemakkelijk aan:

public class Main {
   public static void main(String[] args) {

       System.out.println(Integer.MAX_VALUE);
       System.out.println(Integer.MIN_VALUE);
   }
}

Deze velden zorgen ervoor dat u niet wordt afgeleid van het volbrengen van serieuzere taken. Om nog maar te zwijgen van het feit dat het typen van 2147483647 (wat toevallig de waarde is van MAX_VALUE) geen sinecure is! :) Bovendien hebben we er in een vorige les op gewezen dat wrapper-objecten onveranderlijk zijn.

public static void main(String[] args) {

   Integer a = new Integer(0);
   Integer b = new Integer(0);

   b = a;
   a = 1;
   System.out.println(b);
}

Uitgang:

0

De toestand van het object waarnaar oorspronkelijk door a werd verwezen , veranderde niet (omdat de waarde van b ook zou zijn veranderd). Net als bij String s, wordt in plaats van de status van het wrapper-object te wijzigen, een geheel nieuw object in het geheugen gemaakt. Dus waarom besloten de makers van Java uiteindelijk om primitieve typen in de taal te laten? Aangezien alles een object zou moeten zijn en we wrapper-klassen hebben die alles kunnen uitdrukken wat primitieven uitdrukken, waarom zouden we dan niet alleen de wrappers in de taal houden en de primitieven verwijderen? Het antwoord is simpel: prestaties. Primitieve typen worden primitief genoemd omdat ze veel van de "zware" kenmerken van objecten missen. Ja, objecten hebben veel handige methoden, maar je hebt ze niet altijd nodig. Soms is alles wat je nodig hebt het getal 33, of 2,62, of waar / niet waar . In situaties waarin de voordelen van objecten er niet toe doen en niet nodig zijn om het programma te laten functioneren, zijn primitieven veel beter geschikt voor de taak.