Wrapperklassen

In der Programmiersprache Java existieren einige primitive Datentypen, wie z.B.: int, double, boolean, char, usw. Für jeden dieser primitiven Datentypen existiert eine entsprechende Klasse, die einem primitiven Datentyp entspricht. So existiert in Java die Klasse Integer, Double, Boolean, Character, usw.

Hinweis: Zeichenketten sind auch Objekte. Diese sind Instanzen der Klasse String. Wenn also im Programmcode eine Zeichenkette mit "Meine Zeichenkette" definiert wird, erzeugt man indirekt ein neues Objekt, an das auch Methodenaufrufe geschickt werden können.

Zu einem primitiven Datentyp kann man sehr leicht das entsprechende Objekt erhalten. Im folgenden Beispiel werden zwei Integer Objekte angelegt, ein Wert inkrementiert und danach beide Werte ausgegeben.

  int i = 23;
  Integer j = new Integer(i);
  Integer k = new Integer(42);
  j = new Integer(j.intValue()+1);

  IO.println(j.intValue());
  IO.println(k.intValue());

Da hierbei eine Objektstruktur um einen primitiven Datentyp gewickelt wird, nennt man diese Klassen auch Wrapperklassen.

Will man den Wert eines Integer Objektes erhöhen, ist dies, wie im obigen Beispiel deutlich wird, recht umständlich. Dies liegt daran, dass einem Wrapperobjekt kein neuer Wert zugewiesen werden kann. Diese Objekte nennt man auch immutable, also unveränderbar.

In Java 5.0 wurde der Umgang mit diesen Wrapperklassen etwas vereinfacht. So ist es nun möglich einer Objektreferenz vom Typ einer Wrapperklasse direkt einen entsprechenden primitiven Datentyp zuzuweisen:

  int i = 23;
  Integer j = i;
  Integer k = 42;
  j++;

  IO.println(j);
  IO.println(k);

Diese direkte Zuweisung nennt man Boxing. Der Wert wird also in die Schachtel des Wrappers gepackt. Umgekehrt kann auch der Wert eines Wrapperobjektes direkt als primitiver Datentyp zurückgeliefert werden. Diesen Vorgang nennt man Unboxing und beides zusammen wird als Autoboxing bezeichnet. Diese vereinfachte Schreibweise ist durchaus bequem, man sollte allerdings auch auf die Nebenwirkungen achten. Schreibt man in seinem Quellcode z.B.: Integer j = 23; wird durch das Compilieren daraus folgender Code: Integer j = new Integer(23);.

Implementiert man z.B. eine for-Schleife, so könnte man folgendes programmieren:

  for (Integer i=0;i<1000;i++) {
    IO.println(i.intValue());
  }

Dieser Quellcode sieht auf den ersten Blick gut aus, allerdings werden hier ständig neue Objekte erzeugt, wodurch das Programm langsamer wird. In Wirklichkeit sieht obige Schleife nämlich wie folgt aus:

  for(Integer i=new Integer(0);
              i.intValue()<1000;
              i=new Integer(i.intValue()+1)) {
    IO.println(i.intValue());
  }

Es ist also immer darauf zu achten, wo man Boxing verwendet und ob man sich durch eine vereinfachte Schreibweise ggf. Nachteile einhandelt.

Eine weitere Neuerung in Java 5.0 ist die for-each-Schleife. Wird zum Beispiel ein Array von Integer-Objekten erzeugt, kann dieses wie gewohnt mit einer for-Schleife durchlaufen werden, oder aber mit einer for-each-Schleife:

  Integer [] a = new Integer[10];
  
  for (int i=0; i<10;i++) {      // Array mit Objekten/Werten fuellen
    a[i] = i;                    // Obacht: Boxing
  }
  
  for (int i=0; i<10;i++) {
    IO.println(a[i]);
  }
  
  for(Integer i: a) {            // fuer jedes Integer-Objekt aus a
    IO.println(i);               // 
  }

In der dritten Schleife verweist die Referenz i nach und nach einmal auf jedes Objekt im Array.