Java Wrapper Class (med exempel)

I den här handledningen lär vi oss om Java Wrapper-klassen med hjälp av exempel.

Omslags klasser i Java används för att omvandla primitiva typer ( int, char, float, etc.) i motsvarande objekt.

Var och en av de 8 primitiva typerna har motsvarande omslagsklasser.

Primitiv typ Omslagsklass
byte Byte
boolean Boolean
char Character
double Double
float Float
int Integer
long Long
short Short

Konvertera primitiv typ till förpackningsobjekt

Vi kan också använda valueOf()metoden för att konvertera primitiva typer till motsvarande objekt.

Exempel 1: Primitiva typer till förpackningsobjekt

 class Main ( public static void main(String() args) ( // create primitive types int a = 5; double b = 5.65; //converts into wrapper objects Integer aObj = Integer.valueOf(a); Double bObj = Double.valueOf(b); if(aObj instanceof Integer) ( System.out.println("An object of Integer is created."); ) if(bObj instanceof Double) ( System.out.println("An object of Double is created."); ) ) )

Produktion

Ett objekt av heltal skapas. Ett objekt av Double skapas.

I exemplet ovan har vi använt valueOf()metoden för att konvertera de primitiva typerna till objekt.

Här har vi använt instanceofoperatören för att kontrollera om de genererade objekten är av Integereller Doubletyp eller inte.

Men Java-kompilatorn kan direkt konvertera de primitiva typerna till motsvarande objekt. Till exempel,

 int a = 5; // converts into object Integer aObj = a; double b = 5.6; // converts into object Double bObj = b;

Denna process är känd som automatisk boxning . För att lära dig mer, besök Java autoboxing och unboxing.

Obs! Vi kan också konvertera primitiva typer till omslagningsobjekt med Wrapperklasskonstruktörer. Men användningen av konstruktörer kasseras efter Java 9.

Förpackningsobjekt till primitiva typer

Att konvertera föremål i primitiva typer, kan vi använda de motsvarande metoder värde ( intValue(), doubleValue(), etc) närvarande i varje wrapper klass.

Exempel 2: Förpackningsobjekt till primitiva typer

 class Main ( public static void main(String() args) ( // creates objects of wrapper class Integer aObj = Integer.valueOf(23); Double bObj = Double.valueOf(5.55); // converts into primitive types int a = aObj.intValue(); double b = bObj.doubleValue(); System.out.println("The value of a: " + a); System.out.println("The value of b: " + b); ) )

Produktion

 Värdet på a: 23 Värdet på b: 5,55

I ovanstående exempel, har vi använt den intValue()och doubleValue()metoden för att omvandla Integeroch Doubleföremål i motsvarande primitiva typer.

Men Java-kompilatorn kan automatiskt konvertera objekt till motsvarande primitiva typer. Till exempel,

 Integer aObj = Integer.valueOf(2); // converts into int type int a = aObj; Double bObj = Double.valueOf(5.55); // converts into double type double b = bObj;

Denna process är känd som unboxing . För att lära dig mer, besök Java autoboxing och unboxing.

Fördelar med förpackningsklasser

  • Ibland kan vi ibland behöva använda objekt istället för primitiva datatyper. Till exempel när du arbetar med samlingar. 
     // error ArrayList list = new ArrayList(); // runs perfectly ArrayList list = new ArrayList();
    I sådana fall hjälper omslagsklasser oss att använda primitiva datatyper som objekt.
  • Vi kan lagra nollvärdet i förpackningsobjekt. Till exempel, 
      // generates an error int a = null; // runs perfectly Integer a = null;

Obs! Primitiva typer är effektivare än motsvarande objekt. Därför, när effektivitet är kravet, rekommenderas det alltid primitiva typer.

Intressanta artiklar...