Wrapper-klassen

1. Lijst met soorten wikkels

U weet dat Java 8 primitieve typen heeft, dit zijn typen die geen klassen zijn. Aan de ene kant is dit goed - ze zijn eenvoudig en nemen weinig ruimte in beslag. Aan de andere kant zijn lessen soms precies wat we nodig hebben. Waarom dat precies is, lees je in de volgende les.

Dus wat kan er gedaan worden?

Vanaf de vijfde versie van Java kreeg elk primitief type een dubbele klasse. Elke dergelijke klasse slaat een enkel veld op met een waarde van een specifiek type. Deze klassen worden wrappertypes genoemd , omdat ze primitieve waarden in klassen verpakken.

Hier is een lijst van deze typen. Weet jij er een?

byte

Byte

short

Short

int

Integer

long

Long

float

Float

double

Double

char

Character

boolean

Boolean

De namen van primitieve typen beginnen met een kleine letter, maar de namen van de wrapperklassen beginnen met een hoofdletter. Sommige klassennamen zijn ook iets langer: Integerinstead of intи Characterinstead of char.

Alle objecten van de wrapper-klassen zijn onveranderlijk ( onveranderlijk ).

Vereenvoudigde code voor de Integerklasse ziet er ongeveer zo uit:

public class Integer
{
   private int value;

   Integer(int x)
   {
      this.value = x;
   }

   public int intValue()
   {
      return this.value;
   }

   public static Integer valueOf(int x)
   {
      return new Integer(x);
   }
}

2. Een omzetten intnaar eenInteger

Wrapper-typen worden beschouwd als tegenhangers van hun primitieve broers en zussen: u kunt eenvoudig een wrapper-object maken dat overeenkomt met een primitief type.

Laten we het int-type als voorbeeld gebruiken om te analyseren hoe primitieve typen interageren met hun overeenkomstige wrapper-typen. De code voor het converteren van een intnaar een Integeren vice versa ziet er als volgt uit:

Om een int​​naar een te converteren Integer, moet je deze code schrijven:

Integer name = new Integer(value);

Waar nameis de naam van een Integervariabele en valueis de ingepakte intwaarde.

Voorbeelden:

Integer age = new Integer(18);

Integer hundred = new Integer(100);

Integer zero = new Integer(0);

En om de an Integernaar een te converteren int, moet je deze code schrijven:

int name = variable.intValue();

Waar nameis de naam van een intvariabele en variableis een verwijzing naar een Integerobject.

Voorbeelden:

Integer age = new Integer(18);
int x = age.intValue();

x == 18

Integer hundred = new Integer(100);
int y = hundred.intValue();

y == 100

Integer zero = new Integer(0);
int z = zero.intValue();

z == 0

int i = 110;
Integer zero = new Integer(i);
int z = zero.intValue();

z == 110

3. Autoboxen en uitpakken

Maar zelfs eenvoudige bewerkingen met het Integertype zijn niet gemakkelijk te schrijven.

Zoals we eerder zeiden, Integeris het type onveranderlijk ( onveranderlijk ). Als u een Integerobject met een nieuwe intwaarde wilt maken, moet u expliciet een nieuw Integerobject maken. Dat gezegd hebbende, het is gemakkelijk om de waarde van een intopgeslagen in een Integerobject te krijgen - roep gewoon de intValue()methode aan.

Voorbeeld:

Integer a = Integer.valueOf(5);
int b = a.intValue();
Integer c = new Integer(b + 5)

Dit is nogal omslachtige code, vind je niet?

De makers van Java dachten van wel, dus leerden ze de compiler hoe deze bewerkingen automatisch moesten worden uitgevoerd. De automatische conversie van an intnaar an wordt autoboxingInteger genoemd (automatisch de waarde in een box plaatsen), en de omgekeerde bewerking (conversie van an naar een ) wordt unboxing genoemd .Integerint

Integer a = 10;

Integer a = Integer.valueOf(10);

int b = a;

int b = a.intValue();

Integer c = a + b;

Integer c = Integer.valueOf(a.intValue() + b);

Dankzij autoboxing en unboxing kun je veilig een intaan een Integervariabele toewijzen en vice versa. U kunt uitdrukkingen van elke complexiteit schrijven zonder een onderscheid te maken tussen de typen inten Integer.

Voorbeelden:

Integer a = 5;
int b = a;
Integer c = a + b;
int d = a + b + c;

Integer a = Integer.valueOf(5);
int b = a.intValue();
Integer c = Integer.valueOf(a.intValue() + b);
int d = a.intValue() + b + c.intValue();

Integer a = 5;
int b = 5;

if (a == b)
{
   ...
}

Integer a = Integer.valueOf (5);
int b = 5;

if (a.intValue() == b)
{
   ...
}

4. Wrappervariabelen vergelijken

Autoboxing en unboxing zijn eenvoudige en transparante processen. We gebruiken new Integer()verklaringen als dat nodig is, en we roepen de intValue()methode aan als dat nodig is.

Alles werkt lekker makkelijk voor jou, de programmeur. Houd er rekening mee dat als u an Integeren an vergelijkt Integer, de vergelijking gebaseerd is op referentie en niet op waarden.

Integer a = 1000;
Integer b = 1000;

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

false

Integer a = 1000;
Integer b = 1000;

System.out.println(a.equals(b));

true

De variabelen aen bslaan geen intwaarden op. Ze slaan verwijzingen naar objecten op. Dat betekent dat het belangrijk is om te onthouden hoe u ze correct kunt vergelijken:

Integer a = 1000;
Integer b = 1000;
if (a == b)
{
   ...
}

Integer a = 1000;
Integer b = 1000;
if (a.equals(b))
{
   ...
}