Jetzt anmelden...

Login
Passwort
Registrieren

Java Tutorial #22

Wrapper-Klassen in Java

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!

Kommentare [0]

Stefan 08.08.2019

Infos zum Artikel

Kategorie Java
Autor Stefan
Datum 08.08.2019

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

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 parseInteger(String s)
static long parseLong(String s)
static float parseFloat(String s)
static double parseDouble(String s)
static int parseInteger(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-Benutzeringaben 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.

Lösung ein-/ausblenden

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);
Lösung ein-/ausblenden

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.

Lösung ein-/ausblenden

Kommentar schreiben

Nur angemeldete und aktivierte Benutzer können kommentieren.

Alle Kommentare

Es gibt bislang noch keine Kommentare zu diesem Thema.

Arrays in Java

Arrays ermöglichen das Speichern von Daten in einer übergeordneten Datenstruktur

Java Variablen erklärt

Wie werden Variablen eingesetzt? Was bedeutet Deklarieren und Initialisieren?

Initializer

Eher selten aber praktisch!

FALCONBYTE.NET

Handmade with 🖤️

© 2018, 2019 Stefan E. Heller

Impressum | Datenschutz

facebook programmieren lernen twitter programmieren lernen youtube programmieren lernen