Wrapper klasser

1. Lista över omslagstyper

Du vet att Java har 8 primitiva typer, vilket är typer som inte är klasser. Å ena sidan är det här bra - de är enkla och tar liten plats. Å andra sidan, ibland är lektioner precis vad vi behöver. Du kommer att få reda på exakt varför det är i nästa lektion.

Så vad kan göras?

Från och med den femte versionen av Java fick varje primitiv typ en tvillingklass. Varje sådan klass lagrar ett enda fält med ett värde av en specifik typ. Dessa klasser kallas omslagstyper eftersom de lindar in primitiva värden i klasser.

Här är en lista över dessa typer. Vet du några?

byte

Byte

short

Short

int

Integer

long

Long

float

Float

double

Double

char

Character

boolean

Boolean

Namnen på primitiva typer börjar med en liten bokstav, men namnen på omslagsklasserna börjar med en stor bokstav. Vissa av klassnamnen är också lite längre: Integerinstead of intи Characterinstead of char.

Alla objekt i omslagsklasserna är oföränderliga ( oföränderliga ).

Förenklad kod för Integerklassen ser ut ungefär så här:

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. Konvertera an inttill anInteger

Omslagstyper anses vara motsvarigheter till sina primitiva syskon: du kan enkelt skapa ett omslagsobjekt som motsvarar en primitiv typ.

Låt oss använda int-typen som ett exempel för att analysera hur primitiva typer interagerar med sina motsvarande omslagstyper. Koden för att konvertera från en inttill en Integeroch vice versa skulle se ut så här:

För att konvertera en inttill en Integermåste du skriva denna kod:

Integer name = new Integer(value);

Var nameär namnet på en Integervariabel och valueär det omslutna intvärdet.

Exempel:

Integer age = new Integer(18);

Integer hundred = new Integer(100);

Integer zero = new Integer(0);

Och för att konvertera an Integertill an intmåste du skriva denna kod:

int name = variable.intValue();

Var nameär namnet på en intvariabel och variableär en referens till ett Integerobjekt.

Exempel:

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. Autoboxning och unboxning

Men även enkla operationer med Integertypen är inte lätta att skriva.

Som vi sa tidigare Integerär typen oföränderlig ( oföränderlig ). För att skapa ett Integerobjekt med ett nytt intvärde måste du uttryckligen skapa ett nytt Integerobjekt. Som sagt, det är lätt att få värdet av ett intlagrat inuti ett Integerobjekt - anrop bara intValue()metoden.

Exempel:

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

Det här är ganska besvärlig kod, tycker du inte?

Javas skapare trodde det, så de lärde kompilatorn hur man gör dessa operationer automatiskt. Den automatiska omvandlingen av an inttill an Integerkallas autoboxning (automatiskt sätta värdet i en ruta), och den omvända operationen (konvertera an Integertill en int) kallas unboxing .

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);

Tack vare autoboxning och unboxing kan du säkert tilldela en inttill en Integervariabel och vice versa. Du kan skriva uttryck av vilken komplexitet som helst utan att göra skillnad mellan typerna intoch .Integer

Exempel:

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. Jämföra omslagsvariabler

Autoboxning och unboxing är enkla och transparenta processer. Vi använder new Integer()påståenden efter behov, och vi kallar intValue()metoden efter behov.

Allt fungerar bra och enkelt för dig, programmeraren. Tänk på att om du jämför en Integeroch en Integer, så baseras jämförelsen på referens och inte värden.

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

Variablerna aoch blagrar inte intvärden. De lagrar referenser till objekt. Det betyder att det är viktigt att komma ihåg hur man jämför dem korrekt:

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

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