Java Wrapper-klasse

In deze zelfstudie leren we over de Java Wrapper-klasse aan de hand van voorbeelden.

De wrapper-klassen in Java worden gebruikt om primitieve typen te converteren (int , char , float , etc) in corresponderende objecten.

Elk van de 8 primitieve typen heeft corresponderende wrapper-klassen.

Primitief type converteren naar wrapper-objecten

We kunnen ook de valueOf() . gebruiken methode om primitieve typen om te zetten in corresponderende objecten.

Voorbeeld 1:Primitieve typen tot wrapper-objecten

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.");
    }
  }
}

Uitvoer

An object of Integer is created.
An object of Double is created.

In het bovenstaande voorbeeld hebben we de valueOf() . gebruikt methode om de primitieve typen om te zetten in objecten.

Hier hebben we de instanceof . gebruikt operator om te controleren of de gegenereerde objecten van Integer . zijn of Double typ of niet.

De Java-compiler kan de primitieve typen echter direct omzetten in overeenkomstige objecten. Bijvoorbeeld,

int a = 5;
// converts into object
Integer aObj = a;

double b = 5.6;
// converts into object
Double bObj = b;

Dit proces staat bekend als auto-boxing . Ga voor meer informatie naar Java autoboxing en unboxing.

Opmerking :We kunnen primitieve typen ook converteren naar wrapper-objecten met behulp van Wrapper klasse constructeurs. Maar het gebruik van constructors wordt weggegooid na Java 9.

Wrapper objecten in primitieve typen

Om objecten om te zetten in de primitieve typen, kunnen we de corresponderende waardemethoden gebruiken (intValue() , doubleValue() , etc) aanwezig in elke wrapper-klasse.

Voorbeeld 2:Wikkel objecten in primitieve typen

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

Uitvoer

The value of a: 23
The value of b: 5.55

In het bovenstaande voorbeeld hebben we de intValue() . gebruikt en doubleValue() methode om de Integer . te converteren en Double objecten in overeenkomstige primitieve typen.

De Java-compiler kan objecten echter automatisch converteren naar overeenkomstige primitieve typen. Bijvoorbeeld,

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;

Dit proces staat bekend als unboxing . Ga voor meer informatie naar Java autoboxing en unboxing.

Voordelen van Wrapper-klassen

• In Java moeten we soms objecten gebruiken in plaats van primitieve gegevenstypen. Bijvoorbeeld tijdens het werken met collecties.

  // error
  ArrayList<int> list = new ArrayList<>();
  
  // runs perfectly
  ArrayList<Integer> list = new ArrayList<>();

  In dergelijke gevallen helpen wrapper-klassen ons om primitieve gegevenstypen als objecten te gebruiken.
• We kunnen de null-waarde opslaan in wrapper-objecten. Bijvoorbeeld

  
  // generates an error
  int a = null;
  
  // runs perfectly
  Integer a = null;
  

Opmerking :Primitieve typen zijn efficiënter dan overeenkomstige objecten. Daarom, wanneer efficiëntie de vereiste is, worden primitieve typen altijd aanbevolen.