Methoden und Wrapperklassen

Themen der Übung
Methoden und Wrapperklassen
1
Organisatorisches
2
Methoden
3
Wrapper-Klassen
CoMa-Übung IV
Organisatorisches:
TU Berlin
Im Pool nur auf die Abgabeliste setzen, wenn ihr wirklich fertig seid!
07.11.2012
Christians Abgaben in seinem Tutorium
Bei Gruppenwechsel:
Umtragen mit Tutor im Unix-Pool
eMail mit Daten der veränderten Personen an Madeleine
CoMa-Übung IV (TU Berlin)
Methoden und Wrapperklassen
07.11.2012
1 / 31
Methoden
Methoden und Wrapperklassen
07.11.2012
2 / 31
Vorteile von Methoden
Grundlagen
Vorteil 1: Übersicht
Methoden sind Javas Konzept von Algorithmen.
Die Benutzung von Methoden teilt Programme in viele kleine
Algorithmen auf.
Methoden haben festgelegte Eingaben und Ausgaben, sowie eine
Folge von Befehlen, die aus der Eingabe die Ausgabe erzeugen.
Gibt dem Programm eine Struktur.
Methoden gehören in Java immer zu einer Klasse oder einem Objekt.
Diese Klasse bzw. dieses Objekt wird dann Eigentümer der Methode
genannt.
Vorteil 2: Wiederverwendbarkeit
Jeder Algorithmus muss nur einmal geschrieben werden
Algorithmus, der das Minimum zweier Werte zurückgibt.
Spart Arbeit
Eingabe: zwei int-Werte.
Macht nachträgliche Änderungen leichter
Ausgabe: der Minimum der beiden int-Werte.
Vermeidet unnötige Code-Wiederholungen.
Gehört zu der Klasse Math.
Methoden und Wrapperklassen
Kleinere Algorithmen sind leichter verständlich.
Methoden können vom ganzen Programm verwendet werden
Math.min(int a, int b)
CoMa-Übung IV (TU Berlin)
CoMa-Übung IV (TU Berlin)
07.11.2012
3 / 31
CoMa-Übung IV (TU Berlin)
Methoden und Wrapperklassen
07.11.2012
4 / 31
Deklaration von Methoden
Bestandteile einer Methode – Beispiel 1
Bestandteile einer Methode
Erinnerung: Die Signatur einer Methode besteht aus ihrem Namen und der
Liste der Typen ihrer Parameter.
Methoden bestehen aus zwei Teilen, dem Methodenkopf und dem
Methodenrumpf. Der Methodenkopf besteht aus
Beispiel
1
Modifizieren,
2
einem Rückgabetyp,
3
dem Methodennamen,
p u b l i c s t a t i c l o n g sum ( l o n g a , l o n g b ) {
return a + b ;
}
Methodenkopf:
und einer Parameterliste.
I
Der Methodenrumpf besteht aus den Anweisungen der Methode.
I
I
I
Signatur einer Methode
Unter der Signatur einer Methode versteht man ihren Methodennamen
und die Typen ihrer Parameterliste. Modifikatoren, der Rückgabetyp und
der Methodenrumpf gehören nicht dazu.
CoMa-Übung IV (TU Berlin)
Methoden und Wrapperklassen
07.11.2012
5 / 31
Modifizierer: public und static
Rückgabetyp: long
Methodenname: sum
Parameterliste: long a, long b
Methodenrumpf:
I
Besteht nur aus der Anweisung return a + b;
Die Signatur der Methode ist sum(long,long) – der Methodenname
ist sum und die Methode hat zwei Parameter, beide vom Typ long.
CoMa-Übung IV (TU Berlin)
Methoden und Wrapperklassen
07.11.2012
6 / 31
Rückgaben in Methoden
Klassenmethoden
return
Der Befehl return; beendet die Ausführung einer Methode und gibt
nichts zurück.
Methoden in Java können zwei Arten von Eigentümern haben: Klassen
und Objekte. Demetsprechend lassen sie sich in zwei Kategorien aufteilen:
Klassenmethoden und Objektmethoden.
Der Befehl return a; beendet die Ausführung einer Methode und
gibt a an den Aufrufer zurück.
Klassenmethoden
Werden durch den Modifizierer static in der Methoden-Deklaration
gekennzeichnet (ohne static Objektmethode).
return und der Rückgabetyp
Der Befehl return; darf nur in Methoden benutzt werden, deren
Rückgabetyp void ist.
Beispiel: public static void main(String[] args)
Der Befehl return a; darf nur in Methoden benutzt werden, deren
Rückgabetyp nicht void ist; außerdem muss der Typ von a zu dem
Rückgabetyp der Methode passen.
Werden üblicherweise in der Form
Klassenname.Methodenname(Parameterliste) aufgerufen.
Arbeiten nur mit Klassen und brauchen keine Objekte.
Hat eine Methode einen Rückgabetyp, der nicht void ist, muss die
Methode mit einem return-Befehl enden, der einen passenden Typ
zurückgibt.
CoMa-Übung IV (TU Berlin)
Methoden und Wrapperklassen
07.11.2012
7 / 31
Objektmethoden hingegen müssen an einem Objekt aufgerufen
werden.
Wir arbeiten zunächst nur mit Klassenmethoden.
CoMa-Übung IV (TU Berlin)
Methoden und Wrapperklassen
07.11.2012
8 / 31
Bestandteile einer Methode – Beispiel 2
Namen und Typen
Erinnerung: Die Signatur einer Methode besteht aus ihrem Namen und der
Liste der Typen ihrer Parameter.
Namenskonvention für Methoden
Methodennamen werden mit einem Kleinbuchstaben begonnen.
Beispiel
1
2
3
Methodennamen fangen üblicherweise mit einem Verb an.
Character f i r s t C h a r ( String s t r ) {
return s t r . charAt (0) ;
}
Methoden dürfen nicht wie Schlüsselwörter heißen – class, int,
double, ... sind also tabu.
Methode heißt wie Schlüsselwort → Fehler beim Kompilieren.
Methodenkopf:
I
I
I
I
Modifizierer: keiner
Rückgabetyp: Character
Methodenname: firstChar
Parameterliste: String str
Parameter- und Rückgabetypen
Typen für Parameter können sein:
I
I
Methodenrumpf:
I
Der Rückgabetyp kann sein:
Besteht nur aus der Anweisung return str.charAt(0);
I
Die Signatur der Methode ist firstChar(String) – der Methodenname ist
firstChar und die Methode hat einen Parameter vom Typ String.
CoMa-Übung IV (TU Berlin)
Methoden und Wrapperklassen
07.11.2012
jeder primitive Datentyp (boolean, byte, char, ...),
jeder Referenztyp (Character, String, ...),
9 / 31
I
jeder für Parameter erlaubte Typ,
der spezielle Rückgabetyp void, falls nichts zurückgeben wird.
CoMa-Übung IV (TU Berlin)
Methoden und Wrapperklassen
07.11.2012
10 / 31
Parameter und Signatur
Bestandteile einer Methode – Beispiel 3
Parameter
Erinnerung: Die Signatur einer Methode besteht aus ihrem Namen und der
Liste der Typen ihrer Parameter.
Wie Variablen in der Form Datentyp parametername deklariert.
Beispiel
Jeder Parameter muss einen Typ haben.
→ Kurzform double a,b ist nicht erlaubt!
1
2
Mehrere Parameter werden durch , getrennt.
3
Methode mit leerer Parameterliste → die Liste besteht nur aus ().
public void h e l l o () {
System . o u t . p r i n t l n ( ” H e l l o ” ) ;
}
Methodenkopf:
Parameter werden wie Variablen benutzt in der Methode.
I
I
Signatur
I
Der Kompiler sucht Methoden anhand ihrer Signatur in den
Methoden des Eigentümers.
I
Methodenrumpf:
→ Jede Methode eines Eigentümers muss eine eindeutige Signatur
haben!
I
Methoden und Wrapperklassen
07.11.2012
Besteht nur aus der Anweisung System.out.println("Hello");
Die Signatur der Methode ist hello() – der Methodenname ist
hello und die Methode hat keine Parameter.
→ Kompiler-Fehler sonst.
CoMa-Übung IV (TU Berlin)
Modifizierer: public
Rückgabetyp: void
Methodenname: hello
Parameterliste: keine Parameter
11 / 31
CoMa-Übung IV (TU Berlin)
Methoden und Wrapperklassen
07.11.2012
12 / 31
Deklaration von Methoden – Zusammenfassung
Methodenaufruf
Deklaration von Methoden
Aufruf einer Methode
Eine Methodendeklaration hat in Java folgenden Aufbau:
Der Aufruf einer Methode besteht aus 3 Teilen:
Modifizieren,
I
I
gefolgt von genau einem Rückgabetyp,
I
dem Methodennamen,
einer (möglicherweise leeren) Liste von Parametern,
I
I
Die Syntax für den Aufruf dieser Bestandteile ist:
Eigentümer.Methodenname(Parameter1,Parameter2,...)
die in runde Klammern ( ) eingeschlossen ist,
deren Parameter durch , getrennt sind,
Eigentümer. kann weggelassen werden, wenn die aufgerufene
Methode in derselben Klasse ist wie die aufrufende.
und dem Methodenrumpf,
I
Dem Eigentümer der Methode,
dem Namen der Methode,
und Argumenten für die von der Methode erwarten Parametern.
der in geschweifte Klammern { } eingeschlossen ist.
Argumente
Diese Bestandteile müssen in genau dieser Reihenfolge erscheinen.
Argumente sind konkrete Werte für die Parameter einer Methode.
Signatur einer Methode
z.B. kann 2 ein Argument für einen int-Parameter einer Methode
sein.
Die Signatur einer Methode besteht aus ihrem Namen und der Liste der
Typen ihrer Parameter.
CoMa-Übung IV (TU Berlin)
Methoden und Wrapperklassen
07.11.2012
13 / 31
Der Typ eines Arguments muss zum Typ des Parameters passen.
CoMa-Übung IV (TU Berlin)
Methodenaufruf
Methodenaufruf
Aufruf einer Methode
Aufruf einer Methode
Der Aufruf einer Methode besteht aus 3 Teilen:
I
I
I
I
I
I
Dem Eigentümer der Methode,
dem Namen der Methode,
und Argumenten für die von der Methode erwarten Parametern.
Beispiel 2 – Math.max(int a, int b)
do ub l e t e m p e r a t u r e = 5 . 6 ;
l o n g r o u n d e d T e m p e r a t u r e = Math . round ( t e m p e r a t u r e ) ;
1
2
int a = 3;
i n t maximum = Math . max ( a , 4 ) ;
Eigentümer: die Klasse Math
Eigentümer: die Klasse Math
Methodenname: round
Methodenname: max
Argumente: die double-Variable temperature
Argumente: die int-Variable a und die int-Konstante 4
CoMa-Übung IV (TU Berlin)
Methoden und Wrapperklassen
14 / 31
Die Syntax für den Aufruf dieser Bestandteile ist:
Eigentümer.Methodenname(Parameter1,Parameter2,...)
Beispiel 1 – Math.round(double d)
2
07.11.2012
Der Aufruf einer Methode besteht aus 3 Teilen:
Dem Eigentümer der Methode,
dem Namen der Methode,
und Argumenten für die von der Methode erwarten Parametern.
Die Syntax für den Aufruf dieser Bestandteile ist:
Eigentümer.Methodenname(Parameter1,Parameter2,...)
1
Methoden und Wrapperklassen
07.11.2012
15 / 31
CoMa-Übung IV (TU Berlin)
Methoden und Wrapperklassen
07.11.2012
16 / 31
Übergabe von Argumenten
Methodenaufruf
Aufruf einer Methode
Was passiert bei der Übergabe von Argumenten an Methoden?
Der Aufruf einer Methode besteht aus 3 Teilen:
I
I
I
1
Dem Eigentümer der Methode,
dem Namen der Methode,
und Argumenten für die von der Methode erwarten Parametern.
2
3
4
Die Syntax für den Aufruf dieser Bestandteile ist:
Eigentümer.Methodenname(Parameter1,Parameter2,...)
5
6
7
8
Beispiel 3 – Scanner.nextDouble()
1
2
p u b l i c s t a t i c v o i d changeA ( i n t a ) {
a = a + 1;
}
9
S c a n n e r s c a n n e r = new S c a n n e r ( System . i n ) ;
do ub l e t e m p e r a t u r e = s c a n n e r . n e x t D o u b l e ( ) ;
p u b l i c s t a t i c v o i d main ( S t r i n g [ ] a r g s ) {
int a = 1;
changeA ( a ) ;
System . o u t . p r i n t l n ( a ) ;
}
Wird ein Variable als Argument an eine Methode übergeben, wird eine
Kopie ihres Werts erzeugt und an die Methode übergeben.
Eigentümer: das Objekt scanner
Methoden verändern also keine Variablen in der aufrufenden Methode.
Methodenname: nextDouble
changeA hat also keinen Einfluss auf den Wert von a in der
main-Methode.
Argumente: die Methode erwartet keine
CoMa-Übung IV (TU Berlin)
Methoden und Wrapperklassen
07.11.2012
17 / 31
Verschachtelte Methodenaufrufe
1
2
3
6
7
public static int multiply ( int a , int b) {
r e t u r n a ∗b ;
}
1
2
3
10
11
07.11.2012
18 / 31
07.11.2012
19 / 31
public static int multiply ( int a , int b) {
r e t u r n a ∗b ;
}
4
p u b l i c s t a t i c i n t square ( i n t a )
return multiply (a , a) ;
}
{
5
6
7
8
9
Methoden und Wrapperklassen
Verschachtelte Methodenaufrufe
4
5
CoMa-Übung IV (TU Berlin)
p u b l i c s t a t i c i n t square ( i n t a )
return multiply (a , a) ;
}
{
8
p u b l i c s t a t i c v o i d main ( S t r i n g [ ] a r g s ) {
System . o u t . p r i n t l n ( s q u a r e ( 2 ) ) ;
}
9
10
11
p u b l i c s t a t i c v o i d main ( S t r i n g [ ] a r g s ) {
System . o u t . p r i n t l n ( s q u a r e ( 2 ) ) ;
}
main
CoMa-Übung IV (TU Berlin)
Methoden und Wrapperklassen
07.11.2012
19 / 31
CoMa-Übung IV (TU Berlin)
Methoden und Wrapperklassen
Verschachtelte Methodenaufrufe
1
2
3
Verschachtelte Methodenaufrufe
public static int multiply ( int a , int b) {
r e t u r n a ∗b ;
}
1
2
3
4
5
6
7
4
p u b l i c s t a t i c i n t square ( i n t a )
return multiply (a , a) ;
}
{
5
6
7
8
9
10
11
public static int multiply ( int a , int b) {
r e t u r n a ∗b ;
}
p u b l i c s t a t i c i n t square ( i n t a )
return multiply (a , a) ;
}
8
p u b l i c s t a t i c v o i d main ( S t r i n g [ ] a r g s ) {
System . o u t . p r i n t l n ( s q u a r e ( 2 ) ) ;
}
9
10
11
p u b l i c s t a t i c v o i d main ( S t r i n g [ ] a r g s ) {
System . o u t . p r i n t l n ( s q u a r e ( 2 ) ) ;
}
main
main
square(2)
CoMa-Übung IV (TU Berlin)
square(2)
Methoden und Wrapperklassen
07.11.2012
19 / 31
Verschachtelte Methodenaufrufe
1
2
3
6
7
public static int multiply ( int a , int b) {
r e t u r n a ∗b ;
}
1
2
3
10
11
Methoden und Wrapperklassen
07.11.2012
19 / 31
07.11.2012
19 / 31
public static int multiply ( int a , int b) {
r e t u r n a ∗b ;
}
4
p u b l i c s t a t i c i n t square ( i n t a )
return multiply (a , a) ;
}
{
5
6
7
8
9
CoMa-Übung IV (TU Berlin)
Verschachtelte Methodenaufrufe
4
5
{
p u b l i c s t a t i c i n t square ( i n t a )
return multiply (a , a) ;
}
{
8
p u b l i c s t a t i c v o i d main ( S t r i n g [ ] a r g s ) {
System . o u t . p r i n t l n ( s q u a r e ( 2 ) ) ;
}
9
10
11
p u b l i c s t a t i c v o i d main ( S t r i n g [ ] a r g s ) {
System . o u t . p r i n t l n ( s q u a r e ( 2 ) ) ;
}
main
main
square(2)
square(2)
multiply(2,2)
CoMa-Übung IV (TU Berlin)
Methoden und Wrapperklassen
multiply(2,2)
07.11.2012
19 / 31
CoMa-Übung IV (TU Berlin)
Methoden und Wrapperklassen
Verschachtelte Methodenaufrufe
1
2
3
Verschachtelte Methodenaufrufe
public static int multiply ( int a , int b) {
r e t u r n a ∗b ;
}
1
2
3
4
5
6
7
4
p u b l i c s t a t i c i n t square ( i n t a )
return multiply (a , a) ;
}
{
5
6
7
8
9
10
11
public static int multiply ( int a , int b) {
r e t u r n a ∗b ;
}
p u b l i c s t a t i c i n t square ( i n t a )
return multiply (a , a) ;
}
{
8
p u b l i c s t a t i c v o i d main ( S t r i n g [ ] a r g s ) {
System . o u t . p r i n t l n ( s q u a r e ( 2 ) ) ;
}
9
10
11
p u b l i c s t a t i c v o i d main ( S t r i n g [ ] a r g s ) {
System . o u t . p r i n t l n ( s q u a r e ( 2 ) ) ;
}
main
main
square(2)
square(2)
multiply(2,2)
4
CoMa-Übung IV (TU Berlin)
Methoden und Wrapperklassen
07.11.2012
19 / 31
Verschachtelte Methodenaufrufe
1
2
3
6
7
public static int multiply ( int a , int b) {
r e t u r n a ∗b ;
}
1
2
3
10
11
07.11.2012
19 / 31
07.11.2012
19 / 31
public static int multiply ( int a , int b) {
r e t u r n a ∗b ;
}
4
p u b l i c s t a t i c i n t square ( i n t a )
return multiply (a , a) ;
}
{
5
6
7
8
9
Methoden und Wrapperklassen
Verschachtelte Methodenaufrufe
4
5
CoMa-Übung IV (TU Berlin)
p u b l i c s t a t i c i n t square ( i n t a )
return multiply (a , a) ;
}
{
8
p u b l i c s t a t i c v o i d main ( S t r i n g [ ] a r g s ) {
System . o u t . p r i n t l n ( s q u a r e ( 2 ) ) ;
}
9
10
11
p u b l i c s t a t i c v o i d main ( S t r i n g [ ] a r g s ) {
System . o u t . p r i n t l n ( s q u a r e ( 2 ) ) ;
}
main
main
square(2)
4
CoMa-Übung IV (TU Berlin)
Methoden und Wrapperklassen
07.11.2012
19 / 31
CoMa-Übung IV (TU Berlin)
Methoden und Wrapperklassen
Der Methoden-Stack
Der Methoden-Stack
Stack
Stack
main
main
square(2)
square(2)
multiply(2,2)
multiply(2,2)
Java merkt sich verschachtelte Methoden-Aufrufe, indem es diese
Aufrufe auf ein Stack (Stapel) legt
Java merkt sich verschachtelte Methoden-Aufrufe, indem es diese
Aufrufe auf ein Stack (Stapel) legt
multiply(2,2)
square(2)
main
CoMa-Übung IV (TU Berlin)
Methoden und Wrapperklassen
07.11.2012
20 / 31
CoMa-Übung IV (TU Berlin)
Der Stacktrace
Der Stacktrace
Der Stacktrace
Der Stacktrace
Methoden und Wrapperklassen
07.11.2012
Tritt ein Fehler auf, gibt Java euch den Stacktrace aus.
Tritt ein Fehler auf, gibt Java euch den Stacktrace aus.
→ ist im Wesentlichen der Inhalt des Methodenstacks, zu dem
Zeitpunkt, als der Fehler aufgetreten ist.
→ ist im Wesentlichen der Inhalt des Methodenstacks, zu dem
Zeitpunkt, als der Fehler aufgetreten ist.
Die zuletzt aufgerufene Methode steht dabei oben.
Für die Fehlersuche heißt das:
Die zuletzt aufgerufene Methode steht dabei oben.
Für die Fehlersuche heißt das:
I
I
Geht den Stacktrace von oben nach unten durch, bis ihr in der ersten
Klasse ankommt, die von euch geschrieben ist.
Schaut euch die Zeile an, in der Fehler verursacht wird und behebt die
Ursache.
I
I
1
2
3
4
5
CoMa-Übung IV (TU Berlin)
Methoden und Wrapperklassen
07.11.2012
21 / 31
20 / 31
Geht den Stacktrace von oben nach unten durch, bis ihr in der ersten
Klasse ankommt, die von euch geschrieben ist.
Schaut euch die Zeile an, in der Fehler verursacht wird und behebt die
Ursache.
public class Error {
p u b l i c s t a t i c v o i d main ( S t r i n g [ ] a r g s ) {
System . o u t . p r i n t l n ( ” H e l l o ” . c h a r A t ( −1) ) ;
}
}
CoMa-Übung IV (TU Berlin)
Methoden und Wrapperklassen
07.11.2012
21 / 31
Der Stacktrace
Einige Fallstricke
Der Stacktrace
Nicht-statische Methoden aus statischen Aufrufen
→ ist im Wesentlichen der Inhalt des Methodenstacks, zu dem
Zeitpunkt, als der Fehler aufgetreten ist.
1
2
3
Die zuletzt aufgerufene Methode steht dabei oben.
p u b l i c i n t square ( i n t a ) {
return multiply (a , a) ;
}
4
5
1
2
3
4
5
public class Error {
p u b l i c s t a t i c v o i d main ( S t r i n g [ ] a r g s ) {
System . o u t . p r i n t l n ( ” H e l l o ” . c h a r A t ( −1) ) ;
}
}
6
7
p u b l i c s t a t i c v o i d main ( S t r i n g [ ] a r g s ) {
System . o u t . p r i n t l n ( s q u a r e ( 2 ) ) ;
}
Objektmethode ohne Objekt aus Klassenmethode aufgerufen → Fehler!
Nicht erreichbarer Code
1
2
3
4
p u b l i c s t a t i c v o i d main ( S t r i n g [ ] a r g s ) {
return ;
int a = 1;
}
Zeile 3 ist nie erreichbar → Fehler!
CoMa-Übung IV (TU Berlin)
Methoden und Wrapperklassen
07.11.2012
22 / 31
CoMa-Übung IV (TU Berlin)
Einige Fallstricke (2)
Überladene Methoden
Fehlendes Return
Überladene Methoden
1
2
3
4
5
6
7
Es gibt z.B. eine Menge System.out.println()-Methoden für
verschiedene Datentypen
Kann benutzt werden, um Standardwerte für Parameter festzulegen:
1
2
3
p u b l i c s t a t i c l o n g r o u n d ( do u bl e d )
5
p u b l i c v o i d r o u n d ( d o ubl e d )
6
Signatur nicht eindeutig (Modifizierer und Rückgabetyp zählen nicht)
Methoden und Wrapperklassen
p u b l i c s t a t i c dou ble r o u n d ( doubl e d , i n t p r e c i s i o n ) {
...
}
4
2
CoMa-Übung IV (TU Berlin)
23 / 31
Für Java okay, solange der Kompiler die Methoden anhand der
Parameterliste unterscheiden kann.
Gleiche Signatur
3
07.11.2012
Methoden mit gleichem Namen werden überladene Methoden
genannt.
p u b l i c i n t doSomething ( i n t a ) {
i f ( a > 0) {
return 0;
} e l s e i f ( a <= 0 ) {
return 0;
}
}
Fehler wegen nicht sichergestelltem return
1
Methoden und Wrapperklassen
07.11.2012
24 / 31
7
p u b l i c s t a t i c dou ble r o u n d ( doubl e d ) {
return round ( d , 2) ;
}
CoMa-Übung IV (TU Berlin)
Methoden und Wrapperklassen
07.11.2012
25 / 31
Die API
Die API
Dokumentiert alle Klassen des JDKs und ihre Methoden
Beispiel: Math.round
http://docs.oracle.com/javase/7/docs/api/
http://docs.oracle.com/javase/7/docs/api/java/lang/
Math.html#round(double)
Nicht importierte Klassen finden sich unter java.lang
API beschreibt Methoden-Signatur mit Modifizierern
Eingabe & Ausgabe der Methode und Sonderfälle
CoMa-Übung IV (TU Berlin)
Methoden und Wrapperklassen
07.11.2012
26 / 31
CoMa-Übung IV (TU Berlin)
Methoden und Wrapperklassen
Wrapperklassen
Wrapperklassen (2)
Java bietet für jeden primitiven Datentyp eine zugehörige Wrapperklasse
an. Diese Wrapperklassen erlauben es
ihre primitive Datentypen als String zu formatieren,
einen String in ihren primitiven Datentypen zu parsen,
primitive Datentypen als Referenzen zu betrachten (später wichtig).
Erzeugen von Wrapper-Objekten
Primitiver Datentyp
byte
short
int
long
float
double
char
Wrapperklasse
Byte
Short
Integer
Long
Float
Double
Character
boolean
Boolean
CoMa-Übung IV (TU Berlin)
Methoden und Wrapperklassen
07.11.2012
27 / 31
Mittels new → erzeugt immer ein neues Objekt.
1
I n t e g e r i = new I n t e g e r ( 1 ) ;
Mittels Wrapperklasse.valueOf → erzeugt ein neues Objekt per
new
1
Int ege r j = I nteger . valueOf (1) ;
Ausnahme: bei Byte, Short, Integer, Long und Werten
zwischen -128 und 127 wird auf Objekte aus einem Cache
zurückgegriffen
Durch implizite Umwandlung aus einem primitiven Typ → benutzt
Wrapperklasse.valueOf
1
07.11.2012
28 / 31
Integer j = 10;
CoMa-Übung IV (TU Berlin)
Methoden und Wrapperklassen
07.11.2012
29 / 31
Umwandlung von primitiven Typen und Wrapperklassen
Fallstricke von Wrapperklassen
Boxing und Unboxing
Fallstricke, Teil I
Java wandelt automatisch zwischen primitiven Typen und
Wrapperklassen um (Autoboxing).
1
2
3
Die Umwandlung von primitiven Typen in ein Wrapperklasse nennt
man (Boxing).
1
4
5
In Zeile 3 & 4 wird Unboxing benutzt, in Zeile 5 nicht.
Integer j = 10;
Die Umwandlung von einer Wrapperklasse in einen primitiven Typen
nennt man (Unboxing).
Fallstricke, Teil II
1
1
i n t k = new I n t e g e r ( 1 0 ) ;
2
3
4
5
Hinweis
6
Der Wert eines Wrapper-Objekts ändert sich sein Leben lang nicht.
CoMa-Übung IV (TU Berlin)
I n t e g e r i = new I n t e g e r ( 1 ) ;
I n t e g e r j = new I n t e g e r ( 1 ) ;
System . o u t . p r i n t l n ( i >= j ) ; // t r u e
System . o u t . p r i n t l n ( i <= j ) ; // t r u e
System . o u t . p r i n t l n ( i == j ) ; // f a l s e
Methoden und Wrapperklassen
07.11.2012
I n t e g e r i = new I n t e g e r ( 1 0 ) ;
I n t e g e r j = I n t e g e r . valueOf (10) ;
Integer k = 10;
System . o u t . p r i n t l n ( i == j ) ;
// f a l s e
System . o u t . p r i n t l n ( j == k ) ;
// t r u e
System . o u t . p r i n t l n ( i == k ) ;
// f a l s e
i wird explizit neu erzeugt, j,k nicht (da der Wert in -128..127 liegt)
30 / 31
CoMa-Übung IV (TU Berlin)
Methoden und Wrapperklassen
07.11.2012
31 / 31