Falconbyte unterstüzen
Betrieb und Pflege von Falconbyte brauchen viel Zeit und Geld. Um dir auch weiterhin hochwertigen Content anbieten zu können, kannst du uns sehr gerne mit einem kleinen "Trinkgeld" unterstützen.
Thema in Kurzform
// primitiver Datentyp int
int i = 2;
// Objekt vom Typ Integer
Integer intWrapper = new Integer(2);
// Mithilfe der Wrapper sind Listen mit Zahlenwerten möglich:
ArrayList<Integer> liste = new ArrayList<>();
liste.add(10);
liste.add(20);
- Was sind Wrapper-Klassen?
- Autoboxing
- Wozu sind Wrapper-Klassen gut?
- Übungen
Inhaltsverzeichnis
Was sind Wrapper-Klassen
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:
- Instanzen der Wrapper-Klassen dienen als objektorientierte Hüllen um primitive Werte.
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.8
Bei den anderen Wrapper-Klassen heißen die Methoden analog: booleanValue(), byteValue() und so weiter.
Autoboxing
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.8
Dieses 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; // Autoboxing
Der 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.
Wozu sind Wrapper-Klassen gut?
Arbeiten mit Listen
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.
String in primitiven Wert umwandeln
Mithilfe der Wrapper-Klassen können wir Strings in primitive Werte parsen. Dies gelingt uns mit folgenden statischen Methoden der einzelnen Wrapper-Klassen:
static boolean parseBoolean(String s)
static byte parseByte(String s)
static short parseShort(String s)
static int parseInt(String s)
static long parseLong(String s)
static float parseFloat(String s)
static double parseDouble(String s)
static int parseInt(String s)
Ein paar konkrete Beispiele:
String s = "22";
int i = Integer.parseInt(s); // 22
String s2 = "19.99";
double d = Double.parseDouble(s2); // 19.99
Die 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.0
Übungen
einfach
Erstelle eine ArrayList, die Objekte vom Typ Double speichern kann. Gib der ArrayList anschließend drei selbst gewählte Elemente.
mittel
Genau hingesehen: Wieviele Fehler sind im folgenden Code versteckt?
int i1 = Integer.parseInt("731");
int i2 = Integer.parseInt("731.20");
boolean b1 = Boolean.parseBoolean("true");
boolean b2 = Boolean.parseBoolean(true);
schwer
Welche der Aussagen zu folgendem Code sind richtig?
ArrayList<Integer> zahlen = new ArrayList<>();
zahlen.add(Integer.parseInt("4"));
zahlen.add(Integer.valueOf("8"));
zahlen.add(12);
zahlen.add(null);
for(int sV : zahlen){
System.out.println(sV);
}
A. Der Code lässt sich compilieren.
B. Der Code wirft eine runtime-Exception
C. Eines der add-Anweisungen verwendet Autoboxing.
D. Zwei der add-Anweisungen verwendet Autoboxing.
E. Drei der add-Anweisungen verwendet Autoboxing.
F. Es ist nicht erlaubt, null zu adden.