Die Java-Klassenbibliothek bietet zu jedem primitiven Datentyp eine korrespondierende Klasse an. Diese Klassen werden als Wrapper-Klassen bezeichnet. Wie wir diese speziellen Klassen einsetzen und wozu sie gut sind, erfahrt ihr hier!
In der Java Standardbibliothek gibt es zu jedem primitiven Datentyp eine korrespondierende Klasse. Diese Klassen werden Wrapper-Klassen genannt.
| Primitiver Datentyp | Wrapper-Klasse | Beispiel Konstruktor |
|---|---|---|
| boolean | java.lang.Boolean | new Boolean(true) |
| byte | java.lang.Byte | new Byte((byte) 1) |
| short | java.lang.Short | new Short((short) 1) |
| int | java.lang.Integer | new Integer(1) |
| long | java.lang.Long | new Long(1) |
| float | java.lang.Float | new Float(1.0) |
| double | java.lang.Double | new Double(1.0) |
| char | java.lang.Character | new Character('a') |
Übersetzt bedeutet das Wort wrapper soviel wie "Verpackung" oder "Hülle", womit der Charakter dieser Klassen bereits angedeutet ist:
Integer intWrapper = new Integer(7);
Double doubleWrapper = new Double(2.8);Hier sehen wir zwei Beispiele für Objekte der Wrapper-Klassen Integer und Double. Den jeweiligen Konstruktoren übergeben wir die primitiven Werte 7 bzw. 2.8, die damit in den entsprechenden Objekten verpackt sind. Man nennt dies Boxing.
Die Wrapper-Klassen haben bestimmte Methoden, mit denen wir den primitiven Wert wieder zurückgeliefert bekommen (Unboxing).
int intPrimitiv = intWrapper.intValue();
double doublePrimitive = doubleWrapper.doubleValue();
System.out.println(intPrimitiv); // 7
System.out.println(doublePrimitive); // 2.8Bei den anderen Wrapper-Klassen heißen die Methoden analog: booleanValue(), byteValue() und so weiter.
Um diese umständliche Syntax zu vereinfachen, sind seit Java 5 die Methoden intValue(), doubleValue() usw. für das Unboxing nicht mehr zwingend notwendig. Es genügt dem Compiler, wenn wir einfach die Referenzvariable notieren. Er führt die entsprechende Rückgabe des primitiven Werts dann automatisch aus:
System.out.println(intWrapper); // 7
System.out.println(doubleWrapper); // 2.8Dieses Prinzip nennt man Autoboxing.
Mit dem Autoboxing können wir sogar noch einen Schritt weitergehen und uns die explizite Objekterzeugung mit new auch ganz sparen:
Integer intWrapper1 = new Integer(10);
Integer intWrapper2 = 20; // AutoboxingDer Compiler weiß, dass nach der Deklaration der Integer-Variablen ein Integer-Objekt folgen muss. Schreiben wir nun das int-Literal (20) hinter den Zuweisungsoperator, erzeugt Java für uns "automatisch" das entsprechende Integer-Objekt.
Stellen wir uns einmal vor, wir möchten eine ArrayList erstellen, die Zahlen speichert. Kann folgender Versuch gelingen?
ArrayList<int> zahlenListe = new ArrayList<>(); // error!Wie wir wissen, ist ArrayList eine generische Klasse und Generics funktionieren ausschließlich mit Objekttypen. Da int kein Objekttyp ist, kann das auf diese Weise also nicht funktionieren.
Mithilfe der Wrapper-Klassen allerdings bekommen wir unsere ArrayList mit Zahlen:
ArrayList<Integer> zahlenListe = new ArrayList<>(); // cool!Statt dem primitiven Datentyp int tragen wir in die eckigen Klammern also Integer ein. Damit hat ArrayList, was es braucht: Einen Objekttyp.
Befüllen wir unsere Liste nun mit ein paar Integer-Objekten:
zahlenListe.add(2);
zahlenListe.add(8);Auch hier kommt wieder das Autoboxing zum Tragen: Der Compiler weiß nämlich durch die Deklaration ArrayList<Integer>, dass diese ArrayList nur Objekte der Wrapper-Klasse Integer aufnimmt. Tragen wir jetzt primitive int-Werte (wie 2 und 8) als Argumente in die add-Methode ein, wandelt Java diese automatisch in die entsprechenden Objekttypen um.
Mithilfe der Wrapper-Klassen können wir Strings in primitive Werte parsen. Dies gelingt uns mit folgenden statischen Methoden der einzelnen Wrapper-Klassen:
Ein paar konkrete Beispiele:
String s = "22";
int i = Integer.parseInt(s); // 22
String s2 = "19.99";
double d = Double.parseDouble(s2); // 19.99Die parseXXX-Methoden sind in Java besonders bei der Verarbeitung von GUI-Benutzereingaben wichtig. Diese werden nämlich als String an das Programm gesendet. Stellen wir uns nur mal vor, ein Benutzer gibt zwei Zahlen in Eingabefelder ein, die das Programm dann verrechnen soll. Das wäre mit Strings unmöglich:
String input1 = "8.2";
String input2 = "1.8";
double summe = input1 + input2; // Fehler!Deshalb müssen diese auf jeden Fall in entsprechende primitive Werte umgewandelt werden:
double summe = Double.parseDouble(input1) + Double.parseDouble(input2); // 10.0Java Basics
[Java einrichten] [Variablen] [Primitive Datentypen] [Operatoren] [if else] [switch-case] [Arrays] [Schleifen]
Objektorientierung
[Einstieg] [Variablen ] [Konstruktor] [Methoden] [Rekursion] [Statische Member] [Initializer] [Pass-by-value] [Objektsammlungen] [Objektinteraktion] [Objekte löschen]
Klassenbibliothek
[Allgemeines] [String ] [Math] [Wrapper] [Scanner] [java.util.Arrays] [Date-Time-API]
Vererbung
[Einstieg Vererbung] [Konstruktoren bei Vererbung ] [Der protected Zugriffsmodifikator] [Abstrakte Klassen und Methoden] [Polymorphie in Java] [Typumwandlung] [Die Klasse Object] [Die toString()-Methode] [Objekte vergleichen] [Was ist ein Interface?]
