Trainingsbuch
Prfungsvorbereitung fr den
Sun Certified Java Programmer (SCJP):
Java 2 Platform 1.4 und Platform 5.0
Inhaltsverzeichnis
1
Einleitung ...............................................................................................................
1.1
ber dieses Buch ......................................................................................
1.2
Wie arbeite ich mit Java und NetBeans? ..................................................
11
11
13
21
21
24
29
34
37
50
Operatoren ..............................................................................................................
4.1
Arithmetische Operatoren .........................................................................
4.2
Die Boolean logischen Operatoren ...........................................................
4.3
Die Operatoren Inkrement ++ und Dekrement -- .....................................
4.4
Relationale Operatoren .............................................................................
4.5
Integer Bitweise Operatoren .....................................................................
4.6
Der Shift-Operator (Verschiebeoperator) .................................................
Arrays
6.1
6.2
6.3
.....................................................................................................................
Eindimensionale Arrays ............................................................................
Mehrdimensionale Arrays .........................................................................
bungen und Lsungen ............................................................................
241
241
243
246
255
255
255
277
300
135
135
148
161
169
169
188
Inhaltsverzeichnis
7.5
7.6
7.7
Exceptions ...............................................................................................................
8.1
Begriffserluterung ....................................................................................
8.2
Checked und Unchecked Exceptions ........................................................
8.3
Exception Handling ...................................................................................
8.4
Der throw-Ausdruck ..................................................................................
8.5
Die throws-Klausel ....................................................................................
8.6
bungen und Lsungen ............................................................................
353
353
353
358
361
363
365
Assertions ................................................................................................................
9.1
Begriffserluterung ....................................................................................
9.2
Kompilieren von Klassen mit Assertions ..................................................
9.3
Ein- und Ausschalten von Assertions fr Nicht-Systemdateien ...............
9.4
Ein- und Ausschalten von Assertions fr Systemdateien. .........................
9.5
Regeln fr die Verwendung von Assertions .............................................
9.6
bungen und Lsungen ............................................................................
383
383
386
386
387
387
389
10
Threads ....................................................................................................................
10.1
Begriffserluterung ....................................................................................
10.2
Erstellung eines Threads ...........................................................................
10.3
Der Main-Thread und die Daemon-Threads .............................................
10.4
Synchronisation .........................................................................................
10.5
Thread-Stadien und dazugehrige Methoden ...........................................
10.6
bungen und Lsungen ............................................................................
405
405
405
409
410
414
420
11
433
433
433
440
441
442
12
453
453
455
460
462
462
467
486
Inhaltsverzeichnis
13
493
493
517
530
14
545
545
549
571
576
606
623
637
662
15
Vakatseite
Vorwort
Zu Beginn der 90er-Jahre begann man bei Sun Microsystems unter Leitung
von James Gosling eine neue Programmiersprache zu entwickeln, die am
Anfang den Namen Oak (Eiche) trug. 1995 wurde sie, aufgrund namensrechtlicher Probleme, in Java umbenannt und am 23. Mai 1995 auf der SunWorld in San Francisco vorgestellt. Einem Siegeszug von Java stand nichts
mehr im Wege. Java wurde nach dem amerikanischen Slangbegriff fr Kaffee und dem T-Shirt-Aufdruck Its a jungle out there, so drink your Java benannt. Java ist eine objektorientierte Programmiersprache, die heute fr viele
Internetanwendungen und fr Handy-Software verwendet wird.
Die Bedeutung von Java hat ber die Jahre immer mehr zugenommen, so
wird es fr Programmierer immer wichtiger, Java zu beherrschen. Es stellt
sich die Frage: Wie knnen Sie sich das entsprechende Wissen aneignen
oder sogar Ihr Wissen erweitern und unter Beweis stellen? Ein Weg dorthin
wre: Machen Sie die Prfung fr den Sun Certified Java Programmer
(SCJP)! Die bestandene Zertifizierung knnte ein Meilenstein in Ihrer beruflichen Karriere sein. In diesem Buch knnen Sie anhand von Fragen gezielt
Java-Programmiergrundlagen erwerben und die Prfung anschlieend problemlos bestehen. Dieses Buch soll es neben Programmierprofis auch Anfngern ermglichen, sich Kenntnisse anzueignen. So sind die Beispiele einfach gehalten, und Kompliziertes und Komplexes wird leicht verstndlich
erklrt.
Vakatseite
Danksagung
Mein besonderer Dank gilt Andreas Buchman, der mich mit seiner Kritik, seinen
Anregungen und seinen Ideen begleitet hat. Und vielen Dank auch an Stephan
Riedel, Claudia Mller und Michael Niedermair fr ihre tatkrftige Untersttzung.
11
Einleitung
12
1 Einleitung
menhang noch Fragen, rekapitulieren Sie den noch nicht verstandenen Stoff.
Von Zeit zu Zeit sollten Sie einige Seiten zurckblttern und das eine oder
andere Thema wiederholen, da doch beim ersten Mal nicht jedes Detail vollkommen beherrscht wird. Beherrschen Sie alle Details, knnen Sie sich an
die Abschlussprfungen am Ende des Buches machen. Viel Glck!
13
Dann gibt es noch eine Lernsoftware in englischer Sprache, die man im Internet bei Whizlab bestellen kann (www.whizlab.com), die die Prfungssituation simuliert. Die Fragen mit kommentierten Lsungen sind ein optimales
Training, und man kann sich auf Prfungsfragen mit hnlichem Schwierigkeitsgrad einstellen.
Zum Schluss mchte ich Ihnen noch ein Forum in englischer Sprache vorstellen, das mehrere Rubriken zum Thema Java-Zertifizierung besitzt:
www.javaranch.com.
14
1 Einleitung
(JDK), das auch den Namen Java 2 Software Development Kit trgt (J2SDK).
Das Java Development Kit (JDK) enthlt nicht nur einen Compiler, sondern
auch das Java Runtime Environment (JRE).
b) NetBeans
NetBeans ist eine Entwicklungsumgebung, die eine groe Verbreitung findet
und eine Hilfe beim Programmieren darstellt. NetBeans untersttzt Sie, indem es Tipp- und Syntaxfehler Ihnen anzeigt, Programmiervorschlge macht
und somit Ihnen das Programmieren erleichtert.
3. Schritt
Sie mssen Ihrem Windows-System zeigen, wo sich dieses neu installierte
Programm und alle dazugehrigen wichtigen Teil-Programme befinden. Diesen Schritt bernimmt gewhnlicherweise bei anderen Programmen der Installationsvorgang, nicht so bei dem SDK von Java. Sie mssen selbst Vernderungen bei der PATH-Variablen und der Umgebungsvariablen
vornehmen. Je nach Betriebssystem funktioniert dies anders. An dieser
15
Unter Windows Me
Hier funktioniert das Ganze komfortabler, aber leider ganz anders als unter
Windows XP. Gehen Sie zu Start, und whlen Sie Start/Programme/Zubehr/Systemprogramme/Systeminformationen. Wenn Sie dort angelangt sind,
whlen Sie im Menpunkt unter Extras den Punkt Systemkonfigurationsprogramm und die Registerkarte Umgebung aus. Klicken Sie auf den Button
Neu und erstellen die Umgebungsvariable wie folgt:
Die PATH-Variable mssen Sie verndern, indem Sie diese markieren und
auf die Schaltflche Bearbeiten klicken. Anschlieend fgen Sie an den
Schluss ein Semikolon und den Eintrag c:\j2sdk1.4.2_05\bin ein:
16
c)
1 Einleitung
Unter Windows NT und Windows 2000 wird wie folgt vorgegangen: Start/Einstellungen/Systemsteuerung/System. Und unter XP geringfgig anders:
Start/Systemsteuerung/System. Es wird die Umgebungsvariable neu anlegt
und der PATH ergnzt. Unter Windows NT mssen Sie die Umgebungsregisterkarte, unter Windows 2000 die Registerkarte Erweiterte Einstellungen und
unter XP die Registerkarte Erweitert auswhlen. Anschlieend wird die
Schaltflche Umgebungsvariable angeklickt, und die Benutzervariable durch
klicken auf die Schaltflche Neu wie folgt erstellt:
Die PATH-Variable verndern Sie, indem Sie sie markieren und auf den Button Bearbeiten klicken. An den Schluss wird ein Semikolon und der Eintrag
c:\j2sdk1.4.2_ 05\bin angefgt. Die PATH-Variable befindet sich unter den
Systemvariablen.
17
Sie knnen auch nachtrglich die Java-Version ndern, indem Sie folgende
zwei Schritte durchfhren:
Schritt 1: Sie mssen die entsprechenden Bibliotheken im Men Tools
Java Platform Manager importieren. Unter Add Platform fgen Sie die JavaVersion 1.4 hinzu und erhalten folgendes Ergebnis:
Schritt 2: Klicken Sie mit der rechten Maustaste auf das entsprechende Projekt und whlen Sie den Menpunkt Properties aus. So gelangen Sie zu un-
18
1 Einleitung
Zustzlich mssen Sie noch die Bibliotheken, auf die zugegriffen wird, unter
Categories/Libraries wechseln:
19
20
1 Einleitung
21
Wie wird nun unser erstes Programm umgesetzt? Zuerst mssen Sie das
hierfr bentigte Programm ffnen: NetBeans (vgl. Kapitel 1.2 Wie arbeite
ich mit Java und NetBeans?). Was ist als nchstes notwendig? Bevor Sie
ein Programm erstellen knnen, brauchen Sie ein sogenanntes Projekt, das
vergleichbar ist mit einem Ordner in Windows. In einem Projekt werden mehrere Programme zusammengefasst. Ein Projekt erstellen Sie, indem Sie im
Men File New Project anklicken und unter Categories/General die Mglichkeit Java Application auswhlen und auf Next gehen (siehe folgende Abbildung).
22
Im nchsten Schritt vergeben Sie den Namen SCJP fr Ihr Projekt und erstellen einen Ordner, den wir Training nennen wollen.
Nun brauchen wir noch ein Package, das einem Unterordner entspricht. Klicken Sie mit der rechten Maustaste auf den Ordner Source Packages, whlen Sie New Java Package aus und vergeben den Namen Eins.
23
Jetzt kommen wir zu unserer ersten Klasse (File New Java Class), die
Sie bitte JavaApplications nennen, und geben oben stehende Programmzeilen ein (die berflssigen Zeilen bitte lschen).
24
Zum Schluss wird das bereits kompilierte, d. h. bersetzte Programm gestartet. Starten knnen Sie das Programm, indem Sie mit der rechten Maustaste
auf Ihre Klasse klicken und anschlieend Run File auswhlen. In unten stehender Abbildung sehen Sie das Ergebnis unseres Programms: Es wird der
Satz Hello World auf der Konsole ausgegeben.
Wollen Sie im Folgenden auf bereits erstellte Java-Klassen zugreifen, kopieren Sie den Inhalt des Ordners Beispiele, der sich auf der CD befindet, in den
Ordner C:\Training\SCJP\src.
2.2
25
In den Antworten der Prfung wird nicht davon ausgegangen, dass Sie mit
dem komfortablen Hilfsmittel NetBeans arbeiten, sondern nur mit dem
Java-Kompiler, somit wird in den Lsungen davon gesprochen, dass der Versuch, das Programm auf der Kommandozeile zu starten, fehlschlgt.
Hier einige Beispiele, welche Variationsmglichkeiten der main( )-Methode
erlaubt sind und welche nicht.
Die main( )-Methode kann nur wie folgt variiert werden:
public static void main(String[ ] args) {}
public static void main(String [ ] args) {}
26
a) Kompilierfehler in Zeile 1.
b) Kompilierfehler in Zeile 2.
c) Kompilierfehler in Zeile 3.
d) Der Versuch, das Programm auf der Kommandozeile zu starten, wird bei
Zeile 1 fehlschlagen.
e) Der Versuch, das Programm auf der Kommandozeile zu starten, wird bei
Zeile 2 fehlschlagen.
f) Der Versuch, das Programm auf der Kommandozeile zu starten, wird bei
Zeile 3 fehlschlagen.
g) Keine dieser Mglichkeiten.
(2) Frage
Zeile 1
Zeile 2
Zeile 3
2.2
27
a) Kompilierfehler in Zeile 1.
b) Kompilierfehler in Zeile 2.
c) Kompilierfehler in Zeile 3.
d) Der Versuch, das Programm auf der Kommandozeile zu starten, wird bei
Zeile 1 fehlschlagen.
e) Der Versuch, das Programm auf der Kommandozeile zu starten, wird bei
Zeile 2 fehlschlagen.
f) Der Versuch, das Programm auf der Kommandozeile zu starten, wird bei
Zeile 3 fehlschlagen.
g) Keine dieser Mglichkeiten.
(3) Frage
a) Kompilierfehler in Zeile 1.
b) Kompilierfehler in Zeile 2.
c) Kompilierfehler in Zeile 3.
d) Der Versuch, das Programm auf der Kommandozeile zu starten, wird bei
Zeile 1 fehlschlagen.
e) Der Versuch, das Programm auf der Kommandozeile zu starten, wird bei
Zeile 2 fehlschlagen.
f) Der Versuch, das Programm auf der Kommandozeile zu starten, wird bei
Zeile 3 fehlschlagen.
g) Keine dieser Mglichkeiten.
(4) Frage
a) Kompilierfehler in Zeile 1.
b) Kompilierfehler in Zeile 2.
28
c) Kompilierfehler in Zeile 3.
d) Der Versuch, das Programm auf der Kommandozeile zu starten, wird bei
Zeile 1 fehlschlagen.
e) Der Versuch, das Programm auf der Kommandozeile zu starten, wird bei
Zeile 2 fehlschlagen.
f) Der Versuch, das Programm auf der Kommandozeile zu starten, wird bei
Zeile 3 fehlschlagen.
g) Keine dieser Mglichkeiten.
(5) Frage
a) Kompilierfehler in Zeile 1.
b) Kompilierfehler in Zeile 2.
c) Kompilierfehler in Zeile 3.
d) Der Versuch, das Programm auf der Kommandozeile zu starten, wird bei
Zeile 1 fehlschlagen.
e) Der Versuch, das Programm auf der Kommandozeile zu starten, wird bei
Zeile 2 fehlschlagen.
f) Der Versuch, das Programm auf der Kommandozeile zu starten, wird bei
Zeile 3 fehlschlagen.
g) Keine dieser Mglichkeiten.
Lsungen
(1) Frage
2.3
29
(4) Frage
(5) Frage
a) Beispiele
Beispiele fr erlaubte Bezeichner:
baum_stumpf
$bild
haus1
baum$_12
Beispiele fr nicht erlaubte Bezeichner:
1baum
30
mller@t-online.de
baum-stumpf
34haus
%baum
computer#bild
In welcher der unten stehenden Zeilen befindet sich ein nicht erlaubter Bezeichner?
public class Bezeichner{
String a5;
String 5a;
String buch;
String text;
String @reminder;
String honigmund1;
String text-art;
String &computer;
}
a) Zeile 1
b) Zeile 2
c) Zeile 3
d) Zeile 4
e) Zeile 5
f) Zeile 6
g) Zeile 7
h) Zeile 8
Zeile 1
Zeile 2
Zeile 3
Zeile 4
Zeile 5
Zeile 6
Zeile 7
Zeile 8
2.3
31
(2) Frage
In welcher der unten stehenden Zeilen befindet sich ein nicht erlaubter Bezeichner?
public class Bezeichner{
String auto;
String honig;
String question1;
String _text;
String 2question;
String question_1;
String text_art;
String question-2;
}
Zeile 1
Zeile 2
Zeile 3
Zeile 4
Zeile 5
Zeile 6
Zeile 7
Zeile 8
a) Zeile 1
b) Zeile 2
c) Zeile 3
d) Zeile 4
e) Zeile 5
f) Zeile 6
g) Zeile 7
h) Zeile 8
(3) Frage
In welcher der unten stehenden Zeilen befindet sich ein nicht erlaubter Bezeichner?
public class Bezeichner{
String gren;
String number;
String first_number;
String first-number;
String number%;
String number1;
String 1number;
String number-1;
}
a) Zeile 1
b) Zeile 2
Zeile 1
Zeile 2
Zeile 3
Zeile 4
Zeile 5
Zeile 6
Zeile 7
Zeile 8
32
c) Zeile 3
d) Zeile 4
e) Zeile 5
f) Zeile 6
g) Zeile 7
h) Zeile 8
(4) Frage
In welcher der unten stehenden Zeilen befindet sich ein nicht erlaubter Bezeichner?
public class Bezeichner{
String plan5;
String 5plan;
String $plan;
String plan;
String mrz;
String total+;
String total;
String total_plan;
}
Zeile 1
Zeile 2
Zeile 3
Zeile 4
Zeile 5
Zeile 6
Zeile 7
Zeile 8
a) Zeile 1
b) Zeile 2
c) Zeile 3
d) Zeile 4
e) Zeile 5
f) Zeile 6
g) Zeile 7
h) Zeile 8
(5) Frage
In welcher der unten stehenden Zeilen befindet sich ein nicht erlaubter Bezeichner?
public class Bezeichner{
String hallo;
String a2c;
Zeile 1
Zeile 2
2.3
String hot;
String hot57;
String version-4;
String version1;
String version_9;
String _version;
33
Zeile 3
Zeile 4
Zeile 5
Zeile 6
Zeile 7
Zeile 8
a) Zeile 1
b) Zeile 2
c) Zeile 3
d) Zeile 4
e) Zeile 5
f) Zeile 6
g) Zeile 7
h) Zeile 8
Lsungen
(1) Frage
b, e, Die Lsung b ist falsch, da am Anfang eines Bezeichners keine Zahl stehen darf.
g, h Ein Bezeichner darf kein Sonderzeichen enthalten, deswegen sind e und h
falsch. Die Lsung g ist falsch, da Bindestriche in Bezeichnern verboten sind.
(2) Frage
34
(3) Frage
Die Auswahl e fhrt zu einem Kompilierfehler, da ein Bindestrich in Bezeichnern nicht erlaubt ist.
2.4 Schlsselwrter
2.4.1 Begriffserluterung
Folgende Schlsselwrter drfen nicht als Namen / Bezeichner verwendet
werden, da sie bereits eine vordefinierte Bedeutung in Java haben! So ist es
nicht erlaubt, Ihr Programm break oder Boolean zu nennen. Diese Wrter
sind case-sensitive, d. h. es wird zwischen Gro- und Kleinbuchstaben unterschieden. So sind die Begriffe break (kleiner Anfangsbuchstabe) und
Break (groer Anfangsbuchstabe) nicht identisch. Das Wort break, das ein
Schlsselwort ist, darf nicht als Bezeichner benutzt werden, aber Break. Also
immer auf Gro- und Kleinschreibung achten, da alle Schlsselwrter nur
Kleinbuchstaben enthalten!
Liste der Schlsselwrter
assert
char
double
for
int
private
strictfp
throws
boolean
class
else
goto
interface
protected
super
transient
break
const
extends
if
long
public
switch
try
byte
continue
final
implements
native
return
synchronized
void
case
default
finally
import
new
short
this
volatile
abstract
catch
do
float
instanceof
package
static
throw
while
2.4 Schlsselwrter
35
36
(3) Frage
2.5
37
f) new
g) old
h) Keine dieser Mglichkeiten.
Lsungen
(1) Frage
a, e, Die Begriffe better, Instanceof, cast und value gehren nicht zu den Schlsself
wrtern. Der Unterschied zwischen instanceof und Instanceof liegt im groen
Anfangsbuchstaben und Schlsselwrter enthalten nur Kleinbuchstaben.
(2) Frage
(3) Frage
38
Aber, so denken Sie, 1.267 ist doch viel kleiner als 127! Kein Zweifel, Sie haben Recht. In Java jedoch sieht der Datentyp byte keinen Platz fr eine Zahl
mit Nachkommastellen vor, somit ist die Zahl 1.267 viel zu gro. Bitte beachten Sie generell, dass Fliekommazahlen im amerikanischen Zahlenformat
eingegeben werden mssen, mit Punkt statt Komma als Trennzeichen.
Hier eine Zusammenstellung der wichtigsten Datentypen:
Datentypen
boolean
char
16
false
byte
(0x0000...0xffff)
'\u0000'
short
16
-32768...32767
int
32
-2147483648...2147483647 0
long
64
-9223372036854775808...
9223372036854775807
float
32
1.40239846E-45f
0 ... 65535
0L
0.0F
3.40282347E+38f
double
64
4.94065645841246544E-324
0.0D
1.79769131486231570E+308
2.5
39
2.5.3 Literale
Der Wert, der der Variablen whrend der Initialisierung zugewiesen wird, ist
ein so genannter Literal. In unserem Beispiel byte menge = 30 ist byte der
Datentyp, menge der Name der Variablen und 30 ist der dazugehrige Wert,
also der byte-Literal.
a) Char-Literale
Der primitive Datentyp char darf nur ein Zeichen enthalten, das eine positive
Ziffer, ein Buchstabe und ein Sonderzeichen sein kann. Char darf ein Unicode-Zeichen zum Inhalt haben, wobei z. B. \u0031 die Zahl 1 bedeutet. Der
Unicode ist ein international gltiger Code, der es mglich macht, dass zustzlich zu unseren Buchstaben (A - Z) auch arabische und chinesische Zeichen ausgegeben werden knnen. Char-Literale werden mit einfachen Anfhrungszeichen dargestellt, Ziffern ohne. Fehlen die einfachen
Anfhrungszeichen, oder beinhaltet char eine negative Zahl, kommt es zu einem Kompilierfehler. Char kann als Hexadezimalzahl und Oktalzahl ohne
Anfhrungszeichen dargestellt werden: char a = 0xffff; oder char a = 062;.
Vergleichen Sie hierzu Kapitel 4.5.1 Exkurs: Zahlensysteme ab Seite 169.
Mit char-Literalen besteht die Mglichkeit, einen Teil der Unicode-Zeichen
darzustellen, und zwar 65.536 Zeichen. So gibt z. B. das Unicode-Zeichen
u\0041 den Grobuchstaben A wieder. In unten stehender Abbildung wird
gezeigt, dass eine Zahl ohne Hochkommata zu der Ausgabe des Zeichens
an dieser Position fhrt und nicht zu einer Ausgabe dieser Zahl. Jede Zahl
entspricht einem Unicode-Zeichen. Es gibt also mehrere Mglichkeiten, zustzlich zu char = 'A'; den Grobuchstaben A auf der Konsole auszugeben.
public class Zeichen {
public static void main(String[ ] args) {
char a = 65;
char b =A;
char c = \u0041;
40
b) Integer-Literale
Die Ganzzahlen int, long, byte und short werden unter dem Oberbegriff Integer-Literale zusammengefasst. Sie knnen sowohl als Hexadezimalzahl als
auch als Oktalzahl dargestellt werden, und Zahlen stehen nie in Hochkommata. Integer-Literale sind automatisch immer vom Datentyp int. Sollen sie
long sein, muss ein L dahinter stehen (long = 10L). Die primitiven Datentypen
short oder byte knnen nicht speziell gekennzeichnet werden, da hier intern
ein Cast von int nach byte oder short stattfindet (vgl. Kapitel 2.6.2 Implizite
und explizite Typanpassung ab Seite 51).
2.5
41
c) Fliekommazahlen
Alle Kommazahlen werden unter dem Oberbegriff Fliekommazahlen zusammengefasst, wobei zwischen double und float unterschieden wird. Als
Trennzeichen steht ein Punkt, kein Komma, da Java sich der amerikanischen
Schreibweise bedient. Kommazahlen sind grundstzlich vom primitiven Datentyp double: Steht z. B. float a = 0.0; so ist a trotzdem vom primitiven Datentyp double und nicht float. Wollen Sie einen Wert von Typ float haben,
muss f explizit dastehen: float a = 0.0f;.
d) Boolean-Literale
Boolean-Literale geben darber Auskunft, ob etwas zutrifft oder nicht, wobei
sie nur zwei Werte, true oder false, annehmen knnen. Mit einem BooleanAusdruck sind Sie in der Lage festzustellen, ob heute Montag ist oder nicht.
Es gibt nur zwei Mglichkeiten Boolean-Literale einer Variablen zuzuweisen,
ohne dass es zu einem Kompilierfehler kommt:
boolean b = true;
boolean b = false;
e) String-Literale
Ein String-Literal besteht aus mehreren Zeichen oder sogar Wrtern, sprich
Text. Mit Text kann man nicht rechnen, so kann man einen String-Literal nicht
mit einem anderen String-Literal multiplizieren. String-Literale werden in
Hochkommata gesetzt, wobei es eine Ausnahme gibt, die nicht in Anfhrungszeichen gesetzt werden muss, und zwar der Defaultwert (String a =
null;).
Beispiele fr die korrekte Anwendung:
String a = null;
42
Zeile 1
Zeile 2
Zeile 3
Zeile 4
Zeile 5
Zeile 6
Zeile 7
Zeile 8
a) Zeile 1
b) Zeile 2
c) Zeile 3
d) Zeile 4
e) Zeile 5
f) Zeile 6
g) Zeile 7
h) Zeile 8
i) Keine dieser Mglichkeiten.
(2) Frage
Zeile 1
Zeile 2
Zeile 3
Zeile 4
2.5
char
char
char
char
e = -3;
f = 0xfffff;
g = 0xffff;
h = e;
Zeile 5
Zeile 6
Zeile 7
Zeile 8
a) Zeile 1
b) Zeile 2
c) Zeile 3
d) Zeile 4
e) Zeile 5
f) Zeile 6
g) Zeile 7
h) Zeile 8
i) Keine dieser Mglichkeiten.
(3) Frage
a) Zeile 1
b) Zeile 2
c) Zeile 3
d) Zeile 4
e) Zeile 5
f) Zeile 6
g) Zeile 7
h) Zeile 8
Zeile 1
Zeile 2
Zeile 3
Zeile 4
Zeile 5
Zeile 6
Zeile 7
Zeile 8
43
44
Zeile 1
Zeile 2
Zeile 3
Zeile 4
Zeile 5
Zeile 6
Zeile 7
Zeile 8
a) Zeile 1
b) Zeile 2
c) Zeile 3
d) Zeile 4
e) Zeile 5
f) Zeile 6
g) Zeile 7
h) Zeile 8
i) Keine dieser Mglichkeiten.
(5) Frage
a) Zeile 1
b) Zeile 2
c) Zeile 3
Zeile 1
Zeile 2
Zeile 3
Zeile 4
Zeile 5
Zeile 6
Zeile 7
Zeile 8
2.5
d) Zeile 4
e) Zeile 5
f) Zeile 6
g) Zeile 7
h) Zeile 8
i) Keine dieser Mglichkeiten.
(6) Frage
Zeile 1
Zeile 2
Zeile 3
Zeile 4
Zeile 5
Zeile 6
Zeile 7
Zeile 8
a) Zeile 1
b) Zeile 2
c) Zeile 3
d) Zeile 4
e) Zeile 5
f) Zeile 6
g) Zeile 7
h) Zeile 8
i) Keine dieser Mglichkeiten.
(7) Frage
Zeile 1
Zeile 2
Zeile 3
Zeile 4
45
46
e = true;
f = 127;
g = false;
h = 0;
a) Zeile 1
b) Zeile 2
c) Zeile 3
d) Zeile 4
e) Zeile 5
f) Zeile 6
g) Zeile 7
h) Zeile 8
i) Keine dieser Mglichkeiten.
(8) Frage
Zeile 5
Zeile 6
Zeile 7
Zeile 8
2.5
47
Welches ist der grte positive Wert, den der primitive Datentyp byte einnehmen kann, ohne dass es zu einem Kompilierfehler kommt?
a) 562
b) 32767
c) 2147483647
d) 128
e) 127
f) -128
g) Keine dieser Mglichkeiten.
48
(12) Frage
Welches ist der grte positive Wert, den der primitive Datentyp int einnehmen kann, ohne dass es zu einem Kompilierfehler kommt?
a) 32768
b) 32767
c) 2147483648
d) 128
e) 127
f) 129
g) Keine dieser Mglichkeiten.
(13) Frage
Welches ist der grte positive Wert, den der primitive Datentyp short einnehmen kann, ohne dass es zu einem Kompilierfehler kommt?
a) 32768
b) 32767
c) 2147483647
d) 2147483648
e) 127
f) 128
g) Keine dieser Mglichkeiten.
Lsungen
(1) Frage
Ein char darf nur einem einzigen Buchstaben oder Zeichen zugewiesen
werden.
2.5
49
(2) Frage
Ein char darf nur einem einzigen Buchstaben oder Zeichen zugewiesen
werden.
Einem char drfen nur positive Zahlen vom Typ int bis 65535 zugewiesen werden.
Einem char darf als maximaler Wert einer Hexadezimalzahl nur 0xffff
(entspricht dem Wert 65535) zugewiesen werden.
(3) Frage
Ein byte kann nur die Werte von -128 bis 127 annehmen.
Ein short hat als minimaler Wert die Zahl -32768 und als maximaler
Wert die Zahl 32767. So fhrt der Wert 32768 zu einem Kompilierfehler.
Der Wert -32769 ist fr einen short ebenfalls nicht im Bereich der mglichen Werte.
(4) Frage
Ein byte umfasst nur die Zahlen von -128 bis 127.
Ein short reicht von -32768 bis 32767 als maximaler Wert.
Einem char drfen nur positive Zahlen vom Typ int bis 65535 zugewiesen werden.
(5) Frage
e, h Ein primitiver Boolean kann nur die Werte true oder false annehmen
und diese beiden Werte drfen nicht in Hochkommata stehen.
(6) Frage
Die Wert true und false eines Boolean-Wertes drfen nicht in Hochkommata stehen.
50
(7) Frage
(8) Frage
Der primitive Datentyp byte hat die Reichweite: -27 bis 27 -1.
(9) Frage
Der primitive Datentyp long hat die Reichweite: -263 bis 263 - 1.
(10) Frage
Der primitive Datentyp int kann Werte von -231 bis 231 - 1 annehmen.
(11) Frage
Der grte Wert, den der primitive Datentyp byte annehmen kann, ist
127.
(12) Frage
(13) Frage
Der grte Wert, den der primitive Datentyp short haben kann, ist
32767.
Durch erneute Zuweisung wird der Wert der Variablen i gendert, er ist nun
10.
i = j;
2.6
51
In der letzten Zeile wird der Variablen i, die bisher den Wert 5 hatte, ein neuer
Wert zugewiesen, nmlich 10.
Habe ich einen 5-Euro-Schein und will mir Zigaretten aus dem Automaten
ziehen, muss ich vorher Geld wechseln gehen. Genauso verhlt es sich,
wenn ich eine Zahl vom Datentyp int habe, aber eine byte-Zahl brauche. Dies
geht nur mit einer expliziten Typanpassung. Ich wandle also eine grere in
eine kleinere Zahl um. In der Fachliteratur wird auch der Ausdruck Cast synonym verwendet. Bei einem Cast kann es passieren, dass die Zahl gekappt
wird, damit sie von der Gre her in das kleinere Format passt, so werden
z. B. die Nachkommastellen abgeschnitten, wenn ein double (Fliekommazahl) in ein long (Ganzzahl) berfhrt wird. Fehlt in diesem Fall das Casting,
kommt es zu einem Kompilierfehler.
public class Typanpassung {
public static void main(String[ ] args) {
byte b = 1;
int i = 1;
b = (byte)i;
}
}
52
Der primitive Datentyp int i wird auf diese Weise in den primitiven Datentyp
byte, der kleiner ist, umgewandelt. Immer wenn ein primitiver Datentyp in einen kleineren Datentyp abgendert werden soll, braucht man eine explizite
Typanpassung, sprich einen Cast.
Folgende Variationen der Typumwandlung sind mglich:
byte short int long float double
char
-------------------------------------------------------------4
implizite Typanpassung
3-----------------------------------------------------------explizite Typanpassung, bentigt Casting
a) Zeile 1
b) Zeile 2
c) Zeile 3
d) Zeile 4
e) Zeile 5
f) Zeile 6
g) Zeile 7
h) Zeile 8
Zeile 1
Zeile 2
Zeile 3
Zeile 4
Zeile 5
Zeile 6
Zeile 7
Zeile 8
2.6
Zeile 1
Zeile 2
Zeile 3
Zeile 4
Zeile 5
Zeile 6
Zeile 7
Zeile 8
a) Zeile 1
b) Zeile 2
c) Zeile 3
d) Zeile 4
e) Zeile 5
f) Zeile 6
g) Zeile 7
h) Zeile 8
i) Keine dieser Mglichkeiten.
(3) Frage
a) Zeile 1
b) Zeile 2
Zeile 1
Zeile 2
Zeile 3
Zeile 4
Zeile 5
Zeile 6
Zeile 7
Zeile 8
53
54
c) Zeile 3
d) Zeile 4
e) Zeile 5
f) Zeile 6
g) Zeile 7
h) Zeile 8
i) Keine dieser Mglichkeiten.
(4) Frage
Zeile 1
Zeile 2
Zeile 3
Zeile 4
Zeile 5
Zeile 6
Zeile 7
Zeile 8
a) Zeile 1
b) Zeile 2
c) Zeile 3
d) Zeile 4
e) Zeile 5
f) Zeile 6
g) Zeile 7
h) Zeile 8
i) Keine dieser Mglichkeiten.
(5) Frage
Zeile 1
Zeile 2
Zeile 3
2.6
long
int
int
long
int
d = 5;
e = a;
f = a;
g = b;
h = b;
a) Zeile 1
b) Zeile 2
c) Zeile 3
d) Zeile 4
e) Zeile 5
f) Zeile 6
g) Zeile 7
h) Zeile 8
i) Keine dieser Mglichkeiten.
Lsungen
(1) Frage
(2) Frage
(3) Frage
(4) Frage
Zeile 4
Zeile 5
Zeile 6
Zeile 7
Zeile 8
55
Vakatseite
g
(5) Frage
57
58
noch der bereits existierende angepasst und verbessert. So muss nicht jeder
das Rad neu erfinden.
3.1
59
b) Methoden
Mit Methoden knnen Aktionen durchgefhrt oder Eigenschaften verndert
werden. Mit den so genannten Getter- und Setter-Methoden knnen wir die
Eigenschaft farbe unseres Autos modifizieren. Nachstehend unsere Klasse,
der Getter- und Setter-Methoden hinzugefgt worden sind, wobei die GetterMethode auch Akzessor genannt wird und die Setter-Methode Mutator. Mit
der Setter-Methode (setFarbe(String farbe)) kann man die Variable farbe verndern und mit der Getter-Methode (getFarbe( )) die Variable farbe abfragen. Die Namen der Methoden entspechen der JavaBean Namenskonvention, die besagt, dass die Setter-Methode sich aus setXxx( ) und die GetterMethode sich aus getXxx( ) zusammensetzt, wobei das x fr den Namen der
Variable steht, die verndert werden soll. Der Name der Variablen wird direkt
an get und set mit einem groen Anfangsbuchstaben angehngt. Das Vorgehen, Variablen mglichst privat zu deklarieren und sie dann anschlieend
mit Getter- und Setter-Methoden zugnglich zu machen, nennt man Kapselung. In unserem Beispiel knnen Sie im Moment noch nicht jede Einzelheit,
wie z. B. void, verstehen, da diese Details erst auf den folgenden Seiten erklrt werden, und es im Moment nur um das Verstehen des Prinzips geht.
public class Auto {
private String farbe;
//Diese Methode zeigt Ihnen die Farbe an.
public String getFarbe() {
return farbe;
}
//Mit dieser Methode knnen Sie die Farbe verndern.
public void setFarbe(String farbe) {
this.farbe = farbe;
}
}
Soeben haben wir gesehen, dass es mit der Methode public String
getFarbe( ) mglich ist, die Farbe eines Objektes auszulesen. Die Methode
gibt eine Variable vom Rckgabetyp String zurck. Die Methode public void
60
setFarbe(String farbe) hat den Rckgabetyp void (leer), da sie nichts zurckgibt. Nehmen Sie bitte zur Kenntnis, dass auf jeden Fall void stehen muss,
der Methodennamen darf nicht alleine stehen.
Die Methode public void setFarbe(String farbe) gibt zwar nichts zurck, aber
dafr ndert sie die Eigenschaft String farbe, indem ihr die Variable farbe
vom Typ String zur Verfgung gestellt wird. Wird einer Methode eine Variable
bergeben, heit dieser Wert bergabewert, wobei der Begriff Parameter in
der Fachliteratur synonym verwendet wird.
Es gibt neben private (Sichtbarkeit nur innerhalb der Klasse) noch andere Zugriffsbezeichner fr Klassen, Variablen und Methoden, und zwar public, protected und default. Der Zugriffsbezeichner default steht nicht explizit da, es
steht statt dessen nichts.
Zugriffsbezeichner
public
protected
c) Konstruktoren
Um von Klassen Objekte erzeugen zu knnen, brauchen wir Konstruktoren.
Ein Konstruktor ist vergleichbar mit einem Autokonstrukteur, der ein Auto entwirft, das dann in vielfacher Ausfertigung produziert werden kann. Der Name
des Konstruktors ist per Definition identisch mit dem Klassennamen, und er
wird ohne Rckgabetyp deklariert, d. h. erstellt. Der Konstruktor darf auch
nicht vom Rckgabetyp void sein. Gibt es allerdings eine Methode, die den
gleichen Namen wie die Klasse und einen Rckgabetyp besitzt, fhrt dies
nicht zu einem Kompilierfehler, es hat nur zur Folge, dass diese Methode
3.1
61
kein Konstruktor mehr ist, sondern eine Methode. Konstruktoren knnen die
Zugriffsbezeichner public, protected, package, local und private haben. Eine
Klasse kann mehrere Konstruktoren haben, die sich u. a. durch die bergebenen Parameter unterscheiden.
Beispiele fr Konstruktoren:
1. Auto ( ) { System.out.println(Ich bin ein Konstruktor!); }
2. Auto(String farbe) { System.out.println(Ich bin ein Konstruktor, dem die
Variable vom Typ String bergeben wird!); }
Ist kein Konstruktor explizit definiert, wird automatisch ein impliziter Standard-Konstruktor (default constructor) erstellt, der nicht explizit dasteht,
sprich er ist unsichtbar. Dieser Konstruktor ist leer und enthlt keine Parameter. Fr unsere Klasse Auto wre das der Standardkonstruktor Auto( ){ } (vgl.
Kapitel 3.6 Objektreferenz und Konstruktoraufruf mit this und super ab
Seite 101).
d) Konstanten
Konstanten sind Werte, die immer gleich sind. So ist z. B. die Zahl Pi eine bereits vordefinierte konstante Zahl. Will man eine Konstante definieren, muss
der Zugriffsbezeichner final davor stehen und sie muss initialisiert werden,
d. h. ihr muss von Anfang an ein Wert zugewiesen werden. Einer Konstanten
darf nur einmal ein Wert zugewiesen werden. Wird ihr ein weiterer Wert zugewiesen, kommt es zu einem Kompilierfehler.
62
Wort, wird der erste Buchstabe von diesem grogeschrieben. Diese Regelung entspricht der JavaBean Namenskonvention.
Auto gruenesAuto;
Hier unsere erste Instanz der Klasse Auto in der Klasse Autohandel:
public class Autohandel {
public static void main(String[ ] args) {
//Neue Instanz der Klasse Auto
Auto gruenesAuto = new Auto();
}
}
Der Name der Variablen wird auch Objektreferenz genannt (vgl. Kapitel 11
Garbage Collection ab Seite 433). Der Standardwert eines Objektes ist
null. Wird einer Objektreferenz der Standardwert null zugewiesen, entsteht
kein neues Objekt, da null kein Objekt, sondern ein Literal ist (vgl. Kapitel 2.5
Primitive Datentypen und Variablendeklaration ab Seite 37).
3.1
63
}
}
Die Eigenschaft farbe ist bei jeder Instanz der Klasse Auto anders. So hat jedes Auto eine andere Farbe, es gibt ein grnes Auto oder ein rotes Auto, aber
jedes Auto hat vier Rder. Eine Klassenvariable bezieht sich auf die ganze
Klasse und ist fr die ganze Klasse gleich. Die Klassenvariable gibt es nur
ein einziges Mal. Auch wenn es mehrere Objekte gibt, teilen sich alle Objekte
einer Klasse die gleiche Klassenvariable, wohingegen jedes Objekt eine eigene Instanzvariable besitzt. Da die statische Variable von allen Objekten
geteilt wird, bedeutet dies auch, wenn Sie fr ein Objekt die Klassenvariable
verndern, wie z. B. raeder = 3, ersetzen Sie diesen Wert auch fr alle anderen Objekte.
(1) Zugriff auf Instanz- und Klassenvariablen
64
Bitte beachten Sie, dass das Verwenden von statischen Variablen und Methoden der Objektorientierung widerspricht und deshalb nur sparsam eingesetzt werden sollte.
b) Lokale Variablen
Lokale Variablen sind Variablen, die weder fr eine Klasse noch fr ein Objekt gelten, sondern nur innerhalb einer Methode, eines Blocks, einer
for-Schleife oder einer if-Struktur. Lokale Variablen sind nur in dem Bereich
bekannt, in dem sie definiert wurden. Von auerhalb knnen Sie auf diese
Variablen nicht zugreifen (vgl. Kapitel 5.2.3 Die for-Schleife ab Seite 225),
sprich der Geltungsbereich (scope) bezieht sich nur auf einen kleinen, bestimmten Bereich. Zu Kompilierfehlern in Bezug auf lokale Variablen kommt
es in folgenden Fllen. Erstens: Wenn Sie z. B. jenseits einer for-Schleife die
lokale Variable, die innerhalb der for-Schleife definiert wurde, benutzen wollen. Sie ist dort unbekannt. Zweitens: Einer lokalen Variable wurde kein Wert
zugewiesen, sprich sie wurde nicht initialisiert.
3.1.6 Packages
Mehrere Klassen werden zu einem Package zusammengefasst, da in Java
Ordnung herrscht. So wird nicht alles durcheinander in einen Schrank geworfen, sondern alles wird wohlgeordnet in Schubladen verstaut. Diese Schubladen heien Packages. Die Schachtel fr unsere Prfungsaufgaben heit
z. B. scjp. So steht in einer Klasse ganz oben, zu welchem Package sie gehrt. Darunter stehen die importierten Packages, die bereits von anderen
Programmierern erstellt worden sind und Ihnen zur Verfgung stehen. Eine
Beschreibung dieser Packages befindet sich in den Javadocs (Api Documentation), die Sie unter http://java.sun.com/j2se/1.5.0/docs/index.html herunterladen knnen (vgl. Kapitel 1.2 Wie arbeite ich mit Java und NetBeans? ab
Seite 13).
Es ist sinnvoll, von Zeit zu Zeit in dieser Dokumentation etwas nachzuschauen, um ausfhrliche Hintergrundinformationen ber Klassen und Methoden zu erhalten. Um zur Startseite der Dokumentation zu gelangen, ffnen Sie bitte die index.html, nachdem Sie die Dokumentation
heruntergeladen und entzippt haben, klicken Sie auf den Link Java 2 Platform API Specification. Die erste Seite sieht von der Aufteilung so aus, wie
Sie es in unten stehender Abbildung sehen knnen. Links befinden sich die
Packages und Klassen und rechts knnen Sie den jeweils entsprechenden
Inhalt sehen.
3.1
65
Das Package scjp ist ein Package, das ich erstellt habe und in das ich alle
Klassen dieses Buches abgelegt habe. Wie Sie eigene Packages anlegen,
knnen Sie im Kapitel 2.1 Das erste Java-Programm in NetBeans ab Seite
21 nachlesen. So knnte z. B. in der Klasse Auto unseres Buches ganz oben,
noch vor der Klassendefinition, Folgendes stehen: Das Package, in dem Ihre
Klasse sich befindet, und gleich danach alle importierten Klassen und Packages, die Sie zustzlich in Ihrer Klasse brauchen.
//Package, in dem sich die Klasse Auto befindet
package scjp;
//importiertes Package, das Sie fr Ihren Code brauchen
import java.util.*;
public class Auto { ... }
Wollen Sie, wenn Sie sich in einer anderen Klasse eines anderen Packages
befinden, die Klasse Auto importieren, dann gibt es zwei Mglichkeiten dies
zu tun:
import scjp.*; oder import scjp.Auto;
Mit der ersten Variante importieren Sie alle Klassen und Interfaces des Packages scjp, mit der zweiten nur die Klasse Auto.
66
Welche der unten stehenden Codefragmente beinhaltet eine korrekte Implementierung eines Konstruktors?
a) public class Car{ Car void( ) { }; }
b) public class Car{ Car ( ) { }; }
c) public class Car{ car ( ) { }; }
d) public class Car{ Car (String anzahl) { }; }
e) public class Car{ Car String( ) { }; }
3.1
67
Lsungen
(1) Frage
(2) Frage
b, c Auf Methoden, die private sind, kann nur innerhalb ihrer eigenen Klasse
zugegriffen werden, wohingegen auf Methoden, die public sind, von
berall her zugegriffen werden kann.
(3) Frage
b, d Der Name des Konstruktors ist per Definition identisch mit dem Klassennamen, und er wird ohne Rckgabetyp deklariert, d. h. erstellt. Der
Konstruktor darf auch nicht vom Rckgabetyp void sein. Eine Klasse
kann mehrere Konstruktoren haben, die sich u. a. durch die bergebenen Parameter unterscheiden. Konstruktoren knnen die Zugriffsbezeichner public, protected, package local und private haben.
68
(4) Frage
d, e Ganz oben in einer Klasse steht das Package, in dem sich die Klasse befindet,
anschlieend stehen die Klassen, die importiert werden, und dann erst kommt
die Klassendefinition.
3.2 Vererbung
3.2.1 Begriffserluterung
In der objektorientierten Programmierung gibt es ein Prinzip, das sich Vererbung nennt. Dieser Begriff wurde in Analogie zu der Vererbung in der Welt
der Tiere und der Menschen gewhlt. Ein Kind erbt von seinem Vater die
Nase, mathematisches Grundverstndnis oder musikalisches Empfinden.
Wird an ein Kind die Musikalitt seines Vater weitergegeben, kann es richtig
singen oder leichter ein Musikinstrument erlernen. Vererbungsbeziehungen
werden in Java als Relation zwischen Superklasse (Vaterklasse) und Subklasse (Kindklasse) abgebildet.
Erinnern wir uns an unsere Klasse Auto, welche die Eigenschaft farbe hatte,
die verndert werden konnte und wie folgt aussah:
public class Auto {
private String farbe;
public String getFarbe() {
return farbe;
}
public void setFarbe(String farbe) {
this.farbe = farbe;
3.2
Vererbung
69
}
}
Unsere erste Subklasse soll eine Kindklasse zu unserer Klasse Auto sein.
Diese Vater-Kind-Beziehung heit is-a-Relationship und wird in der Klassendefinition mit dem Schlsselwort extends gekennzeichnet. Es gilt zu beachten, dass eine Klasse per Definition nur eine extends-Beziehung haben kann.
public class Sportwagen extends Auto{
}
Wie Sie sehen knnen, ist unsere Subklasse Sportwagen noch ohne Inhalt.
Im Moment stehen dieser Klasse nur Eigenschaften und Methoden zur Verfgung, die sie von der Superklasse Auto erbt. Das bedeutet, dass die Klasse
Sportwagen von der Superklasse Auto die Eigenschaft farbe und die dazugehrigen Getter- und Settermethoden bernimmt. Im unten stehenden Beispiel wird in der Klasse Autohandel sowohl eine Instanz der Klasse Auto als
auch der Klasse Sportwagen erstellt, und wie Sie sehen knnen, kann man
mit den Methoden der Klasse Auto, die Farbe sowohl des Autos als auch des
Sportwagens aus- und wieder einlesen. Sie mssen also nur einmal diese
Methoden definieren und haben sie dann in allen Subklassen zur Verfgung.
package scjp;
public class Autohandel {
public static void main(String[ ] args) {
String farbe = grn;
String farbeSport = rot;
Auto gruenesAuto = new Auto();
gruenesAuto.setFarbe(farbe);
System.out.print(Die Farbe des Auto ist grn: );
System.out.println(gruenesAuto.getFarbe());
Sportwagen ferrari = new Sportwagen();
ferrari.setFarbe(farbeSport);
System.out.print(Die Farbe des Sportwagens ist rot: );
System.out.println(ferrari.getFarbe());
}
}
70
Auto. Die Subklasse Sportwagen kann allerdings nicht auf die Variable farbe
der Klasse Auto direkt zugreifen, da diese private ist. Sie kann nur die Methoden der Vaterklasse verwenden, die public sind (vgl. auch Kapitel 3.1.3
Bestandteile von Klassen).
Dies bedeutet auch, dass Sie auf package local Bestandteile in Klassen und
Subklassen, die sich in anderen Packages befinden, nicht mehr zugreifen
knnen. Wir verschieben nun die Kindklasse in ein anderes Package. Jetzt
kann weder die Klasse Voegel noch die Klasse Papagei auf die Methode
singe( ) oder die Variable p zugreifen und es kommt zu Kompilierfehlern:
package Test;
import scjp.Voegel;
3.2
Vererbung
71
Der Unterschied kommt zum Tragen, wenn sich beide Klassen in verschiedenen Packages befinden. Der Zugriffsbezeichner protected gewhrleistet,
zustzlich zu package local, den Zugriff auf die Methode und die Variable der
Vaterklasse, aber nur in der Kindklasse, die sich in einem anderen Package
befindet.
package Test;
import scjp.Voegel;
72
3.3
73
Lsungen
(1) Frage
d, e, Die falschen Aussagen mssen richtig wie folgt lauten: Die Beziehung zwischen
f, h einer Superklasse und einer Subklasse nennt sich is-a-Relationship. Dies ist
eine korrekte Formulierung fr eine Vererbungsbeziehung zwischen Klassen:
public class Kaktus extends Pflanze { }. Ein Subklasse erbt Methoden von der
Superklasse.
74
Will ich jetzt meiner Klasse Auto sagen, sie soll das Interface Fahrzeug implementieren, um zu garantieren, dass meine Klasse Auto auch eine Methode
fahren( ) hat, muss ich sie um das Schlsselwort implements und den Namen
des Interfaces ergnzen. Sobald ich dies getan habe, bringt mir NetBeans
sofort eine Fehlermeldung und einen Hinweis darber, was ich tun soll: Klicken Sie auf das rote Kreuz am linken Rand und auf die Glhbirne und anschlieend auf die Meldung "Implement all abstract methods"!
Ich bekomme also die Empfehlung, eine Methode fahren( ) in meine Klasse
Auto einzufgen. Es wird gewhrleistet, dass mein Auto auf jeden Fall fahren
kann. Interfaces erinnern uns daran, nichts zu vergessen. Das Interface stellt
zustzlich sicher, dass die Methode fahren( ) in allen Klassen gleich heit,
um Konfusionen in Bezug auf Methodennamen zu verhindern. Wrde die
Methode fahren in jeder Klasse unterschiedlich genannt werden, wie z. B. in
der Klasse Auto autofahren( ), in der Klasse Motorrad motorrad_fahren( )
oder in der Klasse Lastwagen fahrenLastwagen( ), wre die Gefahr gro,
diese Namen zu vergessen und durcheinanderzubringen.
Unten stehend finden Sie die Klasse Auto mit der implementierten Methode
fahren( ). Die Methode fahren( ) darf sich durch nichts, weder durch einen anderen Rckgabetyp noch durch einen zustzlichen Parameter, von der ursprnglichen Methode unterscheiden, und sie muss ebenfalls public sein,
wie die Methode fahren( ) aus dem Interface Fahrzeug. Dies ist verwirrend,
da die Methode fahren( ) aus dem Interface nur implizit abstract und public
ist, dies bedeutet abstract und public stehen dort, aber unsichtbar. Die konkrete Implementierung darf aber nicht mehr abstrakt sein (siehe auch weiter
unten den Abschnitt Abstrakte Klassen). Werden nicht alle Methoden aus
dem Interface in einer Klasse implementiert, muss diese Klasse wiederum
als abstract deklariert werden.
public class Auto implements Fahrzeug{
private String farbe;
3.3
75
Des Weiteren kann ein Interface ein anderes Interface mit dem Schlsselwort
extends ergnzen. Ein Interface kann durch mehrere Interfaces erweitert
werden. Eine Klasse kann mehrere implements-Beziehungen besitzen, aber,
erinneren wir uns an das Kapitel 3.2 Vererbung, nur eine einzige extendsBeziehung. Die Methoden innerhalb eines Interfaces sind implizit abstract
und public, was normalerweise weggelassen wird bzw. weggelassen werden
kann, und es darf dort nur abstract und public stehen und nichts anderes. Interfaces knnen zustzlich Konstanten enthalten, die als implizit public, static
und final gelten. Es besteht aber die Mglichkeit, dass keiner, einer oder zwei
dieser Begriffe da stehen, ohne dass es zu einem Kompilierfehler fhrt. Es
darf dort aber nichts anderes stehen.
Unten stehend unser Interface Fahrzeug mit einer Methode und einer Konstante.
package scjp;
public interface Fahrzeug {
/*dies sind Konstanten, die implizit public,
static und final sind*/
double d = 3.14;
//Methoden sind implizit abstract und public
void fahren();
}
76
sprich sie knnen Inhalt besitzen. Abstrakte Klassen knnen nicht mit dem
Schlsselwort new instanziiert werden, obwohl sie einen Konstruktor haben.
Wir knnen nur auf die statischen Methoden einer abstrakten Klasse zugreifen. Der Konstruktor der abstrakten Klasse besteht also nur aus Implementierungsvorschriften. Hier ein Beispiel eines statischen Zugriffs auf die Methode
getInstance( ) der abstrakten Klasse Calendar, die Ihnen verschiedene Kalenderfunktionen zur Verfgung stellt (vgl. Kapitel 14.7.3.4 Das Datumsformat
ab Seite 644).
Calendar cal = Calender.getInstance();
Wir knnen mit abstrakten Klassen, wie auch mit Interfaces nur sicherstellen,
dass in Klassen gewisse Methoden vorhanden sind. In einer Subklasse der
abstrakten Klasse mssen die abstrakten Methoden im Gegensatz zu den
ausformulierten implementiert werden. Des Weiteren mssen Klassen als
abstract gekennzeichnet werden, wenn sie eine als abstract deklarierte Methode enthalten. Abstrakte Klassen, die ein Interface implementieren, mssen nicht alle Methoden des Interfaces implementieren.
Welche der unten stehenden Begriffe knnen in Interfaces vor Methoden stehen?
a) protected
b) private
c) final
d) abstract
e) public
f) package local
g) static
h) Keine dieser Mglichkeiten.
(2) Frage
3.3
77
a) Zeile 1
b) Zeile 2
c) Zeile 3
Zeile 1
Zeile 2
Zeile 3
Zeile 4
Zeile 5
78
d) Zeile 4
e) Zeile 5
f) Keine dieser Mglichkeiten.
(5) Frage
Zeile 1
Zeile 2
Zeile 3
Zeile 4
Zeile 5
a) Zeile 1
b) Zeile 2
c) Zeile 3
d) Zeile 4
e) Zeile 5
f) Keine dieser Mglichkeiten.
(6) Frage
a) Zeile 1
b) Zeile 2
c) Zeile 3
d) Zeile 4
e) Zeile 5
f) Keine dieser Mglichkeiten.
Zeile 1
Zeile 2
Zeile 3
Zeile 4
Zeile 5
3.3
(7) Frage
Zeile 1
Zeile 2
Zeile 3
Zeile 4
Zeile 5
a) Zeile 1
b) Zeile 2
c) Zeile 3
d) Zeile 4
e) Zeile 5
f) Keine dieser Mglichkeiten.
(8) Frage
a) Zeile 1
b) Zeile 2
c) Zeile 3
d) Zeile 4
e) Zeile 5
f) Keine dieser Mglichkeiten.
Zeile 1
Zeile 2
Zeile 3
Zeile 4
Zeile 5
79
80
(9) Frage
a) Zeile 1
b) Zeile 2
c) Zeile 3
d) Zeile 4
e) Zeile 5
f) Keine dieser Mglichkeiten.
Lsungen
(1) Frage
Zeile 1
Zeile 2
Zeile 3
Zeile 4
Zeile 5
3.3
81
(2) Frage
c, d, Interfaces enthalten nur leere Methoden, die implizit abstract und public sind,
h
wohingegen abstrakte Klassen auch Methoden mit Inhalt besitzen knnen. Ein
Interface darf Konstanten enthalten, aber keine Methoden, die static sind. Vergleichen Sie hierzu auch das Kapitel 3.4 Modifier auf der nchsten Seite. Ein
Interface kann ein anderes Interface mit dem Schlsselwort extends ergnzen
und nicht mit implements und ein Interface kann durch mehrere Interfaces erweitert werden. Eine Klasse, die eine abstrakte Methode enthlt, muss wiederum
als abstract deklariert werden.
(3) Frage
a, b, Siehe auch Lsung von Aufgabe 2. Und es muss heien: class A implements ine, f, terface B.
g
(4) Frage
(5) Frage
(7) Frage
(9) Frage
82
3.4 Modifier
3.4.1 Allgemeines
Wie wir bereits in den vorangegangenen Kapiteln gelernt haben, knnen
Klassen, Methoden und Variablen public, private, protected oder package local sein. Das Schlsselwort private hat die Aufgabe, vor unbefugtem Zugriff
von auen zu schtzen, wohingegen public gewhrleisten soll, dass eine
Klasse als ffentlich zugngliches Modell fr Objekte gilt (vgl. Kapitel 3.1
Bestandteile von Klassen). Abstrakte Methoden sind leere Methoden, die
erst spter mit Inhalt gefllt werden sollen, und konstante Werte, wie z. B. der
Wert PI, mssen als final deklariert werden. Begriffe, welche die Eigenschaften von Klassen, Methoden und Variablen nher definieren, nennt man Modifier. Nun wollen wir einige weitere Modifier und ihre Verwendungsmglichkeiten kennen lernen.
a) native
Der Ausdruck native kann nur Methoden nher bestimmen. Native Methoden
bestehen nicht aus Javacode, sondern aus Code einer anderen Programmiersprache, wie z. B. C oder C++.
b) transient
Transiente Variablen stehen in direkter Verbindung mit dem Thema Speicherung von Objekten (zur Serialisierung von Objekten vgl. Kapitel 14.8.6 ab
Seite 667). Variablen, die als transient beschrieben werden, beinhalten
Werte, die nicht serialisiert, sprich gespeichert werden sollen. Und nur Variablen knnen als transient deklariert werden.
c) synchronized
Die Verwendung des Modifiers synchronized steht in direkter Verbindung mit
der Themenstellung Threads (Kapitel 10 Threads ab Seite 405). Eine Methode, die durch den Modifier synchronized nher bestimmt wird, soll bei der
Verwendung von Threads sicherstellen, dass nur ein Thread Zugriff auf eine
Methode hat und nicht zwei Threads gleichzeitig. Der Modifier synchronized
bezieht sich nur auf Methoden und Blcke.
d) strictfp
Strictfp stellt bei Methoden, Interfaces und Klassen sicher, dass bei
Nachkommaberechnungen immer das gleiche Ergebnis herauskommt,
sprich es soll zu keinen Rundungsfehlern kommen.
3.4
Modifier
83
e) final
Den Begriff final haben wir bereits kennengelernt als Modifier fr Werte, die
nicht verndert werden drfen, sprich Konstanten. Der Modifier final kann
auch bei Klassen verwendet werden. Finale Klassen drfen keine Subklassen haben, in denen die Methoden der Klasse berschrieben werden knnten. Dies stellt einen unberbrckbaren Gegensatz zum Modifier abstract
dar, da eine finale Klasse nicht mehr verndert werden darf, eine abstrakte
Klasse, aber noch verndert werden muss (vgl. Kapitel 3.3 Interfaces und
abstrakte Klassen)! Diese beiden Modifier schlieen sich gegenseitig aus,
sie widersprechen sich. Alle Methoden in einer final class sind implizit final
und knnen somit auch nicht berschrieben werden.
Interfaces
Variablen
Methoden
Klassen
private
per Definition
transient
private
strictfp
protected
abstract und
private
protected
public
public
public
protected
public
package
public
static
local
package local
abstract
(default)
package local
(default)
strictfp
(default)
static
final
final
native
abstract
synchronized
strictfp
84
fr Konstanten
public
public
static
final
Welche der unten stehenden Modifier fr Methoden knnen in Interfaces verwendet werden?
a) protected
b) private
c) final
d) abstract
e) public
f) package local
g) static
h) Keine dieser Mglichkeiten.
(2) Frage
3.4
Modifier
85
86
d) abstract
e) public
f) protected
g) strictfp
h) Keine dieser Mglichkeiten.
(6) Frage
3.4
Modifier
87
Lsungen
(1) Frage
d, e Methoden in Interfaces knnen nur public und abstract sein (vgl. auch
Kapitel 3.3 Interfaces und abstrakte Klassen).
(2) Frage
Es sind nur folgende Modifier fr Konstanten in Interfaces erlaubt: public, static und final (vgl. auch Kapitel 3.3 Interfaces und abstrakte
Klassen).
(3) Frage
a, b, Konstruktoren knnen private, public, protected und package local sein (siehe
e
auch den Abschnitt Konstruktoren in Kapitel 3.13 ab Seite 58).
(5) Frage
b, e, Die Modifier native und synchronized sind nur fr Methoden verwendbar. Vaf
riablen knnen durch folgende Modifier ergnzt werden: transient, private,
protected, public, package local und static.
(6) Frage
Native Methoden bestehen nicht aus Java, sondern aus irgendeiner anderen Programmiersprache.
88
(7) Frage
b, d, Interfaces knnen nur public und abstract sein und die Modifier abstract und
e, g final schlieen sich gegenseitig aus. Klassen knnen strictfp, public, package local, final und abstract sein.
(8) Frage
89
Diese berladenen Methoden sind dazu da, dass fr Zahlen mit unterschiedlichem Datentyp ein maximaler Wert berechnet werden kann. Es wird fr
ganzzahlige Werte und fr Fliekommazahlen der maximale Wert herausgefunden. Fliekommazahlen mssen im amerikanischen Zahlenformat eingegeben werden, mit Punkt statt Komma als Trennzeichen.
public class maxWert {
public static void main(String[ ] args) {
//Maximum von zwei Ganzzahlen (int-Werten)
System.out.println(Math.max(4, 5));
//Maximum von zwei Dezimalzahlen (double-Werten)
System.out.println(Math.max(4.524, 5.5478));
}
}
90
fr die Parameter keine Rolle. Es wrde gengen, die Parameter zu vertauschen, um einen Kompilierfehler zu verhindern.
long m1(int a, long b);
Weitere Mglichkeiten fr berladene Methoden, die auch nicht zu Kompilierfehlern fhren, bestehen im ndern der Anzahl der Parameter:
long m1(int a);
long m1();
Im ersten Fall haben Sie statt zwei Parametern nur noch einen und im zweiten Fall gar keinen mehr.
Zeile 1
Zeile 2
Zeile 3
Zeile 4
Zeile 5
a) Zeile 1
b) Zeile 2
c) Zeile 3
d) Zeile 4
e) Zeile 5
f) Keine dieser Mglichkeiten.
(2) Frage
Zeile 1
Zeile 2
Zeile 3
Zeile 4
91
Zeile 5
a) Zeile 1
b) Zeile 2
c) Zeile 3
d) Zeile 4
e) Zeile 5
f) Keine dieser Mglichkeiten.
(3) Frage
Zeile 1
Zeile 2
Zeile 3
Zeile 4
Zeile 5
a) Zeile 1
b) Zeile 2
c) Zeile 3
d) Zeile 4
e) Zeile 5
f) Keine dieser Mglichkeiten.
(4) Frage
92
Lsungen
(1) Frage
(2) Frage
Es reicht nicht aus, wenn eine Methode unterschiedliche Rckgabetypen hat, da es beim berladen nur wichtig ist, dass sich die Parameter
voneinander unterscheiden.
(3) Frage
Es reicht nicht aus, wenn die Parameter unterschiedliche Namen haben. Die Parameter mssen sich in Bezug auf die Datentypen unterscheiden.
(4) Frage
b, c, Diese Lsungen treffen zu, da die entsprechenden Methoden sich zur urd
sprnglichen Methode durch vernderte Parameter unterscheiden.
(5) Frage
93
Die Klasse Sohn weist eine Vererbungsbeziehung extends mit der Klasse
Vater auf.
public class Sohn extends Vater{
94
Im nchsten Schritt entwerfen wir eine Klasse Familie und instanziieren jeweils ein Objekt Vater und ein Objekt Sohn. Fhren wir fr beide Objekte die
Methode laufen() durch, stellen wir fest, dass wir die gleiche Ausgabe erhalten, nmlich Ich bin der Vater!.
public class Familie {
public static void main(String[ ] args) {
Vater neuerVater = new Vater();
Sohn neuerSohn = new Sohn();
neuerVater.laufen();
neuerSohn.laufen();
}
}
Der Sohn erbt also die Methode laufen() vom Vater und sagt nun, wie der Vater, whrend er luft, dass er der Vater sei. Htte der Sohn keine Vererbungsbeziehung, wre die Methode laufen in der Klasse unbekannt, und es wrde
zur Laufzeit eine Exception geworfen werden (vgl. Kapitel 8 Exceptions ab
Seite 353).
Wollen wir nun, dass der Sohn ber eine eigene Methode laufen() verfgt,
und er etwas anderes sagt als der Vater, mssen wir eine neue Methode laufen() in der Klasse Sohn erstellen. Diesen Vorgang nennt man berschreiben der Methode laufen():
public class Sohn extends Vater{
void laufen(){
System.out.println(Ich bin der Sohn!);
}
}
public class Familie {
public static void main(String[ ] args) {
Vater neuerVater = new Vater();
Sohn neuerSohn = new Sohn();
neuerVater.laufen();
neuerSohn.laufen();
}
}
95
Nun sieht unser Ergebnis der Klasse Familie ganz anders aus. Es erscheinen
auf der Konsole zwei unterschiedliche Stze Ich bin der Vater! und Ich bin
der Sohn!
Ausgabe auf der Konsole:
Ich bin der Vater!
Ich bin der Sohn!
Die Methode laufen() in der Klasse Sohn berschreibt die gleichnamige Methode der Klasse Vater. Die berschreibende Methode muss den gleichen
Namen, die gleichen Parameter und den gleichen Rckgabetyp wie die Originalmethode haben. Wird der Rckgabewert verndert, ohne dass sich der
Parameter oder der Name ndert, kommt es zu einem Kompilierfehler. (Aber
neu in Java 1.5: Kovariante Rckgabetypen: Es sei denn, der neue Rckgabetyp ist ein Objekt einer Kindklasse des ursprnglichen Rckgabetyps.)
Die Methode, die berschreibt, darf die Zugriffsrechte der ursprnglichen
Methode nicht einschrnken, sondern sie mssen mindestens gleich bleiben
oder erweitert werden. D. h., ich kann gleich ffentlich bleiben oder ich muss
ffentlicher werden, andernfalls kommt es zu einem Kompilierfehler. So darf
eine protected Methode mit einer public oder einer protected Methode berschrieben werden, aber nicht mit einer Methode, die private ist. Es drfen aber
Methoden, die synchronized sind, berschrieben werden, die berschreibende Methode muss aber nicht wieder synchronized sein. Auerdem kann man
problemlos eine nicht synchronisierte Methode mit einer synchronized Methode berschreiben.
Methoden, die static, final oder private sind, drfen nicht berschrieben werden. Eine Kindklasse darf allerdings exakt die gleiche statische Methode besitzen, die wiederum static sein muss. Diese Methode berschreibt nicht die
ursprngliche Methode, sondern verdeckt sie nur (siehe auch Kapitel 3.7
Subtyping und Casting von Objekten ab Seite 114). Bei private ist es hnlich, die Kindklasse kann exakt die gleiche private Methode haben, aber vergessen Sie nicht, dass man auf private Methoden nur innerhalb der eigenen
Klassen zugreifen kann: So kann die Kindklasse nur auf die eigene private
Methode zugreifen (vgl. Kapitel 3.1 Klassen und Objekte, Unterkapitel
Zugriffsbezeichner).
96
a) MM
b) M
c) Nichts
d) Es wird eine Exception geworfen.
(4) Frage
a) MM
b) M
c) Nichts
d) Es wird eine Exception geworfen.
(5) Frage
a) MT
97
98
b) TM
c) M
d) T
e) Nichts
f) Es wird eine Exception geworfen.
(6) Frage
a) MT
b) TM
c) M
d) T
e) Nichts
f) Es wird eine Exception geworfen.
(7) Frage
Welche Methoden, die die Methode f() aus der Klasse Mutter berschreiben,
drfen in der Klasse Tochter stehen, ohne dass es zu einem Kompilierfehler
kommt ?
public class Mutter(){
void f() { System.out.println(M); }
}
public class Tochter extends Mutter() {
Welche Methode darf hier stehen?}
a) private void f( ){ }
99
b) public void f( ){ }
c) protected void f( ){ }
d) int f( ) {}
e) Keine dieser Mglichkeiten.
(8) Frage
Welche Methoden, die die Methode f() aus der Klasse Mutter berschreiben,
drfen in der Klasse Tochter stehen, ohne dass es zu einem Kompilierfehler
kommt ?
public class Mutter(){
public void f() { System.out.println(M); }
}
public class Tochter extends Mutter() {
Welche Methode darf hier stehen?
}
a) private void f( ){ }
b) public void f( ){ }
c) protected void f( ){ }
d) int f( ) {}
e) Keine dieser Mglichkeiten.
(9) Frage
Welche Methoden, die die Methode f() aus der Klasse Mutter berschreiben,
drfen in der Klasse Tochter stehen, ohne dass es zu einem Kompilierfehler
kommt?
public class Mutter(){
private void f() { System.out.println(M); }
}
public class Tochter extends Mutter() {
Welche Methode darf hier stehen?
}
a) final void f( ){ }
b) static void f( ){ }
c) void f( ){ }
d) string f( ) {}
100
Lsungen
(1) Frage
Alle Aussagen sind falsch: Methoden, die static, final oder private sind,
drfen nicht berschrieben werden. Sie knnen in der Subklasse Methoden der Superklasse berschreiben, Sie mssen aber nicht. Die Begriffe berschreiben und berladen knnen nicht synonym verwendet
werden. Beim berschreiben kann ich ffentlicher werden, wohingegen
berladene Methoden sowohl privater als auch ffentlicher in Bezug auf
ihre Sichtbarkeit werden knnen.
(2) Frage
a, b, Eine Subklasse erbt Methoden einer Superklasse, sie kann aber diese Methoden
d, g berschreiben, muss es aber nicht. Die Lsung e ist nicht korrekt, da dort stehen msste: Die berschreibende Methode muss den gleichen Namen, die
gleichen Parameter und den gleichen Rckgabetyp wie die Originalmethode
haben. Beim berschreiben kann ich ffentlicher werden, deswegen kann ich
eine protected Methode mit einer public Methode berschreiben, wohingegen
berladene Methoden sowohl privater als auch ffentlicher in Bezug auf ihre
Sichtbarkeit werden knnen.
(3) Frage
(4) Frage
(5) Frage
Es wird M T auf der Konsole ausgegeben, da die Tochterklasse die Methode f() berschreibt und somit eine eigene Methode f() besitzt.
(6) Frage
3.6
101
(7) Frage
(9) Frage
Nun sieht die Ausgabe in der Klasse Familie wie folgt aus:
public class Familie {
public static void main(String[ ] args) {
Sohn neuerSohn = new Sohn();
neuerSohn.laufen();
102
Die Methode laufen() in der Klasse Sohn, ruft mit dem Befehl super.laufen()
zustzlich die Methode laufen() der Klasse Vater auf.
Die Eigenschaft farbe hatten wir verndert mit der Methode setFarbe(String
farbe), der wir den Parameter String farbe bergeben haben.
3.6
103
In jeder Subklasse steht ebenfalls ein impliziter Standardkonstruktor, der implizit den Aufruf super() enthlt. Mit super() wird der Standardkonstruktor der
Vaterklasse aufgerufen. Hier ein Beispiel des Standardkonstruktors mit super() in unserer Klasse Sohn:
public class Sohn extends Vater{
Sohn(){
super();
}
}
Der implizite super()-Aufruf ist auch der Grund dafr, dass der Konstruktor
der Vaterklasse nicht private sein darf, obwohl Konstruktoren grundstzlich
private sein knnen (siehe Kapitel 3.4). Wre der Konstruktor private, knnte
104
er mit dem Konstruktoraufruf nicht mehr erreicht werden und es wrde zu einem Kompilierfehler kommen (vgl. auch Kapitel 3.2).
Im Folgenden werden wir die Handhabung der Konstruktoren nher betrachten. Dies wollen wir anhand einer neuen Klasse Kleidung tun. Diese Klasse
enthlt einen Konstruktor, dem ein Parameter Preis bergeben wird. Fgen
wir der Klasse einen Konstruktor Kleidung (double preis) hinzu, hat dies zur
Folge, dass es keinen Standardkonstruktor mehr gibt. Dadurch kommt es an
mehreren Stellen zu Kompilierfehlern. Will man Fehler vermeiden, sollte man
in diesem Fall immer zustzlich einen Standardkonstruktor erstellen. Sollten
Sie die folgenden Ausfhrungen verwirren, ist dies nur verstndlich, da es
schwierig ist, sich vorzustellen, wie ein unsichtbarer Konstruktor gelscht
werden kann.
public class Kleidung {
Kleidung(double preis){
System.out.println(Ich koste + preis);
}
}
Folgen wir der Anweisung von NetBeans nicht und erstellen folgenden Konstruktor, der einen Konstruktoraufruf mit super(preis) enthlt:
public class Rock extends Kleidung{
Rock(double preis) {
super(preis);
}
}
In folgendem Fall bekommen wir wieder Probleme: Fgen wir nun in der
Klasse Rock einen Standardkonstruktor hinzu, wrde dies erneut zu einem
3.6
105
Kompilierfehler fhren, da der Konstruktor Rock (){ } ganz oben implizit den
Konstruktoraufruf super() enthlt. Super() ruft den Standardkonstruktor der
Klasse Kleidung auf, den gibt es aber nicht mehr, so landet der Aufruf wieder
im Nichts.
Unter diesen Umstnden kommt es zu keiner Fehlermeldung mehr. Wir haben den Konstruktor, den wir gelscht haben, wieder hergestellt.
Wird jetzt ein Objekt der Klasse Rock instanziiert, wird automatisch der Konstruktor Kleidung(){ System.out.println(Ich bin ein Kleidungsstck); } der
Vaterklasse aufgerufen. Es kommt also zur Ausgabe von Ich bin ein Kleidungsstck, da im Konstruktor Rock ( ){ } ganz oben implizit super() steht.
Es wird also zuerst der Standardkonstruktor der Superklasse aufgerufen und
ausgefhrt und dann erst der Konstruktor der Subklasse. Der Konstruktor
wird also implizit oder explizit aufgerufen und nicht vererbt.
public class Rock extends Kleidung{
//Im Standardkonstuktor steht implizit super();
Rock(){
}
Rock(double preis) {
106
Erstellen wir eine Instanz der Klasse Rock mit dem Konstruktor Rock(double
Preis){ ... } erhalten wir unten stehende Ausgabe, da dieser Konstruktor den
Konstruktor Kleidung(double preis) { ... } mit dem Aufruf super(preis) aus der
Vaterklasse aufruft:
public class Rock extends Kleidung{
Rock(){
}
Rock(double preis) {
super(preis);
}
public static void main(String[ ] args) {
Rock preisRock = new Rock(2.2);
}
}
ndern wir die Klasse Rock, indem wir in den Konstruktor Rock(preis){ ... }
die Ausgabe eines Satzes hinzufgen, erhalten wir unten stehende Ausgabe.
Richten Sie Ihr Augenmerk darauf, dass der Superaufruf immer ganz oben in
dem Konstruktor stehen muss, ansonsten kommt es zu einem Kompilierfehler.
public class Rock extends Kleidung{
Rock(){
}
Rock(double preis) {
super(preis);
System.out.println(Ich bin ein Rock);
}
public static void main(String[ ] args) {
Rock preisRock = new Rock(2.2);
3.6
107
}
}
108
3.6
109
Rock(double preis) {
super(preis);
System.out.println(Ich bin ein Rock);
}
public static void main(String[ ] args) {
Rock rock = new Rock();
Rock preisRock = new Rock(2.2);
}
}
110
Welches Ergebnis erhlt man, wenn man folgendes Programm kompiliert und
startet?
class Vater{
Vater(){
System.out.println(Vater);
}
}
class Tochter extends Vater{
Tochter(){
System.out.println(Tochter);
}
public static void main(String[ ] args){
Tochter tochter = new Tochter();
}
}
a) Tochter
b) Vater Tochter
c) Tochter Vater
d) Vater
e) Keine Ausgabe
f) Kompilierfehler
(4) Frage
Welches Ergebnis erhlt man, wenn man folgendes Programm kompiliert und
startet?
class Vater{
Vater(){
System.out.println(Vater);
}
}
class Tochter {
Tochter(){
System.out.println(Tochter);
3.6
111
}
public static void main(String[ ] args){
Tochter tochter = new Tochter();
}
}
a) Tochter
b) Vater Tochter
c) Tochter Vater
d) Vater
e) Keine Ausgabe
f) Kompilierfehler
(5) Frage
Welches Ergebnis erhlt man, wenn man folgendes Programm kompiliert und
startet?
class Vater{
Vater(){
System.out.println(Vater);
}
}
class Tochter extends Vater{
Tochter(){
System.out.println(Tochter);
}
public static void main(String[ ] args){
Tochter tochter = new Tochter();
super();
}
}
a) Tochter
b) Vater Tochter
c) Tochter Vater
d) Vater
e) Keine Ausgabe
f) Kompilierfehler
112
(6) Frage
Welches Ergebnis erhlt man, wenn man folgendes Programm kompiliert und
startet?
class Vater{
Vater(){
System.out.println(Vater);
}
}
class Tochter extends Vater{
Tochter(){
super()
System.out.println(Tochter);
}
public static void main(String[ ] args){
Tochter tochter = new Tochter();
}
}
a) Tochter
b) Vater Vater Tochter
c) Vater Tochter Vater
d) Vater Tochter
e) Keine Ausgabe
f) Kompilierfehler
g) Keine dieser Mglichkeiten.
(7) Frage
Welches Ergebnis erhlt man, wenn man folgendes Programm kompiliert und
startet?
class Vater{
Vater(){
System.out.println(Vater);
}
}
class Tochter extends Vater{
Tochter(){
this(Tochter);
System.out.println(Tochter);
}
3.6
113
Tochter(String wort){
System.out.println(Ich bin + wort);
}
public static void main(String[ ] args){
Tochter tochter = new Tochter();
}
}
Lsungen
(1) Frage
(2) Frage
(3) Frage
Es kommt zur Ausgabe Vater Tochter, da im Konstruktor der Tochterklasse ganz oben ein impliziter super()-Aufruf steht. Dieser super()-Aufruf hat zur Folge, dass auch der Standardkonstruktor der Vaterklasse
ausgefhrt wird.
114
(4) Frage
Es fehlt die extends-Beziehung, also gibt es auch kein Verwandtschaftsverhltnis und es wird nur Tochter auf der Konsole ausgegeben.
(5) Frage
Der Aufruf super() muss im Konstruktor immer ganz oben stehen, ansonsten kommt es zu einem Kompilierfehler. Auerdem darf er nicht in
der main()-Methode stehen.
(6) Frage
Der explizite und implizite Aufruf von super() hat den gleichen Effekt,
also wird zuerst der Standardkonstruktor der Vaterklasse ausgefhrt
und anschlieend der Standardkonstruktor der Tochterklasse.
(7) Frage
Es wird Vater Ich bin Tochter Tochter ausgegeben, da der Konstruktoraufruf this(Tochter) den Standardaufruf ersetzt, so wird der Konstuktor mit Parameter ausgefhrt, in dem oben auch ein impliziter super()Aufruf steht, und anschlieend noch der Befehl System.out.println(Tochter);.
115
Normalerweise instanziiert man ein Objekt der Klasse Tisch folgendermaen: Tisch neuer Tisch = new Tisch();, da Sie aber noch nicht sicher sind, ob
Sie einen Tisch oder Stuhl bentigen, geht dies mit Moebel neuMoebel = new
Tisch();. Sie sagen also, dass Sie ein Mbelstck brauchen, das im Moment
ein Tisch ist. Da ein Tisch ein Moebel ist, kann die Referenzvariable neuMoebel, die vom Typ her Moebel ist, ein Objekt vom Typ Tisch speichern. Diese
Vorgehensweise wird Subtyping genannt.
Ein Tisch ist ein Mbelstck, deshalb ist diese Zuweisung mglich. Anders
herum geht es nicht, da ein Mbelstck nicht notwendigerweise ein Tisch ist.
Versuchen wir dies zu tun, wird die entsprechende Stelle in NetBeans als
falsch gekennzeichnet.
Lassen Sie uns nun erforschen, was passiert, wenn Sie auf dem Objekt neuMoebel die Methode stehen() aufrufen. Es wird die Methode stehen() des
Objektes Tisch, der Sohnklasse, ausgefhrt. Zuerst wird immer nach der Methode stehen() in der Vaterklasse gesucht, wenn allerdings in der Sohnklasse eine berschriebene Methode existiert, wird diese genommen, andernfalls wird die Methode der Vaterklasse ausgefhrt. Bei der
Instanzvariablen preis greift er in diesem Fall auf den Preis der Vaterklasse
und nicht auf den Preis der Kindklasse zu, da diese nicht vererbt bzw. berschrieben, sondern nur verdeckt (hidden) wird. Existiert allerdings in der Vaterklasse diese Methode oder diese Variable nicht, kommt es zu einem Kompilierfehler.
public class Tisch extends Moebel{
double preis = 3.0;
public static void main(String[ ] args) {
Moebel neuMoebel = new Tisch();
116
Ersetzen wir nun in den Methoden stehen() der Sub- und Superklasse public
durch static, stellen wir fest, dass die statische Methode der Subklasse, die
statische Methode der Superklasse nur verdeckt und nicht berschreibt. So
wird, wie Sie in unten stehendem Beispiel sehen, auf der Konsole Ich bin ein
Mbelstck ausgegeben.
public class Moebel {
double preis = 2.0;
static void stehen(){
System.out.println(Ich bin ein Mbelstck);
}
}
public class Tisch extends Moebel{
double preis = 3.0;
public static void main(String[ ] args) {
Moebel neuMoebel = new Tisch();
neuMoebel.stehen();
System.out.println(neuMoebel.preis);
}
static void stehen() {
System.out.println(Ich bin ein Tisch!);
}
}
Nehmen wir nun an, dass wir eine zustzliche Subklasse der Klasse Moebel,
und zwar die Klasse Stuhl, und wieder unsere Methoden, die public sind, haben.
public class Stuhl extends Moebel{
private void stehen() {
System.out.println(Ich bin ein Stuhl!);
117
}
}
Nun knnen wir nachtrglich der Referenzvariablen neuMoebel ein Stuhlobjekt zuweisen. Dies ist mglich, da sowohl ein Objekt der Klasse Tisch als
auch der Klasse Stuhl ein Mbelstck ist. Sie erhalten nun als Ausgabe Ich
bin ein Stuhl!.
public class Tisch extends Moebel{
public static void main(String[ ] args) {
Moebel neuMoebel = new Tisch();
neuMoebel = new Stuhl();
neuMoebel.stehen();
}
public void stehen() {
System.out.println(Ich bin ein Tisch!);
}
}
118
Wohingegen weder ein Tisch in einen Stuhl, noch ein Stuhl in einen Tisch
verwandelt werden kann. Diesbezgliche Zuweisungen und Castings fhren
unweigerlich zu einem Kompilierfehler, da ein Stuhl kein Tisch ist und ein
Tisch kein Stuhl.
public class Moebel {
public void stehen(){
System.out.println(Ich bin ein Mbelstck);
}
public static void main(String[ ] args){
Moebel moebel = new Moebel();
Tisch tisch = new Tisch();
Stuhl stuhl = new Stuhl();
stuhl = tisch; //Kompilierfehler
stuhl = (Stuhl)tisch; //Kompilierfehler
}
}
Will man ein Objekt vom Typ Moebel in einen Tisch oder Stuhl umwandeln,
schlgt dieser Versuch fehl, da die Klasse Moebel sowohl einen Tisch als
auch einen Stuhl beinhalten kann und nicht nur das eine oder das andere.
Dies bemerkt der Kompiler allerdings nicht zur Kompilierzeit. NetBeans zeigt
keinen Fehler an, es kommt erst zur Laufzeit zu einer ClassCastException.
Diese ClassCastException kann ich vermeiden, indem ich der Referenzvariablen moebel sage, dass sie ein Objekt vom Typ Tisch beinhalten kann. Sie
fgen moebel = tisch ein. So kann ich nachtrglich ein Mbelstck in einen
119
ndere ich allerdings stattdessen den Code, indem ich der Referenzvariable
moebel ein Objekt vom Typ Stuhl zuweise, kommt es zu einem Laufzeitfehler. Diese Tatsache wird vom Kompiler nicht entdeckt, da gem Deklaration
moebel vom Typ Moebel ist und so theoretisch auch ein Objekt vom Typ
Tisch enthalten kann, aber nun beinhaltet es ein Objekt vom Typ Stuhl. Und
einen Stuhl kann ich nicht in einen Tisch umwandeln. Diese Tatsache wird
erst zur Laufzeit entdeckt (ClassCastException).
120
121
Wird allerdings ein Objekt mit einem Interface verglichen, mit dem es keinerlei Verwandtschaftsverhltnis gibt, wird false zurckgegeben, und es kommt
weder zu einem Kompilier- noch zu einem Laufzeitfehler. In unten stehendem Beispiel soll herausgefunden werden, ob ein Sportwagen eine Collection ist. Da dies nicht der Fall ist, wird false auf der Konsole ausgegeben (vgl.
Kapitel 12 Das Collections-Framework ab Seite 453).
import java.util.Collection;
public class Sportwagen extends Auto{
public static void main(String[ ] args) {
Sportwagen sportwagen = new Sportwagen();
boolean a = sportwagen instanceof Collection;
System.out.println(a);
}
}
Weisen Sie einem Objekt allerdings den Standardwert null zu, z. B. Sportwagen sportwagen = null;, erhalten Sie mit dem Operator instanceof sowohl bei
Sportwagen als auch bei Object false als Ergebnis, da null kein Objekt ist,
sondern ein Literal (vgl. Kapitel 3.1.4).
122
Zeile 1
Zeile 2
Zeile 3
Zeile 4
Zeile 5
Zeile 6
a) Zeile 1
b) Zeile 2
c) Zeile 3
d) Zeile 4
e) Zeile 5
f) Zeile 6
g) Keine dieser Mglichkeiten.
(2) Frage
a) Zeile 1
b) Zeile 2
c) Zeile 3
d) Zeile 4
e) Zeile 5
f) Zeile 6
g) Keine dieser Mglichkeiten.
Zeile 1
Zeile 2
Zeile 3
Zeile 4
Zeile 5
Zeile 6
Zeile 1
Zeile 2
Zeile 3
Zeile 4
Zeile 5
Zeile 6
a) Zeile 1
b) Zeile 2
c) Zeile 3
d) Zeile 4
e) Zeile 5
f) Zeile 6
g) Keine dieser Mglichkeiten.
(4) Frage
a) Zeile 1
b) Zeile 2
c) Zeile 3
Zeile 1
Zeile 2
Zeile 3
Zeile 4
Zeile 5
Zeile 6
123
124
d) Zeile 4
e) Zeile 5
f) Zeile 6
g) Keine dieser Mglichkeiten.
(5) Frage
Zeile 1
Zeile 2
Zeile 3
Zeile 4
Zeile 5
Zeile 6
a) Zeile 1
b) Zeile 2
c) Zeile 3
d) Zeile 4
e) Zeile 5
f) Zeile 6
g) Keine dieser Mglichkeiten.
(6) Frage
Zeile 1
Zeile 2
Zeile 3
Zeile 4
Zeile 5
Zeile 6
a) Zeile 1
b) Zeile 2
c) Zeile 3
d) Zeile 4
e) Zeile 5
f) Zeile 6
g) Keine dieser Mglichkeiten.
(7) Frage
a) Zeile 1
b) Zeile 2
c) Zeile 3
d) Zeile 4
e) Zeile 5
f) Zeile 6
g) Keine dieser Mglichkeiten.
Zeile 1
Zeile 2
Zeile 3
Zeile 4
Zeile 5
Zeile 6
125
126
(8) Frage
Zeile 1
Zeile 2
Zeile 1
Zeile 2
127
(10) Frage
Welches Ergebnis erhlt man, wenn man folgendes Programm kompiliert und
startet?
class A {}
class B extends A{}
class C extends A{
public static void main(String[ ] args){
A a = new A();
B b = new B();
C c = new C();
boolean b1 = a instanceof B;
boolean b2 = a instanceof C;
boolean b3 = c instanceof A;
System.out.println(b1);
System.out.println(b2);
System.out.println(b3);
}
}
Zeile 1
Zeile 2
Zeile 3
Welches Ergebnis erhlt man, wenn man folgendes Programm kompiliert und
startet?
class A {}
class B extends A{}
class C extends A{
public static void main(String[ ] args){
A a = new A();
B b = new B();
C c = new C();
boolean b1 = a instanceof B;
boolean b2 = a instanceof C;
boolean b3 = c instanceof B;
Zeile 1
Zeile 2
Zeile 3
128
Welches Ergebnis erhlt man, wenn man folgendes Programm kompiliert und
startet?
class A {}
class B extends A{}
class C extends A{
public static void main(String[ ] args){
A a = new A();
B b = new B();
C c = new C();
boolean b1 = a instanceof B;
boolean b2 = a instanceof C;
boolean b3 = b instanceof A;
System.out.println(b1);
System.out.println(b2);
System.out.println(b3);
}
}
Zeile 1
Zeile 2
Zeile 3
129
Welches Ergebnis erhlt man, wenn man folgendes Programm kompiliert und
startet?
class A {}
class B extends A{}
class C extends A{
public static void main(String[ ] args){
A a = new A();
B b = new B();
C c = new C();
boolean b1 = a instanceof B;
boolean b2 = a instanceof C;
boolean b3 = c instanceof Object;
Zeile 1
Zeile 2
Zeile 3
System.out.println(b1);
System.out.println(b2);
System.out.println(b3);
}
}
Welches Ergebnis erhlt man, wenn man folgendes Programm kompiliert und
startet?
class A {}
class B extends A{}
class C extends A{
public static void main(String[ ] args){
A a = new A();
B b = new B();
Vakatseite
C c = new C();
boolean b1 = a instanceof B;
boolean b2 = c instanceof C;
boolean b3 = b instanceof A;
Zeile 1
Zeile 2
Zeile 3
System.out.println(b1);
System.out.println(b2);
System.out.println(b3);
}
}
Welches Ergebnis erhlt man, wenn man folgendes Programm kompiliert und startet?
class A {}
class Tisch {}
class B extends A{}
class C extends A{
public static void main(String[ ] args){
A a = new A();
B b = new B();
C c = new C();
boolean b1 = a instanceof B;
boolean b2 = a instanceof Tisch;
boolean b3 = c instanceof A;
System.out.println(b1);
System.out.println(b2);
System.out.println(b3);
}
}
Zeile 1
Zeile 2
Zeile 3
131
Lsungen
(1) Frage
(2) Frage
Sie knnen einem Subtyp keinen Supertyp zuweisen. Also ist b = a nicht
mglich.
(4) Frage
(5) Frage
(6) Frage
Sie knnen einem Subtyp keinen Supertyp zuweisen. Die Lsung d trifft
nicht zu, da es bei dem Versuch ein Elternteil in ein Kind zu casten, zu
einem Laufzeitfehler (ClassCastException) kommt und nicht zu einem
132
(8) Frage
Bei dem Versuch ein Elternteil in ein Kind zu casten, kommt es zu einem Laufzeitfehler, es wird eine ClassCastException geworfen. Der
Kompiler ist nicht in der Lage dies zu bemerken, da ein Elternteil theoretisch ein Kind beinhalten kann, so kommt es zu keinem Kompilierfehler.
(9) Frage
(10) Frage
(11) Frage
(12) Frage
(13) Frage
Alle Objekte sind per Definition Subklassen von java.lang.Object, deswegen hat dieser Vergleich true als Ergebnis. Siehe auch Lsung Aufgabe 10.
133
(14) Frage
(15) Frage
134
135
Operatoren
Wenn Sie zwei Zahlen miteinander addieren wollen, bentigen Sie das Pluszeichen (+). Bei der Multiplikation brauchen Sie das Malzeichen (*). In Programmiersprachen werden diese Zeichen unter dem Oberbegriff Operatoren
zusammengefasst. Will man in einer Programmiersprache Berechnungen
durchfhren, bentigt man Operatoren.
136
4 Operatoren
}
Der Divisionsoperator dividiert zwei Zahlen miteinander. Hierbei ist bei einer
Division mit Ganzzahlen (short, byte, int und long) zu beachten, dass nach
der Division die Nachkommastellen abgeschnitten werden, da eine Zahl vom
Typ int zurckgegeben wird. Dies ist auch der Fall, wenn der Rckgabetyp
ein double ist. Wenn Sie ein Ergebnis haben wollen, das die Nachkommastellen nicht kappt, muss mindestens eine der beiden Zahlen, die miteinander
dividiert werden, eine Kommazahl sein, sprich die Zahl muss in Java als
Fliekommazahl dargestellt werden. Dies wre entweder eine Zahl vom Datentyp double (10.0 oder 10.0d) oder float (10.f). Werden unterschiedliche
Datentypen verwendet, findet eine implizite, sprich automatische, Typanpassung statt, es wird die krzere Zahl in die lngere umgewandelt. So wird bei
double d = 10.0/3, die Zahl 3, die vom primitiven Datentyp int ist, an den greren Datentyp double der Zahl 10.0 angepasst. Anschlieend wird eine
Zahl durch die andere geteilt.
public class Division {
public static void main(String[ ] args) {
int a = 10/3;
double b = 10/3;
double c = 10.0/3.0;
double d = 10.0/3;
System.out.println(Ganzzahldivision + a);
System.out.println(Ganzzahldivision + b);
System.out.println(Division von Fliekommazahlen + c);
System.out.println(Division von Fliekommazahlen + d);
}
}
4.1
Arithmetische Operatoren
137
138
4 Operatoren
die gleiche Prioritt, werden sie in der Reihenfolge von links nach rechts abgearbeitet. Die Bearbeitungsreihenfolge kann man, wie in der Mathematik,
mit Klammern beeinflussen, was man zur besseren Lesbarkeit auch tun
sollte.
Operatoren
Prioritt Typ
Beschreibung
++, -+, ~
!
(Typ)
*, /, %
+, +
<<
>>
>>>
<, <=, >, >=
instanceof
==, !=
==, !=
&
&
^
^
|
|
&&
||
?:
=
*=, /=, %=, +=, -=,
<<=, >>=, >>>=,
&=, ^=, |=
1
1
1
1
1
2
3
3
4
4
4
5
5
6
6
7
7
8
8
9
9
10
11
12
13
14
arithmetisch
arithmetisch
integral
boolean
jedes
arithmetisch
arithmetisch
String
integral
integral
integral
arithmetisch
Objekt
primitiv
Objekt
integral
boolean
integral
boolean
integral
boolean
boolean
boolean
alles
jede
jede
Fr die Zertifizierung ist es ntzlich, Folgendes zu verinnerlichen: Der Grundsatz Punkt vor Strich ist verbindlich. Die Operatoren Modulo % und
Multiplikation * haben die gleiche Prioritt, was zur Folge hat, dass die Operatoren von links nach rechts bercksichtigt werden.
4.1
Arithmetische Operatoren
139
140
4 Operatoren
Welches Ergebnis erhlt man, wenn man folgendes Programm kompiliert und
startet?
public class P {
public static void main(String[ ] args) {
System.out.println(1 * 2 % 3 + 4);
System.out.println(1 + 2 + 3 * 4);
}
}
a) 6 15
b) 6 24
c) 7 15
d) Kompilierfehler
e) Keine dieser Mglichkeiten.
(2) Frage
Welches Ergebnis erhlt man, wenn man folgendes Programm kompiliert und
startet?
a) 19 13
4.1
Arithmetische Operatoren
141
public class P {
public static void main(String[ ] args) {
System.out.println(5 * 2 % 3 + 4);
System.out.println(5 % 2 + 3 * 4);
}
}
b) 5 16
c) 5 13
d) Kompilierfehler
e) Keine dieser Mglichkeiten.
(3) Frage
Welches Ergebnis erhlt man, wenn man folgendes Programm kompiliert und
startet?
public class P {
public static void main(String[ ] args) {
System.out.println(15 * 5 % 3 + 6);
System.out.println(15 % 5 + 3 * 6);
}
}
a) 6 18
b) 36 18
c) 6 30
d) Kompilierfehler
e) Keine dieser Mglichkeiten.
(4) Frage
Welches Ergebnis erhlt man, wenn man folgendes Programm kompiliert und
startet?
public class D {
public static void main(String[ ] args) {
System.out.println(-8 % 3);
System.out.println(8 * -3);
System.out.println(-8 % -3);
}
}
a) -2 2 -2
142
4 Operatoren
b) -2 -2 -2
c) -2 -24 -2
d) Kompilierfehler
e) Keine dieser Mglichkeiten.
(5) Frage
Welches Ergebnis erhlt man, wenn man folgendes Programm kompiliert und
startet?
public class D {
public static void main(String[ ] args) {
System.out.println(-8 % 3);
System.out.println(8 % -3);
System.out.println(-8 % -3);
}
}
a) -2 2 -2
b) -2 -2 -2
c) -2 -24 -2
d) Kompilierfehler
e) Keine dieser Mglichkeiten.
(6) Frage
Welches Ergebnis erhlt man, wenn man folgendes Programm kompiliert und
startet?
public class D {
public static void main(String[ ] args) {
System.out.println(-8 % 3);
System.out.println(8 / -3);
System.out.println(-8 % -3);
}
}
a) -2 2 -2
b) -2 -2 -2
c) -2 -24 -2
d) Kompilierfehler
e) Keine dieser Mglichkeiten.
4.1
Arithmetische Operatoren
143
(7) Frage
Welches Ergebnis erhlt man, wenn man folgendes Programm kompiliert und
startet?
public class D {
public static void main(String[ ] args) {
System.out.println(-9.0 / 2.0);
System.out.println(10.0 / -2.0);
System.out.println(-7.0 / -4.0);
}
}
Welches Ergebnis erhlt man, wenn man folgendes Programm kompiliert und
startet?
public class D {
public static void main(String[ ] args) {
System.out.println(-9 / 2);
System.out.println(10 / -2);
System.out.println(-7 / -4);
}
}
144
4 Operatoren
(9) Frage
Welches Ergebnis erhlt man, wenn man folgendes Programm kompiliert und
startet?
public class O {
public static void main(String[ ] args) {
short i = 5;
i += 2;
System.out.println(i);
}
}
a) 5
b) 7
c) Kompilierfehler
(10) Frage
Welches Ergebnis erhlt man, wenn man folgendes Programm kompiliert und
startet?
public class O {
public static void main(String[ ] args) {
short i = 5;
i = i + 2;
System.out.println(i);
}
}
a) 5
b) 7
c) Kompilierfehler
(11) Frage
Welches Ergebnis erhlt man, wenn man folgendes Programm kompiliert und
startet?
public class O {
public static void main(String[ ] args) {
int i = 5;
i = i + 2;
System.out.println(i);
}
}
a) 5
4.1
Arithmetische Operatoren
145
b) 7
c) Kompilierfehler
(12) Frage
Welches Ergebnis erhlt man, wenn man folgendes Programm kompiliert und
startet?
public class D {
public static void main(String[ ] args) {
System.out.println(-7 % 2);
System.out.println(7 % -2);
System.out.println(7 % -4);
}
}
a) -1 1 3
b) 1 -1 -3
c) -3 -3 -1
d) Kompilierfehler
e) Keine dieser Mglichkeiten.
(13) Frage
Welches Ergebnis erhlt man, wenn man folgendes Programm kompiliert und
startet?
public class D {
public static void main(String[ ] args) {
System.out.println(-7 / 2);
System.out.println(7 / -2);
System.out.println(7 / -4);
}
}
a) -1 1 3
b) 1 -1 -3
c) -3 -3 -1
d) Kompilierfehler
e) Keine dieser Mglichkeiten.
146
4 Operatoren
(14) Frage
Welches Ergebnis erhlt man, wenn man folgendes Programm kompiliert und
startet?
public class D {
public static void main(String[ ] args) {
System.out.println(-7.0 / 2.0);
System.out.println(7.0 / -2.0);
System.out.println(7.0 / -4.0);
}
}
Lsungen
(1) Frage
(2) Frage
(3) Frage
(4) Frage
(5) Frage
4.1
Arithmetische Operatoren
147
(6) Frage
Siehe Lsung Aufgabe 4. Bei der Division von Ganzzahlen, hier vom
Typ int, ist zustzlich zu beachten, dass nach der Division die Nachkommastellen abgeschnitten werden, deshalb erhalten Sie bei 8/-3 die
Zahl -2 als Ergebnis. Eine Ganzzahl ist standardmig vom Typ int.
Siehe auch Kapitel 4.1.2.
(7) Frage
Werden zwei Fliekommazahlen, hier vom Typ double, miteinander dividiert, erhalten Sie als Ergebnis wieder eine Fliekommazahl (vgl. Kapitel 4.1.2). Eine Fliekommazahl ist standardmig vom Typ double,
es sei denn, es steht ein f dahinter, wie z. B. 10.0f, dann ist sie vom Typ
float (siehe auch Kapitel 2.5 Primitive Datentypen und Variablendeklaration ab Seite 37).
(8) Frage
Bei der Division von Ganzzahlen, hier vom Typ int, ist zu beachten,
dass nach der Division die Nachkommastellen abgeschnitten werden.
(9) Frage
(10) Frage
Hier wre ein expliziter Cast notwendig, da kein impliziter zu dem Datentyp short stattfindet. Es kommt bei i = i + 2 zu einem Kompilierfehler,
da der Wert short i durch den Additions-Operator automatisch in eine
Zahl vom Typ int berfhrt wird, somit ist der Rckgabetyp short zu
klein.
(11) Frage
Hier ist der Rckgabetyp int der richtige, deswegen kommt es zur Ausgabe von 7 und nicht zu einem Kompilierfehler.
(12) Frage
(13) Frage
148
4 Operatoren
(14) Frage
149
150
4 Operatoren
Welches Ergebnis erhlt man, wenn man folgendes Programm kompiliert und
startet?
public class L {
public static void main(String[ ] args) {
boolean a = true;
boolean b = false;
boolean c = false;
boolean d = false;
System.out.println(a | b);
System.out.println(b ^ c);
System.out.println(c & d);
}}
151
Welches Ergebnis erhlt man, wenn man folgendes Programm kompiliert und
startet?
public class L {
public static void main(String[ ] args) {
boolean a = true;
boolean b = false;
boolean c = false;
boolean d = false;
System.out.println(a | b);
System.out.println(b | c);
System.out.println(c | d);
}}
Welches Ergebnis erhlt man, wenn man folgendes Programm kompiliert und
startet?
public class L {
public static void main(String[ ] args) {
boolean a = true;
boolean b = false;
boolean c = false;
boolean d = false;
System.out.println(a ^ b);
System.out.println(b ^ c);
System.out.println(c ^ d);
}
}
152
4 Operatoren
Welches Ergebnis erhlt man, wenn man folgendes Programm kompiliert und
startet?
public class L {
public static void main(String[ ] args) {
boolean a = true;
boolean b = false;
boolean c = false;
boolean d = false;
System.out.println(a & b);
System.out.println(b & c);
System.out.println(c & d);
}
}
Welches Ergebnis erhlt man, wenn man folgendes Programm kompiliert und
startet?
public class L {
public static void main(String[ ] args) {
boolean a = false;
boolean b = false;
boolean c = true;
boolean d = true;
System.out.println(a & b);
153
Welches Ergebnis erhlt man, wenn man folgendes Programm kompiliert und
startet?
public class L {
public static void main(String[ ] args) {
boolean a = false;
boolean b = false;
boolean c = true;
boolean d = true;
System.out.println(a ^ b);
System.out.println(b ^ c);
System.out.println(c ^ d);
}}
154
4 Operatoren
(7) Frage
Welches Ergebnis erhlt man, wenn man folgendes Programm kompiliert und
startet?
public class L {
public static void main(String[ ] args) {
boolean a = false;
boolean b = false;
boolean c = true;
boolean d = true;
System.out.println(a | b);
System.out.println(b | c);
System.out.println(c | d);
}
}
Welches Ergebnis erhlt man, wenn man folgendes Programm kompiliert und
startet?
public class L {
public static void main(String[ ] args) {
boolean a = false;
boolean b = false;
boolean c = true;
System.out.println(a | b & c ^ a);
}
}
a) true
b) false
155
(9) Frage
Welches Ergebnis erhlt man, wenn man folgendes Programm kompiliert und
startet?
public class L {
public static void main(String[ ] args) {
boolean a = false;
boolean b = false;
boolean c = true;
System.out.println(a & b & c ^ a);
}
}
a) true
b) false
(10) Frage
Welches Ergebnis erhlt man, wenn man folgendes Programm kompiliert und
startet?
public class L {
public static void main(String[ ] args) {
boolean a = false;
boolean b = false;
boolean c = true;
System.out.println(a | b | c ^ a);
}
}
a) true
b) false
Lsungen
(1) Frage
b,
Werden zwei Boolean-Werte mit dem logischen And-Operator in Beziehung gesetzt, erhlt man nur true, wenn beide Operanten true sind.
Wenn mindestens einer von zwei Operanten true ist, gibt der logische
Or-Operator als Resultat true auf der Konsole aus. Der logische XOROperator hat als Ergebnis nur true, wenn einer von beiden Operatoren
true ist. Es darf also nur einer true sein, sind beide true oder beide false,
wird false zurckgegeben.
156
4 Operatoren
(2) Frage
Wenn mindestens einer von zwei Operanten true ist, gibt der logische
Or-Operator als Resultat true auf der Konsole aus.
(3) Frage
Der logische XOR-Operator hat als Ergebnis nur true, wenn einer von
beiden Operatoren true ist. Es darf also nur einer true sein, sind beide
true oder beide false, wird false zurckgegeben.
(4) Frage
Werden zwei Boolean-Werte mit dem logischen And-Operator in Beziehung gesetzt, erhlt man nur true, wenn beide Operanten true sind.
(5) Frage
(6) Frage
(7) Frage
(8) Frage
Es gilt wie bei allen Operatoren, dass sie zuerst nach Prioritten abgearbeitet werden und anschlieend bei Operatoren mit gleicher Prioritt
von links nach rechts (siehe Kapitel 4.1.4). Es wird zuerst &, dann ^ und
dann | durchgefhrt.
(9) Frage
(10) Frage
4.2.7 Short-Circuit-Auswertung
Es gibt zwei weitere logische Operatoren: && und ||. Bei && kommt nur true
als Ergebnis heraus, wenn beide Operanten true sind. Bei der Auswertung
mit || gengt es, wenn einer von zwei Operanten true ist, damit das Resultat
true ist. Soweit entspricht es dem Verhalten von & und |, nun gibt es aber ei-
157
Wenn hingegen, wenn || durch | ersetzt wird, werden sofort beide Seiten ausgewertet. Somit wird die for-Schleife nur ein einziges Mal ausgefhrt.
public class ShortCircuit {
public static void main(String[] args) {
int a = 0;
int b = 0;
for (int i = 0; i < 5; i++) {
if(++a < 2 | ++b < 2 ) {
System.out.println(a + + b);
}
}
158
4 Operatoren
}
Welches Ergebnis erhlt man, wenn man folgendes Programm kompiliert und
startet?
public class S {
public static void main(String[ ] args) {
int a = 1;
int b = 1;
for (int i = 0; i<5; i++){
if(++a <3 || ++b <3){
System.out.println(a + + b);
}
}
}
}
a) 2 2
b) 2 1 3 2
(2) Frage
Welches Ergebnis erhlt man, wenn man folgendes Programm kompiliert und
startet?
public class S {
public static void main(String[ ] args) {
int a = 1;
int b = 1;
for (int i = 0; i<5; i++){
if(++a <3 | ++b <3){
System.out.println(a + + b);
}
}
}
}
a) 2 2
b) 2 1 3 2
159
(3) Frage
Welches Ergebnis erhlt man, wenn man folgendes Programm kompiliert und
startet?
public class S {
public static void main(String[ ] args) {
int a = 1;
int b = 1;
for (int i = 0; i<5; i++){
if(++a <3 && ++b <3){
System.out.println(a + + b);
}
}
}
}
a) 2 2
b) 2 1 3 2
(4) Frage
Welches Ergebnis erhlt man, wenn man folgendes Programm kompiliert und
startet?
public class S {
public static void main(String[ ] args) {
int a = 0;
int b = 0;
for (int i = 0; i<5; i++){
if(++a <2 || ++b <3){
System.out.println(a + + b);
}
}
}
}
a) 1 0 2 1 3 2
b) 1 1 2 2
c) 1 1
(5) Frage
Welches Ergebnis erhlt man, wenn man folgendes Programm kompiliert und
startet?
public class S {
public static void main(String[ ] args) {
int a = 0;
160
4 Operatoren
int b = 0;
for (int i = 0; i<5; i++){
if(++a <2 | ++b <3){
System.out.println(a + + b);
}
}
}
a) 1 0 2 1 3 2
b) 1 1 2 2
c) 1 1
(6) Frage
Welches Ergebnis erhlt man, wenn man folgendes Programm kompiliert und
startet?
public class S {
public static void main(String[ ] args) {
int a = 0;
int b = 0;
for (int i = 0; i<5; i++){
if(++a <2 && ++b <3){
System.out.println(a + + b);
}
}
}
}
a) 1 0 2 1 3 2
b) 1 1 2 2
c) 1 1
Lsungen
(1) Frage
Bei dem Operator || wird der Ausdruck auf der rechten Seite ++b erst
ausgefhrt, wenn ++a < 3 auf der linken Seite false wird, also nachdem
die for-Schleife zweimal durchlaufen wurde. Achtung: Die Variablen a
und b wurden mit 1 und nicht mit 0 initialisiert.
4.3
161
(2) Frage
Bei dem Operator | werden sofort beide Seiten ausgewertet und somit
wird die for-Schleife nur einmal durchlaufen.
(3) Frage
Bei dem Operator && wird der Ausdruck auf der rechten Seite ++b nicht
mehr ausgefhrt, wenn ++a < 3 auf der linken Seite false wird, also
nachdem die for-Schleife einmal durchlaufen wurde.
(4) Frage
Bei dem Operator || wird der Ausdruck auf der rechten Seite ++b erst
ausgefhrt, wenn ++a < 2 auf der linken Seite false wird, also nachdem
die for-Schleife zweimal durchlaufen wurde. Der Gesamtausdruck wird
aber erst nach dem dritten Durchlauf false, so wird die for-Schleife dreimal durchlaufen. Achtung: Die Variablen a und b wurden mit 0 initialisiert.
(5) Frage
Bei dem Operator | werden sofort beide Seiten ausgewertet und somit
wird die for-Schleife nur zweimal durchlaufen.
(6) Frage
Bei dem Operator && wird der Ausdruck auf der rechten Seite ++b nicht
mehr ausgefhrt, wenn ++a < 2 auf der linken Seite false wird, also
nachdem die for-Schleife einmal durchlaufen wurde.
4.3 Die Operatoren Inkrement ++ und Dekrement -Bei der Inkrement-Funktion ++i wird i jeweils um 1 erhht und bedeutet somit
das gleiche wie i= i + 1, wohingegen die Dekrement-Funktion --i i jeweils um
1 reduziert. Es gibt nun zwei Mglichkeiten: Man kann das ++ vor i schreiben
oder nach i, also entweder ++i (Prinkrement) oder i++ (Postinkrement). Bei
++i wird i vor der Addition, um 1 erhht, wohingegen bei i++ i erst danach um
1 erhht wird. Nun ein praktisches Beispiel: In unten stehendem Fall wird k
mit dem Wert 10 zu i addiert (10 + 11), somit ist das Ergebnis 21. Die Variable
i ist also bereits vor der Berechnung von 10 auf 11 erhht worden. Nachdem
die beiden Zahlen zusammengezhlt worden sind, wird der Wert von k um 1
erhht und k hat jetzt den Wert 11.
public class IncrDecre {
public static void main(String[ ] args){
int i = 10;
162
4 Operatoren
int k = 10;
int l = ++i + k++;
//i wird hochgezhlt vor der Berechnung
System.out.println(i);
//k wird hochgezhlt nach der Berechnung
System.out.println(k);
//es wird i = 11 und k = 10 zusammengezhlt
System.out.println(l);
}
In unten stehender Klasse IncreDecre wird vor der Berechnung zuerst ++i
von 12 auf 13 gesetzt, k++ wird nicht verndert und bleibt bei dem Wert 12
und i++ behlt den Wert 13. Diese Zahlen werden addiert und das Ergebnis
ist 38 (13 + 12 + 13 = 38). Nachdem diese Werte zusammengezhlt wurden,
wird i von 13 auf 14 und k von 12 auf 13 hochgezhlt. So haben die Variablen
zum Schluss bei der Ausgabe folgende Werte: i = 14, k = 13 und l = 38.
public class IncrDecre {
public static void main(String[ ] args){
int i = 12;
int k = 12;
//38 = 13 + 12 + 13
int l = ++i + k++ + i++;
System.out.println(i);
System.out.println(k);
System.out.println(l);
}
}
4.3
163
Welches Ergebnis erhlt man, wenn man folgendes Programm kompiliert und
startet?
public class L{
public static void main(String[ ] args){
int i = 1;
int k = 1;
int l = i++ + k++;
System.out.println(i);
System.out.println(k);
System.out.println(l);}}
a) 2 2 4
b) 1 1 2
c) 2 2 2
d) 1 2 3
e) 2 2 3
f) Kompilierfehler
g) Keine dieser Mglichkeiten.
(2) Frage
Welches Ergebnis erhlt man, wenn man folgendes Programm kompiliert und
startet?
public class L{
public static void main(String[ ] args){
int i = 1;
int k = 1;
int l = i++ + ++k;
System.out.println(i);
System.out.println(k);
System.out.println(l);}
}
a) 2 2 4
b) 1 1 2
c) 2 2 2
d) 1 2 3
164
4 Operatoren
e) 2 2 3
f) Kompilierfehler
g) Keine dieser Mglichkeiten.
(3) Frage
Welches Ergebnis erhlt man, wenn man folgendes Programm kompiliert und
startet?
public class L{
public static void main(String[ ] args){
int i = 1;
int k = 1;
int l = ++i + k++;
System.out.println(i);
System.out.println(k);
System.out.println(l);
}}
a) 2 2 4
b) 1 1 2
c) 2 2 2
d) 1 2 3
e) 2 2 3
f) Kompilierfehler
g) Keine dieser Mglichkeiten.
(4) Frage
Welches Ergebnis erhlt man, wenn man folgendes Programm kompiliert und
startet?
public class L{
public static void main(String[ ] args){
int i = 1;
int k = 1;
int l = ++i + ++k;
System.out.println(i);
System.out.println(k);
System.out.println(l);}}
a) 2 2 4
b) 1 1 2
4.3
165
c) 2 2 2
d) 1 2 3
e) 2 2 3
f) Kompilierfehler
g) Keine dieser Mglichkeiten.
(5) Frage
Welches Ergebnis erhlt man, wenn man folgendes Programm kompiliert und
startet?
public class L{
public static void main(String[ ] args){
int i = 5;
int k = 3;
int l = ++i + ++k + i++;
System.out.println(i);
System.out.println(k);
System.out.println(l);
}}
a) 7 4 16
b) 6 3 14
c) 6 3 15
d) 7 4 15
e) Kompilierfehler
f) Keine dieser Mglichkeiten.
(6) Frage
Welches Ergebnis erhlt man, wenn man folgendes Programm kompiliert und
startet?
public class L{
public static void main(String[ ] args){
int i = 5;
int k = 3;
int l = ++i + k++ + i++;
System.out.println(i);
System.out.println(k);
System.out.println(l);
}
}
166
4 Operatoren
a) 7 4 16
b) 6 3 14
c) 6 3 15
d) 7 4 15
e) Kompilierfehler
f) Keine dieser Mglichkeiten.
(7) Frage
Welches Ergebnis erhlt man, wenn man folgendes Programm kompiliert und
startet?
public class L{
public static void main(String[ ] args){
int i = 5;
int k = 3;
int l = i++ + ++k + i++;
System.out.println(i);
System.out.println(k);
System.out.println(l);
}
}
a) 7 4 16
b) 6 3 14
c) 6 3 15
d) 7 4 15
e) Kompilierfehler
f) Keine dieser Mglichkeiten.
(8) Frage
Welches Ergebnis erhlt man, wenn man folgendes Programm kompiliert und
startet?
public class L {
public static void main(String[ ] args){
int k = 6;
int i = 6;
int l = ++i + k++;
System.out.println(i);
System.out.println(k);}
}
4.3
167
a) 6 6
b) 6 7
c) 7 6
d) 7 7
e) Kompilierfehler
f) Keine dieser Mglichkeiten.
(9) Frage
Welches Ergebnis erhlt man, wenn man folgendes Programm kompiliert und
startet?
public class L {
public static void main(String[ ] args){
int k = 6;
int i = 6;
int l = i++ + k++;
System.out.println(i);
System.out.println(k); }}
a) 6 6
b) 6 7
c) 7 6
d) 7 7
e) Kompilierfehler
f) Keine dieser Mglichkeiten.
(10) Frage
Welches Ergebnis erhlt man, wenn man folgendes Programm kompiliert und
startet?
public class L {
public static void main(String[ ] args){
int k = 6;
int i = 6;
int l = ++i + k++;
System.out.println(i);
System.out.println(l);
}
}
a) 6 12
168
4 Operatoren
b) 6 13
c) 7 13
d) 7 14
e) Kompilierfehler
f) Keine dieser Mglichkeiten.
Lsungen
(1) Frage
(2) Frage
(3) Frage
(4) Frage
Prinkrement (++ vor der Variablen) wird vor der Berechnung hochgezhlt und Postinkrement (++ nach der Variablen) wird nach der Berechung um 1 erhht.
(5) Frage
(6) Frage
(7) Frage
(8) Frage
169
(9) Frage
(10) Frage
0
+ 0 * 22
+0
0
+ 0 * 21
+0
1
+ 1 * 20
+1
=1
170
4 Operatoren
0
+ 0 * 22
+0
1
+ 1 * 21
+2
0
+ 0 * 20
+0
=2
0
+ 0 * 20
+0
=4
0
+ 0 * 20
+0
=8
1
+ 1 * 22
+4
0
+ 0 * 21
+0
0
+ 0 * 22
+0
0
+ 0 * 21
+0
Unten stehende Aufstellung hat als berschrift die Ergebnisse der Hochzahlen 20 bis 26. Diese sollen es Ihnen erleichtern, Zahlen vom dezimalen in das
binre System und umgekehrt umzurechnen. Die dezimale Zahl 32 lsst sich
durch 1 * 32 + 0 * 16 + 0 * 8 + 0 * 4 + 0 * 2 + 0 *1 darstellen, somit ist die dazugehrige binre Zahl 0010 0000 (binre Zahlen werden immer in ViererBlcken wiedergegeben und werden von links mit Nullen aufgefllt). 33 lsst
sich durch 1 * 32 + 0 * 16 + 0 * 8 + 0 * 4 + 0 * 2 + 1 * 1 errechnen und betrgt
0010 0001. Bei den Zahlen 20, 66 und 97 wird entsprechend vorgegangen.
26 = 64
25 = 32
24 = 16
23 = 8
22 = 4
21 = 2
20 = 1
1 * 32
= 32
32 + 1
= 33
16 + 4
= 20
26 = 64
25 = 32
24 = 16
23 = 8
22 = 4
21 = 2
20 = 1
64 + 2
= 66
64 + 32 + 2
= 97
b) Oktales Zahlensystem
Oktale Zahlen, d. h. Zahlen zur Basis 8, knnen auch in dezimale Zahlen umgewandelt werden, wobei die Zahlen auf zwei Arten dargestellt werden knn-
171
en: 0132 oder 1328. Das oktale Zahlensystem umfasst lediglich die Ziffern 0,
1, 2, 3, 4, 5, 6, 7, sprich es gibt die Zahlen 8 und 9 nicht.
(1) Umrechnungsbeispiel von oktal nach dezimal
3
+ 3 * 81
+ 24
2
+ 2 * 80
+2
= 90
82 = 64
81 = 8
80 = 1
8+2*1
= 10
2 * 64
= 128
512 + 8
= 520
3 * 64 + 8 + 1
= 201
2
1
c) Hexadezimales Zahlensystem
Nun wollen wir noch Zahlen in das hexadezimale Zahlensystem umrechnen:
Hexadezimale Zahlen, d. h. Zahlen zur Basis 16, werden wie folgt geschrieben: 0x12a oder 12a16. Die Zahlen gehen von 0, 1, 2, 3, 4, 5, 6, 7, 8, 9, a, b,
c, d, e und f, wobei a fr 10, b fr 11, c fr 12, d fr 13, e fr 14 und f fr 15
steht.
(1) Umrechnungsbeispiel von hexadezimal nach dezimal
2
+ 2 * 161
+ 32
a
+ a * 160
+ 10
= 298
172
4 Operatoren
162 = 256
161 = 16
160 = 1
256 + 32 + 10
= 298
1024 + 1
= 1025
256 + 16 + 11
= 283
1024 + 15
= 1039
d) Aufstellungen Zahlensysteme
Hier eine Art Umrechnungstabelle zwischen den verschiedenen Zahlensystemen:
Dezimale Zahlen
Binre Zahlen
Oktale Zahlen
Hexadezimale Zahlen
0
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
0000
0001
0010
0011
0100
0101
0110
0111
1000
1001
1010
1011
1100
1101
1110
1111
10000
0
1
2
3
4
5
6
7
10
11
12
13
14
15
16
17
20
0
1
2
3
4
5
6
7
8
9
a
b
c
d
e
f
10
Da eine Zahl vom Datentyp int 32 mgliche Bits hat, hier noch einige ausgewhlte Umrechnungsbeispiele mit 32 Bit. Hierbei ist zu beachten, dass nur
die linken Einsen und nicht die Nullen der binren Zahlen auf dem Bildschirm
ausgegeben werden. Die linken Nullen stehen hier nur, um das Ergebnis
besser veranschaulichen zu knnen.
Dezimale
Zahlen
Binre Zahlen
Hexadezimale Zahlen
0
1
0x0
0x1
173
Dezimale
Zahlen
Binre Zahlen
Hexadezimale Zahlen
2
15
31
-1
-2
-3
-4
-9
0x2
0xf
0x1f
0xffffffff
0xfffffffe
0xfffffffd
0xfffffffc
0xfffffff7
Rechnen Sie bitte 1012 in eine dezimale Zahl um. Welches Ergebnis erhalten
Sie?
a) 5
b) 65
c) 257
d) Keine dieser Mglichkeiten.
(2) Frage
Rechnen Sie bitte 1018 in eine dezimale Zahl um. Welches Ergebnis erhalten
Sie?
a) 5
b) 65
c) 257
d) Keine dieser Mglichkeiten.
(3) Frage
Rechnen Sie bitte 10116 in eine dezimale Zahl um. Welches Ergebnis erhalten Sie?
a) 5
b) 65
c) 257
d) Keine dieser Mglichkeiten.
174
4 Operatoren
(4) Frage
Rechnen Sie bitte 0x4e in eine dezimale Zahl um. Welches Ergebnis erhalten
Sie?
a) 31
b) 30
c) 40
d) Keine dieser Mglichkeiten.
(5) Frage
Rechnen Sie bitte 0x3f in eine dezimale Zahl um. Welches Ergebnis erhalten
Sie?
a) 64
b) 62
c) 63
d) Keine dieser Mglichkeiten.
(6) Frage
Rechnen Sie bitte 013 in eine dezimale Zahl um. Welches Ergebnis erhalten
Sie?
a) 12
b) 13
c) 11
d) Keine dieser Mglichkeiten.
(7) Frage
Rechnen Sie bitte 0x44 in eine dezimale Zahl um. Welches Ergebnis erhalten
Sie?
a) 36
b) 68
c) 69
d) Keine dieser Mglichkeiten.
(8) Frage
Rechnen Sie bitte 044 in eine dezimale Zahl um. Welches Ergebnis erhalten
Sie?
175
a) 36
b) 68
c) 69
d) Keine dieser Mglichkeiten.
(9) Frage
Rechnen Sie bitte 10112 in eine dezimale Zahl um. Welches Ergebnis erhalten Sie?
a) 11
b) 10
c) 12
d) Keine dieser Mglichkeiten.
(10) Frage
Rechnen Sie bitte 110012 in eine dezimale Zahl um. Welches Ergebnis erhalten Sie?
a) 24
b) 23
c) 25
d) Keine dieser Mglichkeiten.
(11) Frage
Rechnen Sie bitte 1000002 in eine dezimale Zahl um. Welches Ergebnis erhalten Sie?
a) 31
b) 30
c) 32
d) Keine dieser Mglichkeiten.
(12) Frage
Rechnen Sie bitte 1112 in eine dezimale Zahl um. Welches Ergebnis erhalten
Sie?
a) 6
b) 7
176
4 Operatoren
c) 8
d) Keine dieser Mglichkeiten.
(13) Frage
Rechnen Sie bitte 02 in eine dezimale Zahl um. Welches Ergebnis erhalten
Sie?
a) 2
b) 3
c) 4
d) Keine dieser Mglichkeiten.
(14) Frage
Rechnen Sie bitte 0x2 in eine dezimale Zahl um. Welches Ergebnis erhalten
Sie?
a) 2
b) 3
c) 4
d) Keine dieser Mglichkeiten.
(15) Frage
Rechnen Sie bitte 0x22 in eine dezimale Zahl um. Welches Ergebnis erhalten
Sie?
a) 32
b) 33
c) 34
d) Keine dieser Mglichkeiten.
(16) Frage
Rechnen Sie bitte 0x202 in eine dezimale Zahl um. Welches Ergebnis erhalten Sie?
a) 130
b) 514
c) 258
d) Keine dieser Mglichkeiten.
177
(17) Frage
Rechnen Sie bitte 0202 in eine dezimale Zahl um. Welches Ergebnis erhalten
Sie?
a) 130
b) 514
c) 258
d) Keine dieser Mglichkeiten.
(18) Frage
Rechnen Sie bitte 1111 in eine dezimale Zahl um. Welches Ergebnis erhalten
Sie?
a) 15
b) 14
c) 16
d) Keine dieser Mglichkeiten.
(19) Frage
Rechnen Sie bitte 11111 in eine dezimale Zahl um. Welches Ergebnis erhalten Sie?
a) 30
b) 31
c) 32
d) Keine dieser Mglichkeiten.
(20) Frage
Rechnen Sie bitte 111000 in eine dezimale Zahl um. Welches Ergebnis erhalten Sie?
a) 58
b) 56
c) 57
d) Keine dieser Mglichkeiten.
178
4 Operatoren
Lsungen
(1) Frage
Bei dieser Umrechnung kann Ihnen unten stehende Umrechnungstabelle von groem Nutzen sein, da es sich um eine Binrzahl handelt:
26 = 64
25 = 32
24 = 16
23 = 8
22 = 4
21 = 2
20 = 1
1+4
=5
(2) Frage
83 = 512
82 = 64
81 = 8
80 = 1
1 + 64
= 65
(3) Frage
163 = 1024
162 = 256
161 = 16
160 = 1
1 + 256
= 257
(4) Frage
163 = 1024
162 = 256
161 = 16
160 = 1
14 + 64
= 78
(5) Frage
163 = 1024
162 = 256
161 = 16
160 = 1
15 + 48
= 63
179
(6) Frage
83 = 512
82 = 64
81 = 8
80 = 1
3+8
= 11
(7) Frage
Es handelt sich um eine Hexadezimalzahl, gehen Sie analog wie in Aufgabe 5 vor.
(8) Frage
044 ist eine Oktalzahl, verwenden Sie bei der Umrechnung die gleiche
Tabelle wie in Frage 6.
(9) Frage
10112 ist eine Binrzahl, gehen Sie analog wie in Frage 1 vor.
(10) Frage
Bei 110012 handelt sich um eine Binrzahl, verwenden Sie bitte die
Umrechnungstabelle aus Frage 1.
(11) Frage
(12) Frage
1112 ist eine Binrzahl, gehen Sie analog wie in Frage 1 vor.
(13) Frage
02 ist eine Oktalzahl, verwenden Sie bitte die Tabelle aus Frage 6.
(14) Frage
Bei 0x2 handelt sich um eine Hexadezimalzahl, gehen Sie analog wie
in Aufgabe 5 vor.
(15) Frage
Bei 0x22 handelt sich um eine Hexadezimalzahl, nehmen Sie bitte die
Tabelle aus Aufgabe 5.
180
4 Operatoren
(16) Frage
(17) Frage
0202 ist eine Oktalzahl, verwenden Sie bei der Umrechnung die gleiche
Tabelle wie in Frage 6.
(18) Frage
Da es sich um eine Binrzahl handelt, nehmen Sie bitte die Umrechnungstabelle aus Aufgabe 1.
(19) Frage
11111 ist eine Binrzahl, fr deren Umrechnung Sie bitte die Tabelle
aus Aufgabe 1 nehmen.
(20) Frage
181
6
-7
Nun denken Sie sicherlich, dass dies furchtbar kompliziert ist. Es gibt aber
eine sehr einfache Methode, viel schneller zum Ergebnis zu kommen. Fr
den Not-Operator gilt ~x == -x -1, was immer zutrifft und das Kippen der
Bits fr eine Berechnung des Ergebnisses entbehrlich macht. Wenden Sie
diese Formel an, so erhalten Sie das Ergebnis 7 (~x == -6 1).
182
4 Operatoren
Welches Ergebnis erhlt man, wenn man folgendes Programm kompiliert und
startet?
public class B {
public static void main(String[ ] args) {
int i = 13;
int b = 12;
System.out.println(i^b);
}
}
a) 1
b) 13
c) 12
d) Keine dieser Mglichkeiten
183
(2) Frage
Welches Ergebnis erhlt man, wenn man folgendes Programm kompiliert und
startet?
public class B {
public static void main(String[ ] args) {
int i = 13;
int b = 12;
System.out.println(i | b);
}
}
a) 1
b) 13
c) 12
d) Keine dieser Mglichkeiten
(3) Frage
Welches Ergebnis erhlt man, wenn man folgendes Programm kompiliert und
startet?
public class B {
public static void main(String[ ] args) {
int i = 13;
int b = 12;
System.out.println(i & b);
}
}
a) 1
b) 13
c) 12
d) Keine dieser Mglichkeiten
(4) Frage
Welches Ergebnis erhlt man, wenn man folgendes Programm kompiliert und
startet?
public class B {
public static void main(String[ ] args) {
int i = 20;
int b = 37;
184
4 Operatoren
System.out.println(i & b);
}
a) 4
b) 20
c) 5
d) 37
e) Keine dieser Mglichkeiten
(5) Frage
Welches Ergebnis erhlt man, wenn man folgendes Programm kompiliert und
startet?
public class BitweiseOperatoren {
public static void main(String[ ] args) {
int i = 20;
int b = 37;
System.out.println(~i);
System.out.println(~b);
}
}
a) 21 38
b) 20 37
c) 21 38
d) 20 38
e) Keine dieser Mglichkeiten.
(6) Frage
Welches Ergebnis erhlt man, wenn man folgendes Programm kompiliert und
startet?
public class BitweiseOperatoren {
public static void main(String[ ] args) {
int i = 2;
int b = 3;
System.out.println(~i);
System.out.println(~b);
}
}
185
a) 2 3
b) 3 4
c) 3 4
d) 2 3
e) Keine dieser Mglichkeiten.
(7) Frage
Welches Ergebnis erhlt man, wenn man folgendes Programm kompiliert und
startet?
public class B {
public static void main(String[ ] args) {
int i = 2;
int b = 3;
System.out.println(i | b);
}
}
a) 4
b) 2
c) 3
d) 5
e) Keine dieser Mglichkeiten.
(8) Frage
Welches Ergebnis erhlt man, wenn man folgendes Programm kompiliert und
startet?
public class B {
public static void main(String[ ] args) {
int i = 2;
int b = 3;
System.out.println(i ^ b);
}
}
a) 4
b) 2
c) 3
d) 5
186
4 Operatoren
Welches Ergebnis erhlt man, wenn man folgendes Programm kompiliert und
startet?
public class B {
public static void main(String[ ] args) {
int i = 8;
int b = 9;
System.out.println(i ^ b);
}
}
a) 4
b) 2
c) 3
d) 1
e) Keine dieser Mglichkeiten.
(10) Frage
Welches Ergebnis erhlt man, wenn man folgendes Programm kompiliert und
startet?
public class B {
public static void main(String[ ] args) {
int i = 8;
int b = 9;
System.out.println(i | b);
}
}
a) 4
b) 2
c) 3
d) 1
e) Keine dieser Mglichkeiten.
187
Lsungen
(1) Frage
(2) Frage
Intern werden beide Zahlen in eine Binrzahl berfhrt. Diese Binrzahlen werden mit dem Or-Operator in Beziehung gesetzt, wobei an der
gleichen Stelle mindestens eine Zahl eine 1 haben muss, damit eine 1
als Resultat erscheint. Das binre Ergebnis ist die Zahl 1101, die umgerechnet in eine Dezimalzahl 13 ergibt.
(3) Frage
(4) Frage
Bei dem bitweisen And-Operator werden zwei binre Zahlen miteinander in Beziehung gesetzt. Die binre Zahl 1 erhalten Sie nur als Resultat, wenn bei beiden Zahlen an dieser Stelle eine 1 steht, andernfalls
wird 0 zurckgegeben.
(5) Frage
(6) Frage
(7) Frage
188
4 Operatoren
(8) Frage
Sie erhalten als Ergebnis 1. Einen Lsungshinweis finden Sie, wenn Sie
sich die Lsung von Aufgabe 1 anschauen.
(9) Frage
Siehe Aufgabe 1.
(10) Frage
Siehe Aufgabe 2.
189
Bei einem Shift um 32 bleibt der Wert gleich, da es genau 32 Bits bei einer
int-Zahl gibt, sprich es wird um 32 geshiftet, wobei man wieder zum Anfangspunkt gelangt.
public class ShiftOperator {
public static void main(String[ ] args) {
int a = 20;
int b = a << 32;
System.out.println(a);
System.out.println(Integer.toBinaryString(a));
System.out.println(b);
System.out.println(Integer.toBinaryString(b));
}
}
190
4 Operatoren
191
14
5
101 //Die letzten zwei Nullen auf der rechten Seite sind sozusagen heruntergefallen
5
Der Rechts-Shift-Operator fllt eine negative binre Zahl von links mit Einsen
auf, so wird eine Eins von links nach rechts verschoben, und sie behlt dabei
das Vorzeichen.
public class ShiftOperator {
public static void main(String[ ] args) {
int a = -20;
int b = a >> 2;
System.out.println(a);
System.out.println(Integer.toBinaryString(a));
System.out.println(Integer.toHexString(a));
System.out.println(b);
System.out.println(Integer.toBinaryString(b));
System.out.println(Integer.toHexString(b));
}
}
Wird allerdings die Zahl 1 um eine beliebige Zahl nach rechts geshiftet,
kommt immer 1 als Ergebnis heraus, da von links mit Einsen aufgefllt wird.
public class ShiftOperator {
public static void main(String[ ] args) {
int a = -1;
int b = a >> 2;
System.out.println(a);
System.out.println(Integer.toBinaryString(a));
System.out.println(Integer.toHexString(a));
System.out.println(b);
System.out.println(Integer.toBinaryString(b));
System.out.println(Integer.toHexString(b));
}
}
192
4 Operatoren
ffffffff
-1
11111111111111111111111111111111
ffffffff
Genauso verhlt es sich mit der Zahl 0, da diese von links immer mit 0 aufgefllt wird, wobei nur die 0 auf der Konsole ausgegeben wird.
public class ShiftOperator {
public static void main(String[ ] args) {
int a = 0;
int b = a >> 2;
System.out.println(a);
System.out.println(Integer.toBinaryString(a));
System.out.println(Integer.toHexString(a));
System.out.println(b);
System.out.println(Integer.toBinaryString(b));
System.out.println(Integer.toHexString(b));
}
}
Bei einem Shift um 32 bleibt der Wert unverndert, da es genau 32 Bits bei
einer int-Zahl gibt, sprich es wird um 32 Bits geshiftet, wobei wieder der Ursprung erreicht wird.
193
System.out.println(b);
System.out.println(Integer.toBinaryString(b));
System.out.println(Integer.toHexString(b));
}
}
Welches Ergebnis erhlt man, wenn man folgendes Programm kompiliert und
startet?
public class S {
public static void main(String[ ] args) {
int a = 0xfffffff4;
int b = a >> 6;
System.out.println(Integer.toHexString(a));
System.out.println(Integer.toHexString(b));
}
}
a) 0xfffffff4 0xffffffff
b) 0xfffffff4 0xfffffffe
c) 0xfffffff4 0xfffffd00
d) 0xfffffff4 0xfffffffc
e) 0xfffffff4 0x3ffffff
f) Keine dieser Mglichkeiten.
194
4 Operatoren
(2) Frage
Welches Ergebnis erhlt man, wenn man folgendes Programm kompiliert und
startet?
public class S {
public static void main(String[ ] args) {
int a = 0xfffffff4;
int b = a >>> 6;
System.out.println(Integer.toHexString(a));
System.out.println(Integer.toHexString(b));
}
}
a) 0xfffffff4 0xffffffff
b) 0xfffffff4 0xfffffffe
c) 0xfffffff4 0xfffffd00
d) 0xfffffff4 0xfffffffc
e) 0xfffffff4 0x3ffffff
f) Keine dieser Mglichkeiten.
(3) Frage
Welches Ergebnis erhlt man, wenn man folgendes Programm kompiliert und
startet?
public class S {
public static void main(String[ ] args) {
int a = 0xfffffff4;
int b = a << 6;
System.out.println(Integer.toHexString(a));
System.out.println(Integer.toHexString(b));
}
}
a) 0xfffffff4 0xffffffff
b) 0xfffffff4 0xfffffffe
c) 0xfffffff4 0xfffffd00
d) 0xfffffff4 0xfffffffc
e) 0xfffffff4 0x3fffffff
f) Keine dieser Mglichkeiten.
195
(4) Frage
Welches Ergebnis erhlt man, wenn man folgendes Programm kompiliert und
startet?
public class S {
public static void main(String[ ] args) {
int a = 0xffffffff;
int b = a >> 2;
System.out.println(Integer.toHexString(a));
System.out.println(Integer.toHexString(b));
}
}
a) 0xffffffff 0xffffffff
b) 0xffffffff 0xfffffffe
c) 0xffffffff 0xfffffd00
d) 0xffffffff 0xfffffffc
e) 0xffffffff 0x3fffffff
f) Keine dieser Mglichkeiten.
(5) Frage
Welches Ergebnis erhlt man, wenn man folgendes Programm kompiliert und
startet?
public class S {
public static void main(String[ ] args) {
int a = 0x00000000;
int b = a >> 6;
System.out.println(Integer.toHexString(a));
System.out.println(Integer.toHexString(b));
}
}
a) 0 0
b) 0x00000000 0x00000000
c) 0x00000000 0x00000020
d) Keine dieser Mglichkeiten.
196
4 Operatoren
(6) Frage
Welches Ergebnis erhlt man, wenn man folgendes Programm kompiliert und
startet?
public class S {
public static void main(String[ ] args) {
int a = 0x00000000;
int b = a >>> 6;
System.out.println(Integer.toHexString(a));
System.out.println(Integer.toHexString(b));
}
}
a) 0 0
b) 0x00000000 0x00000000
c) 0x00000000 0x00000020
d) Keine dieser Mglichkeiten.
(7) Frage
Welches Ergebnis erhlt man, wenn man folgendes Programm kompiliert und
startet?
public class S {
public static void main(String [ ] args) {
int a = 0xffffffff;
int b = a >>> 2;
System.out.println(Integer.toHexString(a));
System.out.println(Integer.toHexString(b));
}
}
a) 0xffffffff 0xffffffff
b) 0xffffffff 0x3fffffff
c) 0xffffffff 0xfffffff3
d) Keine dieser Mglichkeiten.
(8) Frage
Welches Ergebnis erhlt man, wenn man folgendes Programm kompiliert und
startet?
public class S {
public static void main(String [ ] args) {
int a = 0xffffffff;
int b = a >> 32;
197
System.out.println(Integer.toHexString(a));
System.out.println(Integer.toHexString(b));
}
}
a) 0xffffffff 0xffffffff
b) 0xffffffff 0x3fffffff
c) 0xffffffff 0xfffffff3
d) Keine dieser Mglichkeiten.
(9) Frage
Welches Ergebnis erhlt man, wenn man folgendes Programm kompiliert und
startet?
public class S {
public static void main(String [ ] args) {
int a = 0xffffffff;
int b = a >>> 32;
System.out.println(Integer.toHexString(a));
System.out.println(Integer.toHexString(b));
}
}
a) 0xffffffff 0xffffffff
b) 0xffffffff 0x3fffffff
c) 0xffffffff 0xfffffff3
d) Keine dieser Mglichkeiten.
(10) Frage
Welches Ergebnis erhlt man, wenn man folgendes Programm kompiliert und
startet?
public class S {
public static void main(String [ ] args) {
int a = 0x1f;
int b = a >>> 33;
System.out.println(Integer.toHexString(a));
System.out.println(Integer.toHexString(b));
}
}
a) 0x1f 0x1f
b) 0x1f 0xf
c) 0x1f 0x3e
Vakatseite
d) Keine dieser Mglichkeiten.
(11) Frage
Welches Ergebnis erhlt man, wenn man folgendes Programm kompiliert und startet?
public class S {
public static void main(String [ ] args) {
int a = 0x1f;
int b = a << 33;
System.out.println(Integer.toHexString(a));
System.out.println(Integer.toHexString(b));
}
}
a) 0x1f 0x1f
b) 0x1f 0xf
c) 0x1f 0x3e
d) Keine dieser Mglichkeiten.
(12) Frage
Welches Ergebnis erhlt man, wenn man folgendes Programm kompiliert und startet?
public class S {
public static void main(String [ ] args) {
int a = 23;
int b = a << 33;
System.out.println(a);
System.out.println(b);
}
}
a) 23 47
b) 23 11
c) 23 46
d) 23 12
e) Keine dieser Mglichkeiten.
199
(13) Frage
Welches Ergebnis erhlt man, wenn man folgendes Programm kompiliert und
startet?
public class S {
public static void main(String [ ] args) {
int a = 23;
int b = a >> 33;
System.out.println(a);
System.out.println(b);
}
}
a) 23 47
b) 23 11
c) 23 46
d) 23 12
e) Keine dieser Mglichkeiten.
Lsungen
(1) Frage
Der Rechts-Shift-Operator >> fllt ein negative Zahl von links mit Einsen
und eine positive Zahl von links mit Nullen auf. So wird die Hexadezimalzahl 0xfffffff4 (in Langform: 1111 1111 1111 1111 1111 1111 1111
0100) in die Hexadezimalzahl 0xffffffff (in Langform: 1111 1111 1111
1111 1111 1111 1111 1111) berfhrt.
(2) Frage
Der vorzeichenlose Rechts-Shift >>> fllt sowohl positive als auch negative Zahlen von links mit Nullen auf. So wird die Hexadezimalzahl
0xfffffff4 (in Langform: 1111 1111 1111 1111 1111 1111 1111 0100) in
die Hexadezimalzahl 0x3ffffff (in Langform: 0000 0011 1111 1111 1111
1111 1111 1111) umgewandelt.
(3) Frage
Der Links-Shift-Operator << fllt sowohl eine positive als auch eine negative Zahl von rechts mit Nullen auf. So wird die Hexadezimalzahl
0xfffffff4 (in Langform: 1111 1111 1111 1111 1111 1111 1111 0100) in
die Hexadezimalzahl 0xfffffd00 (in Langform: 1111 1111 1111 1111
1111 1101 0000 0000) transformiert.
200
4 Operatoren
(4) Frage
(5) Frage
Gehen Sie bitte analog wie in Frage 1 vor. Als Ergebnis auf der Konsole
erscheint allerdings jeweils nur eine 0.
(6) Frage
Gehen Sie bitte analog wie in Frage 2 vor. Als Ergebnis auf der Konsole
erscheint allerdings jeweils nur eine 0.
(7) Frage
Vergleichen Sie die Vorgehensweise bitte mit der Lsung von Frage 2.
(8) Frage
Bei einem Shift (sowohl beim Rechts- als auch beim Links-Shift) um 32
bleibt der Wert erhalten, da bei einem Shift um 32 wieder der Anfang
erreicht wird.
(9) Frage
Bei einem vorzeichenlosen Rechts-Shift um 32 bleibt der Wert unverndert, da man wieder zum Ausgangspunkt gelangt.
(10) Frage
(11) Frage
(12) Frage
201
(13) Frage
202
4 Operatoren
203
Kontrollstrukturen
5.1 Selektionen
5.1.1 Die if-Struktur
Mit der if-Struktur ist es mglich, zwischen mindestens zwei Mglichkeiten zu
whlen. Wenn in unten stehendem Beispiel die Anrede Frau ist, soll der Satz
Ich bin eine Frau! auf der Konsole erscheinen. Da die Bedingung zutrifft und
der Boolean-Ausdruck anrede == Frau den Wert true zurck gibt, wird der
Satz Ich bin eine Frau! ausgegeben. Die Anweisung der if-Struktur wird nur
ausgefhrt, wenn die dazugehrige Bedingung wahr ist. Die geschweiften
Klammern { } der if-Struktur knnen weggelassen werden, wenn der if-Bedingung nur eine Programmierzeile folgt.
public class IfElse {
public static void main(String[ ] args) {
String anrede = Frau;
//Wenn der Inhalt der Variable identisch Frau ist
if (anrede == Frau){
//Soll folgender Satz ausgegeben werden:
System.out.println(Ich bin eine Frau!);
}
}
}
Ist allerdings der Inhalt der Variable das Wort Mann, so wird in unserem Beispiel gar nichts ausgegeben. Der Boolean-Wert gibt nun false zurck, da
Mann nicht identisch mit Frau ist, so wird der Befehl, den Satz Ich bin eine
Frau! zu schreiben, nicht ausgefhrt. Das Programm berspringt nun diese
Anweisung.
public class IfElse {
public static void main(String[ ] args) {
String anrede = Mann;
//Wenn der Inhalt der Variable nicht identisch Frau ist,
if (anrede == Frau){
204
5 Kontrollstrukturen
//wird dieser Satz nicht auf der Konsole ausgegeben:
System.out.println(Ich bin eine Frau!);
}
}
5.1
Selektionen
205
if (anrede == Frau){
System.out.println(Ich bin eine Frau!);
}
else if (anrede == Mann){
System.out.println(Ich bin ein Mann!);
}
else if (anrede == Kind){
System.out.println(Ich bin ein Kind!);
}
}
}
In der Klammer nach dem if steht immer ein Boolean-Ausdruck. Wir erinnern
uns, dass dieser nur zwei Zustnde annehmen kann, und zwar true oder
false (vgl. Kapitel 2.5.3 Literale ab Seite 39). Der if-Zweig wird aber nur
ausgefhrt, wenn der Boolean-Ausdruck true ist, bei false wird die Anweisung bersprungen. So ist das Ergebnis des unten stehenden Beispiels auf
der Konsole das Wort zwei.
public class IfElse {
public static void main(String[ ] args) {
boolean b = false;
if (b){
System.out.println(eins);
}
else if (b = true){
System.out.println(zwei);
}
}
}
Fr den Fall, dass es zwei Boolean-Ausdrcke gibt, die wie in unten stehendem Beispiel true zurckgeben, wird nur die erste if-Anweisung mit true ausgefhrt, danach springt das Programm weiter. Der dritte Boolean-Ausdruck
gibt false zurck, da b im zweiten Boolean-Ausdruck auf true gesetzt wurde
und !b (nicht true) false ist.
public class IfElse {
public static void main(String[ ] args) {
boolean b;
if (b = true){
206
5 Kontrollstrukturen
System.out.println(eins);
}
else if (b = true){
System.out.println(zwei);
}
else if (!b){
System.out.println(drei);
}
}
Steht in der Klammer nach dem if oder else if ein Vergleich und keine Zuweisung, wird wie in unten stehendem Beispiel zwei auf der Konsole ausgegeben.
public class IfElse {
public static void main(String[ ] args) {
boolean b = false;
if (b == true){
System.out.println(eins);
}
else if (b == false){
System.out.println(zwei);
}
}
}
Eine Zuweisung zu einem Begriff wie Frau (anrede = Frau) fhrt allerdings
zu einem Kompilierfehler, da dies im Gegensatz zu b = true kein BooleanAusdruck ist, und in der Klammer nach if immer ein Boolean-Ausdruck stehen muss.
public class IfElse {
public static void main(String[ ] args) {
String anrede = Frau;
if (anrede = Frau){
System.out.println(Ich bin eine Frau!);
}
}
}
5.1
Selektionen
207
Das gleiche gilt fr den Fall, dass der Boolean-Ausdruck nach dem if oder
else durch if (a) ersetzt wird, es kommt zu einem Kompilierfehler.
Welches Ergebnis erhlt man, wenn man folgendes Programm kompiliert und
startet?
public class A {
public static void main(String[ ] args) {
boolean b1 ;
if (b1 = false){
System.out.println(Hund);
}
else if(b1 = true){
System.out.println(Katze);
}
else if(!b1){
System.out.println(Maus);
}
}
}
a) Hund
b) Katze
c) Maus
d) Katze Maus
e) Maus Katze
f) Hund Katze Maus
g) Maus Katze Hund
h) Keine dieser Mglichkeiten.
(2) Frage
Welches Ergebnis erhlt man, wenn man folgendes Programm kompiliert und
startet?
public class A {
public static void main(String[ ] args) {
boolean b1 ;
if (b1 = true){
208
5 Kontrollstrukturen
System.out.println(Hund);
}
else if(b1 = true){
System.out.println(Katze);
}
else if(!b1){
System.out.println(Maus);
}
}
a) Hund
b) Katze
c) Maus
d) Katze Maus
e) Maus Katze
f) Hund Katze Maus
g) Maus Katze Hund
h) Keine dieser Mglichkeiten.
(3) Frage
Welches Ergebnis erhlt man, wenn man folgendes Programm kompiliert und
startet?
public class A {
public static void main(String[ ] args) {
boolean b1 = true;
if (b1 = false){
System.out.println(Hund);
}
else if(b1 = false){
System.out.println(Katze);
}
else if(!b1){
System.out.println(Maus);
}
}
}
a) Hund
b) Katze
c) Maus
5.1
Selektionen
209
d) Katze Maus
e) Maus Katze
f) Hund Katze Maus
g) Maus Katze Hund
h) Keine dieser Mglichkeiten.
(4) Frage
Welches Ergebnis erhlt man, wenn man folgendes Programm kompiliert und
startet?
public class A {
public static void main(String[ ] args) {
boolean b1 = true;
if (b1 = false){
System.out.println(Hund);
}
else if(!b1){
System.out.println(Katze);
}
else if(!b1){
System.out.println(Maus);
}
}
}
a) Hund
b) Katze
c) Maus
d) Katze Maus
e) Maus Katze
f) Hund Katze Maus
g) Maus Katze Hund
h) Keine dieser Mglichkeiten.
(5) Frage
Welches Ergebnis erhlt man, wenn man folgendes Programm kompiliert und
startet?
public class A {
public static void main(String[ ] args) {
boolean b1 = true;
210
5 Kontrollstrukturen
if (b1 = false){
System.out.println(Hund);
}
else if(b1 = true){
System.out.println(Katze);}
else if(!b1){
System.out.println(Maus);
}
}
a) Hund
b) Katze
c) Maus
d) Katze Maus
e) Maus Katze
f) Hund Katze Maus
g) Maus Katze Hund
h) Keine dieser Mglichkeiten.
(6) Frage
Welches Ergebnis erhlt man, wenn man folgendes Programm kompiliert und
startet?
public class A {
public static void main(String[ ] args) {
boolean b1 = true;
if (b1 == false){
System.out.println(Hund);
}
else if(b1 == false){
System.out.println(Katze);
}
else if(!b1){
System.out.println(Maus);}
}
}
a) Hund
b) Katze
c) Maus
5.1
Selektionen
211
d) Katze Maus
e) Maus Katze
f) Hund Katze Maus
g) Maus Katze Hund
h) Keine dieser Mglichkeiten.
(7) Frage
Welches Ergebnis erhlt man, wenn man folgendes Programm kompiliert und
startet?
public class A {
public static void main(String[ ] args) {
boolean b1 = true;
if (b1 == true){
System.out.println(Hund);
}
else if(b1 == false){
System.out.println(Katze);
}
else if(!b1){
System.out.println(Maus);
}
}
}
a) Hund
b) Katze
c) Maus
d) Katze Maus
e) Maus Katze
f) Hund Katze Maus
g) Maus Katze Hund
h) Keine dieser Mglichkeiten.
(8) Frage
Welches Ergebnis erhlt man, wenn man folgendes Programm kompiliert und
startet?
public class A {
public static void main(String[ ] args) {
212
5 Kontrollstrukturen
boolean b1 = true;
if (b1 == false){
System.out.println(Hund);
}
else if(!b1){
System.out.println(Maus);
}}
a) Hund
b) Maus
c) Maus Hund
d) Hund Maus
e) Keine dieser Mglichkeiten.
(9) Frage
Welches Ergebnis erhlt man, wenn man folgendes Programm kompiliert und
startet?
public class A {
public static void main(String[ ] args) {
String s = A;
if (s == A){
System.out.println(A);
}
else if(s == B){
System.out.println(B); }}}
a) A
b) B
c) A B
d) B A
e) Kompilierfehler
f) Laufzeitfehler
g) Keine dieser Mglichkeiten.
5.1
Selektionen
213
(10) Frage
Welches Ergebnis erhlt man, wenn man folgendes Programm kompiliert und
startet?
public class A {
public static void main(String[ ] args) {
String s = B;
if (s == A){
System.out.println(A);
}
else if(s == B){
System.out.println(B);
}}}
a) A
b) B
c) A B
d) B A
e) Kompilierfehler
f) Laufzeitfehler
g) Keine dieser Mglichkeiten.
(11) Frage
Welches Ergebnis erhlt man, wenn man folgendes Programm kompiliert und
startet?
public class A {
public static void main(String[ ] args) {
String s = A;
if (s = A){
System.out.println(A);
}
else if(s == B){
System.out.println(B);
}
}
}
a) A
b) B
c) A B
214
5 Kontrollstrukturen
d) B A
e) Kompilierfehler
f) Laufzeitfehler
g) Keine dieser Mglichkeiten.
(12) Frage
Welches Ergebnis erhlt man, wenn man folgendes Programm kompiliert und
startet?
public class A {
public static void main(String[ ] args) {
String s = a;
if (s == A){
System.out.println(A);
}
else if(s == B){
System.out.println(B);
}
}
}
a) A
b) B
c) A B
d) B A
e) Kompilierfehler
f) Laufzeitfehler
g) Keine dieser Mglichkeiten.
Lsungen
(1) Frage
Es wird der Zweig ausgefhrt, fr den die Bedingung true den Tatsachen entspricht, so wird Katze ausgegeben. Hier ist besonders zu beachten, dass b1 = true eine Zuweisung ist, die nur bei Boolean-Audrcken erlaubt ist.
(2) Frage
Es wird nur der erste Zweig abgearbeitet, fr den die Bedingung true zutrifft. So erhlt man als Ergebnis Hund als Ausgabe auf der Konsole.
5.1
Selektionen
215
(3) Frage
(4) Frage
Es wird nur der erste Zweig ausgefhrt, fr den die Bedingung true wahr
ist.
(5) Frage
(6) Frage
Achtung! Hier steht b1 == false, dies ist ein Vergleich und keine Zuweisung! So ist die Bedingung true fr keinen else-if-Zweig zutreffend.
(7) Frage
Achtung! Hier steht b1 == true, dies ist ein Vergleich und keine Zuweisung!
(8) Frage
Achtung! Hier steht b1 == false, dies ist ein Vergleich und keine Zuweisung!
(9) Frage
(10) Frage
Es wird der Buchstabe B ausgegeben, da fr den else-if-Zweig die Bedingung wahr ist.
(11) Frage
In der Klammer nach dem if muss eine Bedingung stehen, dort steht
aber eine Zuweisung s = A. Um den Kompilierfehler zu vermeiden,
msste dort ein Vergleich stehen: s == A!
(12) Frage
216
5 Kontrollstrukturen
Vergisst man die break-Anweisungen am Ende jedes Falles, werden alle anderen Flle auch abgearbeitet. Hinter dem Standardfall steht kein break, da
dies der letzte Fall ist.
public class SwitchStruktur {
public static void main(String[ ] args) {
int x = 1;
switch (x){
case 1:
System.out.println(Ich bin Fall 1);
case 2:
System.out.println(Ich bin Fall 2);
default:
System.out.println(Ich bin der Standardfall);
}
5.1
Selektionen
217
}
}
Die Reihenfolge der verschiedenen Labels spielt keine Rolle, case 2 kann vor
case 1 stehen und auch der Standardfall muss nicht der Letzte sein. Befindet
sich der default-Fall nicht am Ende, sollte dahinter ein break stehen, da
sonst, wie man in unten stehendem Beispiel sehen kann, auch der nchste
Fall mit abgearbeitet wird.
public class SwitchStruktur {
public static void main(String[ ] args) {
int x = 0;
switch (x){
default:
System.out.println(Ich bin der Standardfall);
case 1:
System.out.println(Ich bin Fall 1);
break;
case 2:
System.out.println(Ich bin Fall 2);
break;
}
}
}
Welches Ergebnis erhlt man, wenn man folgendes Programm kompiliert und
startet?
public class A {
public static void main(String[ ] args) {
short a = 1;
switch (a){
case 1: System.out.println( 1 ); break;
case 2: System.out.println( 2 ); break;
218
5 Kontrollstrukturen
default: System.out.println( Standard );
}
}
a) 1 2 Standard
b) 1 Standard 2
c) Standard 1 2
d) Standard
e) 1
f) 2
g) Kompilierfehler
h) Keine dieser Mglichkeiten.
(2) Frage
Welches Ergebnis erhlt man, wenn man folgendes Programm kompiliert und
startet?
public class A {
public static void main(String[ ] args) {
short a = 1;
switch (a){
case 1: System.out.println( 1 );
case 2: System.out.println( 2 );
default: System.out.println( Standard );
}
}
}
a) 1 2 Standard
b) 1 Standard 2
c) Standard 1 2
d) Standard
e) 1
f) 2
g) Kompilierfehler
h) Keine dieser Mglichkeiten.
5.1
Selektionen
219
(3) Frage
Welches Ergebnis erhlt man, wenn man folgendes Programm kompiliert und
startet?
public class A {
public static void main(String[ ] args) {
String a = 1;
switch (a){
case 1: System.out.println( 1 ); break;
case 2: System.out.println( 2 ); break;
default: System.out.println( Standard );
}
}
}
a) 1 2 Standard
b) 1 Standard 2
c) Standard 1 2
d) Standard
e) 1
f) 2
g) Kompilierfehler
h) Keine dieser Mglichkeiten.
(4) Frage
Welches Ergebnis erhlt man, wenn man folgendes Programm kompiliert und
startet?
public class A {
public static void main(String[ ] args) {
short a = 5;
switch (a){
case 1: System.out.println( 1 ); break;
case 2: System.out.println( 2 ); break;
default: System.out.println( Standard );
}
}
}
a) 1 2 Standard
b) 1 Standard 2
220
5 Kontrollstrukturen
c) Standard 1 2
d) Standard
e) 1
f) 2
g) Kompilierfehler
h) Keine dieser Mglichkeiten.
(5) Frage
Welches Ergebnis erhlt man, wenn man folgendes Programm kompiliert und
startet?
public class A {
public static void main(String[ ] args) {
short a = 1;
switch (a){
default: System.out.println( Standard );
case 1: System.out.println( 1 );
case 2: System.out.println( 2 );
}
}
}
a) 1 2 Standard
b) 1 Standard 2
c) Standard 1 2
d) Standard
e) 1
f) 2
g) Kompilierfehler
h) Keine dieser Mglichkeiten.
(6) Frage
Welches Ergebnis erhlt man, wenn man folgendes Programm kompiliert und
startet?
public class A {
public static void main(String[ ] args) {
short a = 1;
5.1
Selektionen
221
switch (a){
default: System.out.println( Standard );
case 2: System.out.println( 2 );
case 1: System.out.println( 1 );
}
}
}
a) 1 2 Standard
b) 1 Standard 2
c) Standard 1 2
d) Standard
e) 1
f) 2
g) Kompilierfehler
h) Keine dieser Mglichkeiten.
(7) Frage
Welches Ergebnis erhlt man, wenn man folgendes Programm kompiliert und
startet?
public class A {
public static void main(String[ ] args) {
boolean b;
switch (b){
default: System.out.println( Standard );
case 2: System.out.println( 2 );
case 1: System.out.println( 1 );
}
}
}
a) 1 2 Standard
b) 1 Standard 2
c) Standard 1 2
d) Standard
e) 1
f) 2
222
5 Kontrollstrukturen
g) Kompilierfehler
h) Keine dieser Mglichkeiten.
Lsungen
(1) Frage
Der erste Fall erweist sich als zutreffend, so ist die Ausgabe 1.
(2) Frage
Bereits der erste Fall entspricht der Wahrheit, da aber die break-Anweisungen nach jedem Label fehlen, werden auch die anderen Flle abgearbeitet.
(3) Frage
In der Klammer nach der switch-Anweisung drfen nur folgende Datentypen stehen: char, byte, short und int.
(4) Frage
(5) Frage
Der default-Fall muss nicht an letzter Stelle stehen, so kommt es zu keinem Kompilierfehler, sondern zur Ausgabe von 1 und 2, da nach jedem
Label der break-Ausdruck fehlt.
(6) Frage
(7) Frage
In der Klammer nach der switch-Anweisung drfen nur folgende Datentypen stehen: char, byte, short und int.
5.2 Iterationen
5.2.1 Die while-Schleife
Will man z. B. eine Adressliste aller Kunden aus einer Datenbank auslesen,
verwendet man eine so genannte while-Schleife. Solange also nicht der
letzte Kunde erreicht worden ist, soll jede weitere Adresse ausgedruckt wer-
5.2
Iterationen
223
den. Als Synonym fr while-Schleife wird auch hufig in der Fachliteratur der
Begriff kopfgesteuerte Schleife verwendet.
Wir fangen mit einer einfachen while-Schleife an, die die Zahlen 0 bis 4 ausgeben soll. Am Anfang bentigen wir einen Einstiegspunkt, eine deklarierte
und initialisierte Variable, in unserem Fall ist dies int i = 0. So ist der erste
Wert, der ausgegeben wird, die Zahl 0. Dann braucht man eine Abbruchbedingung, die vor Durchlauf der Schleife berprft wird. Diese besteht aus einem Boolean-Ausdruck i<5, der zur Folge hat, dass die Schleife so lange
durchlaufen wird, bis der Ausdruck nicht mehr true ist. In unserem Fall bedeutet dies, die Schleife wird fnfmal abgearbeitet und als letztes erscheint
die Zahl 4. 4 ist die letzte Zahl, fr die die Bedingung kleiner 5 wahr ist. Der
Operator i++ sorgt innerhalb der Schleife dafr, dass die Variable bei jedem
Durchlauf um 1 erhht wird. Die Variable i wird auch als Schleifenzhler bezeichnet.
224
5 Kontrollstrukturen
System.out.println(Dies ist der Durchlauf Nr. +i );
i++;
}
}
Steht in der Klammer nach dem while keine Bedingung, sondern etwas anderes, wie z. B. while (i), kommt es zu einem Kompilierfehler.
Die do-while-Schleife fhrt bei der Bedingung i < 0 zu einem anderen Resultat als die while-Schleife. Die do-while-Schleife wird mindestens einmal abgearbeitet, da sie erst nach dem ersten Durchlauf auf die Abbruchbedingung
stt.
public class DoWhileSchleife {
public static void main(String[ ] args) {
5.2
Iterationen
225
int i = 0;
do {
System.out.println(Dies ist der Durchlauf Nr. + i);
i++;
}while (i < 0);
}
}
Des Weiteren gibt es noch mehrere erlaubte Variationen fr die Erstellung einer for-Schleife. So kann die Variable auerhalb der for-Schleife deklariert
und innerhalb der Klammer der for-Schleife initialisiert werden.
public class ForSchleife {
public static void main(String[ ] args) {
//Deklaration des Schleifenzhlers i
int i;
//Initialisierung des Schleifenzhlers i
for(i = 0; i < 5; i++){
226
5 Kontrollstrukturen
System.out.println(Dies ist der Durchlauf Nr. + i);
}
}
Der Operator i++ darf auch innerhalb der for-Schleife geschrieben werden,
aber der Strichpunkt muss in der Klammer nach for erhalten bleiben, sonst
kommt es zu einem Kompilierfehler.
public class ForSchleife {
public static void main(String[ ] args) {
for(int i = 0; i < 5;){
i++
}
}
}
5.2
Iterationen
227
228
5 Kontrollstrukturen
case 2:
System.out.println(Ich bin Fall 2);
break oben;
default:
System.out.println(Standard);
}
}
}
Welches Ergebnis erhlt man, wenn man folgendes Programm kompiliert und
startet?
public class SwitchStruktur {
public static void main(String[ ] args) {
for (int j = 1; j < 2; j++){
switch (j){
case 1: System.out.println(1);
case 2: System.out.println(2);
default: System.out.println(Standard);
}
}
}
}
a) 1
b) 2
c) Standard
d) 1 2 Standard
e) Kompilierfehler
f) Keine dieser Mglichkeiten.
5.2
Iterationen
229
(2) Frage
Welches Ergebnis erhlt man, wenn man folgendes Programm kompiliert und
startet?
public class SwitchStruktur {
public static void main(String[ ] args) {
for (int j = 1; j = 2; j++){
switch (j){
case 1: System.out.println(1); break;
case 2: System.out.println(2);break;
default: System.out.println(Standard);
}
}
}
}
a) 1
b) 2
c) Standard
d) 1 2 Standard
e) Kompilierfehler
f) Keine dieser Mglichkeiten.
(3) Frage
Welches Ergebnis erhlt man, wenn man folgendes Programm kompiliert und
startet?
public class SwitchStruktur {
public static void main(String[ ] args) {
for (long j = 1; j < 2; j++){
switch (j){
case 1: System.out.println(1); break;
case 2: System.out.println(2); break;
default: System.out.println(Standard);
}
}
}
}
a) 1
b) 2
c) Standard
d) 1 2 Standard
230
5 Kontrollstrukturen
e) Kompilierfehler
f) Keine dieser Mglichkeiten.
(4) Frage
Welches Ergebnis erhlt man, wenn man folgendes Programm kompiliert und
startet?
public class SwitchStruktur {
public static void main(String[ ] args) {
for (int j = 1; j < 2; j++){
switch (j){
case 1: System.out.println(1); break;
default: System.out.println(Standard);
case 2: System.out.println(2);break;
}
}
}
}
a) 1
b) 2
c) Standard
d) 1 Standard 2
e) Kompilierfehler
f) Keine dieser Mglichkeiten.
(5) Frage
Welches Ergebnis erhlt man, wenn man folgendes Programm kompiliert und
startet?
public class SwitchStruktur {
public static void main(String[ ] args) {
int j = 1;
for ( ; j < 2; j++){
switch (j){
case 1: System.out.println(1); break;
default: System.out.println(Standard);
case 2: System.out.println(2);break;
}
}
}
}
5.2
Iterationen
231
a) 1
b) 2
c) Standard
d) 1 Standard 2
e) Kompilierfehler
f) Keine dieser Mglichkeiten.
(6) Frage
Welches Ergebnis erhlt man, wenn man folgendes Programm kompiliert und
startet?
public class SwitchStruktur {
public static void main(String[ ] args) {
int j = 1;
for (j < 2; j++){
switch (j){
case 1: System.out.println(1); break;
default: System.out.println(Standard);
case 2: System.out.println(2);break;
}
}
}
}
a) 1
b) 2
c) Standard
d) 1 Standard 2
e) Kompilierfehler
f) Keine dieser Mglichkeiten.
(7) Frage
Welches Ergebnis erhlt man, wenn man folgendes Programm kompiliert und
startet?
public class SwitchStruktur {
public static void main(String[ ] args) {
int j;
for (j = 1; j < 2; j++){
switch (j){
232
5 Kontrollstrukturen
case 1: System.out.println(1); break;
default: System.out.println(Standard);
case 2: System.out.println(2);break;
}
}
}
a) 1
b) 2
c) Standard
d) 1 Standard 2
e) Kompilierfehler
f) Keine dieser Mglichkeiten.
(8) Frage
Welches Ergebnis erhlt man, wenn man folgendes Programm kompiliert und
startet?
public class SwitchStruktur {
public static void main(String[ ] args) {
auen:
for (int j = 1; j < 5; j++){
switch (j){
case 1: System.out.println(1); break;
default: System.out.println(Standard);
case 2: System.out.println(2);break auen;
}
}
}
}
a) 1 2
b) 2 1
c) 1 2 Standard
d) 1 Standard 2
e) Kompilierfehler
f) Keine dieser Mglichkeiten.
5.2
Iterationen
233
(9) Frage
Welches Ergebnis erhlt man, wenn man folgendes Programm kompiliert und
startet?
public class SwitchStruktur {
public static void main(String[ ] args) {
auen:
for (int j = 1; j < 5; j++){
switch (j){
case 1: System.out.println(1); break;
default: System.out.println(Standard);
case 2: System.out.println(2);break;
}
}
}
}
a) 1 2
b) 2 1
c) 1 2 Standard
d) 1 Standard 2
e) Kompilierfehler
f) Keine dieser Mglichkeiten.
(10) Frage
Welches Ergebnis erhlt man, wenn man folgendes Programm kompiliert und
startet?
public class SwitchStruktur {
public static void main(String[ ] args) {
auen:
for (int j = 1; j < 5; j++){
switch (j){
case 1: System.out.println(1); break;
default: System.out.println(Standard);
case 2: System.out.println(2);continue
auen;
}
}
}
}
a) 1 2
234
5 Kontrollstrukturen
b) 2 1
c) 1 2 Standard
d) 1 Standard 2
e) Kompilierfehler
f) Keine dieser Mglichkeiten.
(11) Frage
5.2
Iterationen
235
e) for(int i = 0; ; i++) { }
f) for( ; ; ) { }
g) Keine dieser Mglichkeiten.
(14) Frage
Welches Ergebnis erhlt man, wenn man folgendes Programm kompiliert und
startet?
public class WhileSchleife {
public static void main(String[ ] args) {
int i = 0;
while (i<2){
System.out.println(i);
i++;
}
}
}
a) 0 1
b) 0 1 2
c) Kompilierfehler.
d) Keine dieser Mglichkeiten.
(15) Frage
Welches Ergebnis erhlt man, wenn man folgendes Programm kompiliert und
startet?
public class WhileSchleife {
public static void main(String[ ] args) {
int i = 0;
while (i){
System.out.println(i);
i++;
}
}
}
a) 0 1
b) 0 1 2
c) Kompilierfehler.
d) Keine dieser Mglichkeiten.
236
5 Kontrollstrukturen
(16) Frage
Welches Ergebnis erhlt man, wenn man folgendes Programm kompiliert und
startet?
public class WhileSchleife {
public static void main(String[ ] args) {
int i = 0;
while (i<0){
System.out.println(i);
i++;
}
}
}
a) 0 1
b) 0 1 2
c) Kompilierfehler.
d) Keine dieser Mglichkeiten.
(17) Frage
Welches Ergebnis erhlt man, wenn man folgendes Programm kompiliert und
startet?
public class DoWhileSchleife {
public static void main(String[ ] args) {
int i = 1;
do {
System.out.println(i);
i++;
}while (i < 2);
}
}
a) 1
b) 0 1
c) 0 1 2
d) Kompilierfehler.
e) Keine dieser Mglichkeiten.
(18) Frage
Welches Ergebnis erhlt man, wenn man folgendes Programm kompiliert und
startet?
public class DoWhileSchleife {
public static void main(String[ ] args) {
5.2
Iterationen
237
int i = 1;
do {
System.out.println(i);
i++;
}while (i < 1);
}
}
a) 1
b) 0 1
c) 0 1 2
d) Kompilierfehler.
e) Keine dieser Mglichkeiten.
Lsungen
(1) Frage
(2) Frage
(3) Frage
Die Variable j darf nicht vom Datentyp long sein, sondern nur char, byte,
short und int.
(4) Frage
(5) Frage
(6) Frage
Die Variable j darf zwar auerhalb der for-Schleife deklariert und initialisiert werden, dann muss aber innerhalb der Klammer vor der Bedingung ein Strichpunkt stehen. Es msste wie folgt aussehen: for ( ; j < 2;
j++).
Vakatseite
(7) Frage
Die for-Schleife wird einmal durchlaufen, somit wird die Zahl 1 auf der Konsole ausgegeben. Der Schleifenzhler darf auerhalb der for-Schleife deklariert und innerhalb initialisiert werden, ohne dass es zu einem Kompilierfehler
kommt.
(8) Frage
Die Schleife wird zweimal durchlaufen, wobei dann der Befehl break auen;
dazu fhrt, dass die for-Schleife abgebrochen wird.
(9) Frage
Die for-Schleife wird viermal durchlaufen, so wird Folgendes auf der Konsole
ausgegeben: 1 2 Standard 2 Standard 2.
(10) Frage
Die for-Schleife wird viermal durchlaufen, so wird Folgendes auf der Konsole
ausgegeben: 1 2 Standard 2 Standard 2. Der Befehl continue auen; hat zur
Folge, dass die for-Schleife nicht abgebrochen wird, sondern weiterluft.
(11) Frage
(12) Frage
(13) Frage
Es msste an zweiter Stelle in der Klammer eine Bedingung stehen, dort steht
aber eine Zuweisung (i=100)
Strichpunkt fehlt.
Strichpunkt fehlt.
(14) Frage
Die while-Schleife wird zweimal durchlaufen, deswegen wird 0 1 auf der Konsole ausgegeben.
(15) Frage
In der Klammer nach while steht (i), dies ist keine Bedingung bzw. kein boolean-Ausdruck, deswegen kommt es zu einem Kompilierfehler.
5.2
Iterationen
239
(16) Frage
Die Bedingung 1<0 ist bereits zu Beginn false, deswegen wird die whileSchleife bersprungen.
(17) Frage
(18) Frage
Die do-while-Schleife wird auf jeden Fall mindestens einmal abgearbeitet, da sie erst nach dem ersten Durchlauf auf die Abbruchbedingung
stt.
240
5 Kontrollstrukturen
241
Arrays
Vergessen Sie beim Konstruieren die Gre des Arrays, kommt es zu einem
Kompilierfehler, wobei allerdings ein Array der Lnge 0 erlaubt ist.
242
6 Arrays
Schreiben Sie die Gre des Arrays in die Klammer vor der Zuweisung, fhrt
dies ebenfalls zu einem Kompilierfehler. Die Gre des Arrays muss immer
nach der Zuweisung angegeben werden.
Sie knnen aber auch ein Array in einem Schritt mit expliziten Werten initialisieren und anschlieend mit i [0] auf das erste Element, mit i [1] auf das
zweite Element und mit i [2] auf das dritte Element zugreifen. Bitte beachten
Sie, dass sich das erste Element immer an der Position 0 befindet.
Element
Position
1
0
2
1
3
2
Werden dem Array keine expliziten Werte zugewiesen, besitzt das Array den
Standardwert des jeweiligen Datentyps des Arrays. Bei dem primitiven Datentyp int ist dies der Wert 0 und beim Wrapper Integer ist dies null (vgl. Kapitel 7.2).
public class Arrays {
public static void main(String[ ] args) {
int[ ] i = new int [1];
Integer b[ ] = new Integer[1];
System.out.println(Erstes Element des Arrays i: + i[0]);
System.out.println(Erstes Element des Arrays b: + b[0]);
}
}
6.2
Mehrdimensionale Arrays
243
Weist ein Array mehrere Elemente auf, knnen Sie die Elemente mithilfe der
for-Schleife und der Methode a.length auslesen. Die Methode a.length gibt
die Lnge der Elemente einer Ebene des Arrays wieder. Hier ein Beispiel:
public class Arrays {
public static void main(String[ ] args) {
int[ ] a = {1, 2, 3};
for (int i=0; i<a.length; i++){
System.out.println(Indexposition + i + hat Wert: + a[i]);
}
}
}
Wollen Sie auf die Indexposition 2 zugreifen, die bei int[ ] a = new int[2]; nicht
vorhanden ist, kommt es zur Laufzeit zu einer ArrayIndexOutOfBoundsException (siehe Kapitel 8 Exceptions), die eine RuntimeException ist. Dies
erkennt der Kompiler erst zur Laufzeit, da dies kein Syntaxfehler, sondern ein
Logikfehler ist.
244
6 Arrays
Indexposition
0
1
0
1
3
1
2
4
Der erste Schritt, ein zweidimensionales Array zu erstellen, ist die Deklaration. Es existieren drei Wege, ein Array fehlerfrei zu deklarieren:
public class Arrays {
public static void main(String[ ] args) {
int [ ][ ] a;
int [ ]b[ ];
int c[ ][ ];
}
}
Lenken Sie Ihr Augenmerk auf die rechte Seite, wo mindestens in der ersten
Klammer ein Wert stehen muss.
public class Arrays {
public static void main(String[ ] args) {
int [ ][ ] a = new int[2][ ];
int [ ]b[ ] = new int[2][ ];
int c[ ][ ] = new int[2][ ];
}
}
Vergessen Sie auf der rechten Seite in der eckigen Klammer einen Wert einzusetzen, kommt es zu einem Kompilierfehler.
6.2
Mehrdimensionale Arrays
245
Zustzlich zu unserem zweidimensionalen Array, wollen wir jetzt ein dreidimensionales Array deklarieren und mit Standardwerten initialisieren. Wie Sie
sehen knnen, drfen Sie auf der rechten Seite nie die rechteckige Klammer
in der Mitte ohne Wert lassen, da dies zu Problemen fhrt. Die anderen zwei
unten stehenden Varianten sind erlaubt.
246
6 Arrays
}
Wie Sie sehen knnen, wird zweimal die Methode a.length bentigt, da
a.length nicht alle Array-Elemente zhlt, sondern nur die Elemente einer
Ebene. In unserem Fall, wie Sie unten sehen knnen, kommt a.length in der
ersten Ebene zu dem Ergebnis 2.
public class Arrays {
public static void main(String[ ] args) {
int [ ][ ] a = {
{1, 2},
{3, 4}};
System.out.println(a.length);
}
}
Sie haben das Array int [ ] a = new int[2], wie viele Elemente besitzt es?
a) 1
b) 2
c) 3
d) 4
e) 5
(2) Frage
Sie haben das Array int [ ] a = new int[2], wie kann man die Anzahl der Elemente einer Ebene feststellen?
a) a.length( )
b) a.length
c) a.getLength
247
d) a[ ].length
e) a.capacity
f) a.size
(3) Frage
Welches Ergebnis erhlt man, wenn man folgendes Programm kompiliert und
startet?
public class A {
public static void main(String[ ] args) {
int [ ][ ] a = {
{5, 4},
{3, 2}};
for (int i = 0; i<a.length; i++){
for (int j = 0; j<a.length; j++){
System.out.println(a[i][j]);
}
}
}
}
a) 4, 3, 2
b) 5, 4, 3, 2
c) Kompilierfehler
d) Laufzeitfehler
e) Keine dieser Mglichkeiten.
248
6 Arrays
(5) Frage
Welches Ergebnis erhlt man, wenn man folgendes Programm kompiliert und
startet?
public class A {
public static void main(String[ ] args) {
int [2][2] a = {
{5, 4},
{3, 2}};
for (int i = 0; i<a.length; i++){
for (int j = 0; j<a.length; j++){
System.out.println(a[i][j]);
}
}
}
}
a) 4, 3, 2
b) 5, 4, 3, 2
c) Kompilierfehler
d) Laufzeitfehler
e) Keine dieser Mglichkeiten.
(6) Frage
Welche der unten stehenden Mglichkeiten deklariert und initialisiert ein Array mit fnf Werten, ohne einen Kompilierfehler zu verursachen?
a) int a[ ] = new int[5];
b) int a[5] = new int[5];
249
Welches Ergebnis erhlt man, wenn man folgendes Programm kompiliert und
startet?
public class A {
public static void main(String[ ] args) {
double [ ][ ] a = {
{4.0, 8.0},
{7.0, 10.0}};
System.out.println(a[1][1]);
}
}
a) 4.0
b) 10.0
c) Kompilierfehler
d) Laufzeitfehler
e) Keine dieser Mglichkeiten.
(9) Frage
Welches Ergebnis erhlt man, wenn man folgendes Programm kompiliert und
startet?
public class A {
public static void main(String[ ] args) {
double [ ][ ] a = {
{4.0, 8.0},
{7.0, 10.0}};
System.out.println(a[2][2]);
}
}
a) 4.0
b) 10.0
250
6 Arrays
c) Kompilierfehler
d) Laufzeitfehler
e) Keine dieser Mglichkeiten.
(10) Frage
Welches Ergebnis erhlt man, wenn man folgendes Programm kompiliert und
startet?
public class A {
public static void main(String[ ] args) {
int [ ][ ] a = {
{6, 9},
{3, 4},
{2, 7, 5}};
System.out.println(a[2][2]+ + a[1][1]);
}
}
a) 4, 6
b) 5, 4
c) 10
d) 9
e) Kompilierfehler
f) Laufzeitfehler
g) Keine dieser Mglichkeiten.
(11) Frage
Welches Ergebnis erhlt man, wenn man folgendes Programm kompiliert und
startet?
public class A {
public static void main(String[ ] args) {
int [ ][ ] a = {
{6, 9},
{3, 4},
{2, 7, 5}};
System.out.println(a[2][2]+ a[1][1]);
}
}
a) 4, 6
b) 5, 4
251
c) 10
d) 9
e) Kompilierfehler
f) Laufzeitfehler
g) Keine dieser Mglichkeiten.
(12) Frage
Welches Ergebnis erhlt man, wenn man folgendes Programm kompiliert und
startet?
public class A {
public static void main(String[ ] args) {
int [2][2] a = {
{6, 9},
{3, 4},
{2, 7, 5}};
System.out.println(a[2][2]+ a[1][1]);
}
}
a) 4, 6
b) 5, 4
c) 10
d) 9
e) Kompilierfehler
f) Laufzeitfehler
g) Keine dieser Mglichkeiten.
(13) Frage
Welches Ergebnis erhlt man, wenn man folgendes Programm kompiliert und
startet?
public class A {
public static void main(String[ ] args) {
int [ ][ ] a = {
{15, 14, 12},
{53, 46, 91},
{96, 72, 12},
{45, 34, 23}};
System.out.println(a[3][2]+ + a[2][2]);
252
6 Arrays
}
a) 23 12
b) 72 91
c) Kompilierfehler
d) Laufzeitfehler
e) Keine dieser Mglichkeiten.
(14) Frage
Welches Ergebnis erhlt man, wenn man folgendes Programm kompiliert und
startet?
public class A {
public static void main(String[ ] args) {
int [ ][ ] a = {
{15, 14, 12},
{53, 46, 91},
{96, 72, 12},
{45, 34, 23}};
System.out.println(a[3][3]+ + a[2][2]);
}
}
a) 23 12
b) 72 91
c) Kompilierfehler
d) Laufzeitfehler
e) Keine dieser Mglichkeiten.
(15) Frage
Welches Ergebnis erhlt man, wenn man folgendes Programm kompiliert und
startet?
public class A {
public static void main(String[ ] args) {
int [ ][ ] a = {
{15, 14, 12},
{53, 46, 91},
{96, 72, 12},
{45, 34, 23}};
System.out.println(a[2][2]+ + a[1][2]);
253
}
}
a) 91 12
b) 12 91
c) Kompilierfehler
d) Laufzeitfehler
e) Keine dieser Mglichkeiten.
Lsungen
(1) Frage
Es besitzt 2 Elemente.
(2) Frage
(3) Frage
(5) Frage
Beim Deklarieren und Intitalisieren, darf auf der linken Seite in den eckigen Klammern nichts stehen. Es msste statt int [2][2] a, int [ ][ ] a stehen.
(6) Frage
Auf der linken Seite drfen in der eckigen Klammer keine Werte stehen
und auf der rechten Seite muss mindestens in der ersten Klammer ein
Wert stehen.
254
6 Arrays
(7) Frage
a, e Auf der linken Seite drfen in der eckigen Klammer keine Werte stehen
und auf der rechten Seite muss mindestens in der ersten Klammer ein
Wert stehen. Eine Array-Deklaration darf keine Grenangabe besitzen
und runde Klammern gibt es bei der Array-Deklaration und -Initalisierung nicht.
(8) Frage
(9) Frage
(10) Frage
An der Position a[2][2] befindet sich das Zahl 5 und an der Position
a[1][1] die Zahl 4.
(11) Frage
(12) Frage
Beim Deklarieren und Intitalisieren darf auf der linken Seite in den eckigen Klammern nichts stehen. Es msste statt int [2][2] a, int [ ][ ] a stehen.
(13) Frage
An der Position a[3][2] steht die Zahl 23 und an der Position a[2][2] die
Zahl 12.
(14) Frage
(15) Frage
An der Position a[2][2] steht die Zahl 12 und an der Position a[1][2] die
Zahl 91.
255
Wichtige Standardklassen
(Fundamental Classes)
256
Beinhaltet String s allerdings einen Wert, der sich nicht in einen int-Wert umwandeln lsst, kommt es zu einer NumberFormatException (vgl. Kapitel 8
Exceptions). Dies wird erst zur Laufzeit bemerkt, da es sich nicht um einen
Syntax-, sondern um einen Logikfehler handelt. Ein Syntaxfehler wrde bereits zur Kompilierzeit bemerkt und rot unterkringelt werden. Das gleiche gilt
fr den Fall, dass der String direkt in den Konstruktor eingegeben wird (new
Integer(gut)):
7.2
257
258
Wird allerdings versucht, eine Variable von einem greren primitiven Datentyp als int in den Konstruktor einzufgen, kommt es zu einem Kompilierfehler.
Dies ist z. B. in unten stehendem Beispiel der Fall: Es wird dem Konstruktor
ein Parameter vom Typ long bergeben. Dies funktioniert bereits zur Kompilierzeit nicht und zur Laufzeit wird ein Error geworfen (siehe Kapitel 8 Exceptions).
7.2
259
260
false
false
Zu Problemen kommt es auch, wenn der Parameter nicht vom Typ String
oder leer ist. Sollte der Rckgabetyp der Methode valueOf(String) ein primitiver Wert sein, fhrt dies ebenfalls zu Komplikationen.
7.2
261
Wrde dort allerdings String = gut stehen, wrde es nicht zu einem Kompilierfehler kommen, sondern zu einem Laufzeitfehler und einer NumberFormatException, da der Kompiler erst zur Laufzeit bemerkt, dass sich der String
nicht in einen passenden primitiven Datentyp berfhren lsst (vgl. Kapitel 8
Exceptions).
262
Zeile 1
Zeile 2
Zeile 3
Zeile 4
Zeile 5
7.2
263
System.out.println(b3);
System.out.println(b4);
System.out.println(b5);
}
}
a) Zeile 1
b) Zeile 2
c) Zeile 3
d) Zeile 4
e) Zeile 5
f) Keine dieser Mglichkeiten.
(2) Frage
a) Zeile 1
b) Zeile 2
c) Zeile 3
d) Zeile 4
e) Zeile 5
f) Keine dieser Mglichkeiten.
Zeile 1
Zeile 2
Zeile 3
Zeile 4
Zeile 5
264
(3) Frage
Zeile 1
Zeile 2
Zeile 3
Zeile 4
Zeile 5
a) Zeile 1
b) Zeile 2
c) Zeile 3
d) Zeile 4
e) Zeile 5
f) Keine dieser Mglichkeiten.
(4) Frage
a) Zeile 1
b) Zeile 2
Zeile 1
Zeile 2
Zeile 3
Zeile 4
Zeile 5
7.2
265
c) Zeile 3
d) Zeile 4
e) Zeile 5
f) Keine dieser Mglichkeiten.
(5) Frage
Zeile 1
Zeile 2
Zeile 3
Zeile 4
Zeile 5
Zeile 6
a) Zeile 1
b) Zeile 2
c) Zeile 3
d) Zeile 4
e) Zeile 5
f) Zeile 6
(6) Frage
Zeile 1
Zeile 2
Zeile 3
Zeile 4
Zeile 5
Zeile 6
266
}
}
a) Zeile 1
b) Zeile 2
c) Zeile 3
d) Zeile 4
e) Zeile 5
f) Zeile 6
g) Keine dieser Mglichkeiten.
(7) Frage
Zeile 1
Zeile 2
Zeile 3
Zeile 4
Zeile 5
Zeile 6
a) Zeile 1
b) Zeile 2
c) Zeile 3
d) Zeile 4
e) Zeile 5
f) Zeile 6
g) Keine dieser Mglichkeiten.
(8) Frage
7.2
267
Zeile 1
Zeile 2
Zeile 3
Zeile 4
Zeile 5
Zeile 6
}
}
a) Zeile 1
b) Zeile 2
c) Zeile 3
d) Zeile 4
e) Zeile 5
f) Zeile 6
g) Keine dieser Mglichkeiten.
(9) Frage
a) Zeile 1
b) Zeile 2
c) Zeile 3
d) Zeile 4
e) Zeile 5
f) Zeile 6
g) Keine dieser Mglichkeiten.
Zeile 1
Zeile 2
Zeile 3
Zeile 4
Zeile 5
Zeile 6
268
(10) Frage
Zeile 1
Zeile 2
Zeile 3
Zeile 4
Zeile 5
Zeile 6
a) Zeile 1
b) Zeile 2
c) Zeile 3
d) Zeile 4
e) Zeile 5
f) Zeile 6
g) Keine dieser Mglichkeiten.
(11) Frage
Welches Ergebnis erhlt man, wenn man folgendes Programm kompiliert und
startet?
public class A {
public static void main(String[ ] args) {
String s = 1;
Integer i = Integer.valueOf(s);
Byte b = Byte.valueOf(1);
Short sh = Short.valueOf(s);
Float f = Float.valueOf(s);
}
}
a) Kompilierfehler
b) Laufzeitfehler (NumberFormatException)
c) Keine dieser Mglichkeiten.
7.2
269
(12) Frage
Welches Ergebnis erhlt man, wenn man folgendes Programm kompiliert und
startet?
public class A {
public static void main(String[ ] args) {
String s = 1;
Integer i = Integer.valueOf(s);
Byte b = Byte.valueOf(1);
Short sh = Short.valueOf(s);
Float f = Float.valueOf(s);
}
}
a) Kompilierfehler
b) Laufzeitfehler (NumberFormatException)
c) Keine dieser Mglichkeiten.
(13) Frage
Welches Ergebnis erhlt man, wenn man folgendes Programm kompiliert und
startet?
public class A {
public static void main(String[ ] args) {
String s = eins;
Integer i = Integer.valueOf(s);
Byte b = Byte.valueOf(1);
Short sh = Short.valueOf(s);
Float f = Float.valueOf(s);
}
}
a) Kompilierfehler
b) Laufzeitfehler (NumberFormatException)
c) Keine dieser Mglichkeiten.
(14) Frage
Welches Ergebnis erhlt man, wenn man folgendes Programm kompiliert und
startet?
public class A {
public static void main(String[ ] args) {
String s = 1;
Integer i = Integer.valueOf(s);
byte b = Byte.valueOf(1);
Short sh = Short.valueOf(s);
270
a) Kompilierfehler
b) Laufzeitfehler (NumberFormatException)
c) Keine dieser Mglichkeiten.
(15) Frage
Zeile 1
Zeile 2
Zeile 3
Zeile 4
Zeile 5
a) Zeile 1
b) Zeile 2
c) Zeile 3
e) Zeile 5d)Zeile 4
f) Keine dieser Mglichkeiten.
(16) Frage
a) Zeile 1
b) Zeile 2
Zeile 1
Zeile 2
Zeile 3
Zeile 4
Zeile 5
7.2
271
c) Zeile 3
d) Zeile 4
e) Zeile 5
f) Keine dieser Mglichkeiten.
(17) Frage
Zeile 1
Zeile 2
Zeile 3
Zeile 4
Zeile 5
a) Zeile 1
b) Zeile 2
c) Zeile 3
d) Zeile 4
e) Zeile 5
f) Keine dieser Mglichkeiten.
(18) Frage
a) Zeile 1
b) Zeile 2
Zeile 1
Zeile 2
Zeile 3
Zeile 4
Zeile 5
Zeile 6
272
c) Zeile 3
d) Zeile 4
e) Zeile 5
f) Zeile 6
g) Keine dieser Mglichkeiten.
(19) Frage
Zeile 1
Zeile 2
Zeile 3
Zeile 4
Zeile 5
Zeile 6
a) Zeile 1
b) Zeile 2
c) Zeile 3
d) Zeile 4
e) Zeile 5
f) Zeile 6
g) Keine dieser Mglichkeiten.
(20) Frage
Zeile 1
Zeile 2
Zeile 3
Zeile 4
Zeile 5
Zeile 6
7.2
273
}
}
a) Zeile 1
b) Zeile 2
c) Zeile 3
d) Zeile 4
e) Zeile 5
f) Zeile 6
g) Keine dieser Mglichkeiten.
(21) Frage
274
(23) Frage
7.2
275
h) Double
Lsungen
(1) Frage
c, d, Die Wrapper-Klasse Boolean hat zwei Konstruktoren, einen mit ihrem eigenen
e
primitiven Datentyp (true oder false) und einen mit einem String als Parameter, in den man true oder false eingeben kann und nicht auf Gro- oder Kleinschreibung achten muss. Als Parameter kann auch irgendein Text oder der Defaultwert null eingegeben werden, wobei dann false als Ergebnis
zurckgegeben wird. Zu Kompilierfehlern kommt es allerdings in den Fllen,
in denen true oder falsegro geschrieben und nicht als String eingegeben wird.
Auerdem darf kein Wrapperobjekt als Parameter bergeben werden.
(2) Frage
(3) Frage
(4) Frage
Der Wrapper Character hat keinen Konstruktor mit einem String, sondern nur einen mit einem primitiven Char.
(7) Frage
(8) Frage
276
(9) Frage
d, e, Die Zahl 1 ist vom Typ int und wird nicht automatisch in den entsprechenden
f
kleineren primitiven Datentyp umgewandelt, dies wrde einen expliziten Cast
erfordern.
(10) Frage
String s = gut kann man nicht in einen Zahlenwert umwandeln, deswegen kommt es zu einer NumberFormatException.
(11) Frage
Es kommt zu keinem Kompilierfehler, da es korrekt ist, der Methode valueOf() einen String zu bergeben.
(12) Frage
In die Funktion valueOf(s) kann nur ein String als Parameter eingefgt
werden und kein anderer Datentyp wie z. B. int (Byte.valueOf(1);). Vergleichen Sie auch hierzu Lsung von Aufgabe 11.
(13) Frage
String s = eins kann man nicht in einen Zahlenwert umwandeln, deswegen kommt es zu einer NumberFormatException.
(14) Frage
Auf der linken Seite muss immer der WrapperTyp stehen, es darf nicht
der primitive Typ stehen (byte b = Byte.valueOf(1);), da die Funktion
valueOf(String s) einen Wrapper zurckgibt und keinen primitiven Datentyp.
(15) Frage
(16) Frage
(17) Frage
(18) Frage
Der Methode parseInt(String s) muss ein String als Parameter bergeben werden, es darf kein anderer Datentyp darin stehen, wie z. B. int
(long l = Long.parseLong(1);).
7.3
277
(19) Frage
(20) Frage
(21) Frage
Die Klassen Void, Boolean und Character sind keine Subklassen der
Klasse java.lang.Number und alle Wrapper-Klassen sind final und serialisierbar. Primitive Datentypen sind keine Objekte. Die Klasse Character hat nur einen Konstruktor mit ihrem eigenen primitiven Datentyp.
(22) Frage
Byte, Short, Integer, Long, Float und Double sind direkte Subklassen
der Klasse Number. Die Klassen Void, Boolean und Character sind
keine Subklassen der Klasse java.lang.Number.
(23) Frage
(24) Frage
278
7.3
279
4
4
1.2
1.2
Wird ein Parameter vom Typ short, byte oder char eingegeben, wird er automatisch in den Typ int umgewandelt. Bei Parametern unterschiedlichen Typs
wird der kleinere Typ in den greren Typ berfhrt. Sind also die Parameter
vom Typ int (1) und float (1.2f), erhlt man als Rckgabetyp float(1.0), sprich
das Ergebnis auf der Konsole wird mit Nachkommastellen ausgegeben.
public class MathClass {
public static void main(String[ ] args) {
//linker Parameter int, rechter Parameter float, Rckgabetyp
//float (Ergebnis 1.0)
System.out.println(Math.min(1, 1.2f));
//linker Parameter int, rechter Parameter double,
//Rckgabetyp double (Ergebnis 1.0)
System.out.println(Math.min(1, 1.2d));
}
}
Sie sehen unten: Die min()-Methode, in die zwei Parameter vom primitiven
Datentyp byte, short oder char eingegeben werden, hat den Rckgabetyp int,
da die Parameter automatisch in den primitiven Datentyp int umgewandelt
werden. So gibt die min()-Methode den primitiven Datentyp int zurck, auch
wenn die bergebenen Parameter vom Typ byte sind.
280
7.3
281
long m2 = Math.round(2.0d);
double m3 = Math.ceil(2.0f);
double m4 = Math.floor(2.0d);
System.out.println(m1);
System.out.println(m2);
System.out.println(m3);
System.out.println(m4);
}
}
Bei den Rundungsmethoden kommt es allerdings in den Fllen zu Problemen, in denen der Rckgabetyp von der Gre her kleiner ist als der Rckgabetyp der Methode. So ist der Rckgabetyp fr die Methode round(double
d) long, somit ist der Rckgabetyp int zu klein und fhrt zu Komplikationen.
Der Rckgabetyp von round(float f) ist int, es kann aber als Rckgabetyp
ohne weiteres long stehen, da dieser Datentyp grer ist und eine automatische Anpassung erfolgt. Der Rckgabetyp von ceil(double d) ist double, so
fhrt der Rckgabetyp float zu einem Kompilierfehler.
282
7.3
283
284
b) byte
c) int
d) long
e) float
f) double
(5) Frage
7.3
285
(8) Frage
Welches Ergebnis erhlt man, wenn man folgendes Programm kompiliert und
startet?
public class A {
public static void main(String[ ] args) {
long a = Math.round(2.2d);
int b = Math.round(2.2f);
double c = Math.floor(2.2d);
System.out.println(a + b + c);
}
}
a) 5.0
b) 6.0
c) 7.0
d) 8.0
e) Kompilierfehler
f) Keine dieser Mglichkeiten.
(9) Frage
Welches Ergebnis erhlt man, wenn man folgendes Programm kompiliert und
startet?
public class A {
public static void main(String[ ] args) {
long a = Math.round(-2.2d);
int b = Math.round(-2.2f);
double c = Math.floor(-2.2d);
System.out.println(a + b + c);
}
}
a) -5.0
b) -6.0
c) -7.0
d) -8.0
e) Kompilierfehler
f) Keine dieser Mglichkeiten.
286
(10) Frage
Welches Ergebnis erhlt man, wenn man folgendes Programm kompiliert und
startet?
public class A {
public static void main(String[ ] args) {
long a = Math.round(-2.2d);
int b = Math.round(-2.2f);
double c = Math.ceil(-2.2d);
System.out.println(a + b + c);
}
}
a) -5.0
b) -6.0
c) -7.0
d) -8.0
e) Kompilierfehler
f) Keine dieser Mglichkeiten.
(11) Frage
Welches Ergebnis erhlt man, wenn man folgendes Programm kompiliert und
startet?
public class A {
public static void main(String[ ] args) {
int a = Math.round(-2.2d);
int b = Math.round(-2.2f);
double c = Math.ceil(-2.2d);
System.out.println(a + b + c);
}
}
a) -5.0
b) -6.0
c) -7.0
d) -8.0
e) Kompilierfehler
f) Keine dieser Mglichkeiten.
7.3
287
(12) Frage
Welches Ergebnis erhlt man, wenn man folgendes Programm kompiliert und
startet?
public class A {
public static void main(String[ ] args) {
long a = Math.round(2.8d);
int b = Math.round(2.8f);
double c = Math.floor(2.8d);
System.out.println(a + b + c);
}
}
a) 5.0
b) 6.0
c) 7.0
d) 8.0
e) Kompilierfehler
f) Keine dieser Mglichkeiten.
(13) Frage
Welches Ergebnis erhlt man, wenn man folgendes Programm kompiliert und
startet?
public class A {
public static void main(String[ ] args) {
long a = Math.round(2.8d);
int b = Math.round(2.8f);
double c = Math.ceil(2.8d);
System.out.println(a + b + c);
}
}
a) 5.0
b) 6.0
c) 7.0
d) 8.0
e) Kompilierfehler
f) Keine dieser Mglichkeiten.
288
(14) Frage
Welches Ergebnis erhlt man, wenn man folgendes Programm kompiliert und
startet?
public class A {
public static void main(String[ ] args) {
long a = Math.round(5.6d);
int b = Math.round(-5.6f);
double c = Math.ceil(5.8d);
System.out.println(a + + b + + c);
}
}
a) 5 -6 6.0
b) 5 -5 6.0
c) 6 -6 6.0
d) 6 -5 6.0
e) Kompilierfehler
f) Keine dieser Mglichkeiten.
(15) Frage
Welches Ergebnis erhlt man, wenn man folgendes Programm kompiliert und
startet?
public class A {
public static void main(String[ ] args) {
long a = Math.round(5.6d);
int b = Math.round(-5.6f);
float c = Math.ceil(5.8d);
System.out.println(a + + b + + c);
}
}
a) 5 -6 6.0
b) 5 -5 6.0
c) 6 -6 6.0
d) 6 -5 6.0
e) Kompilierfehler
f) Keine dieser Mglichkeiten.
7.3
289
(16) Frage
Welches Ergebnis erhlt man, wenn man folgendes Programm kompiliert und
startet?
public class A {
public static void main(String[ ] args) {
long a = Math.round(-5.6d);
int b = Math.round(-5.6f);
double c = Math.ceil(-5.8d);
System.out.println(a + + b + + c);
}
}
a) -5 -6 -6.0
b) -5 -5 -6.0
c) -6 -6 -6.0
d) -6 -5 -6.0
e) Kompilierfehler
g) Keine dieser Mglichkeiten.
(17) Frage
Welches Ergebnis erhlt man, wenn man folgendes Programm kompiliert und
startet?
public class A {
public static void main(String[ ] args) {
double a = Math.abs(-6.7d);
float b = Math.abs(-6.6f);
int c = Math.abs(-5);
System.out.println(a + + b + + c);
}
}
a) 6 6 5
b) 6.7 6.6 5
c) -6.7 -6.6 -5
d) Kompilierfehler
e) Keine dieser Mglichkeiten.
290
(18) Frage
Welches Ergebnis erhlt man, wenn man folgendes Programm kompiliert und
startet?
public class A {
public static void main(String[ ] args) {
float a = Math.abs(-6.7d);
float b = Math.abs(-6.6f);
int c = Math.abs(-5);
System.out.println(a + + b + + c);
}
}
a) 6 6 5
b) 6.7 6.6 5
c) -6.7 -6.6 -5
d) Kompilierfehler
e) Keine dieser Mglichkeiten.
(19) Frage
Welches Ergebnis erhlt man, wenn man folgendes Programm kompiliert und
startet?
public class A {
public static void main(String[ ] args) {
double a = Math.abs(6.7d);
float b = Math.abs(6.6f);
int c = Math.abs(5);
System.out.println(a + + b + + c);
}
}
a) 6 6 5
b) 6.7 6.6 5
c) -6.7 -6.6 -5
d) Kompilierfehler
e) Keine dieser Mglichkeiten.
7.3
291
(20) Frage
Welches Ergebnis erhlt man, wenn man folgendes Programm kompiliert und
startet?
public class A {
public static void main(String[ ] args) {
double a = Math.round(-3.6d);
float b = Math.abs(-6.6f);
double c = Math.sqrt(4);
System.out.println(a + + b + + c);
}
}
a) -3 -6.6 2.0
b) -4 -6.6 2.0
c) -4 6.6 2.0
d) Kompilierfehler
e) Keine dieser Mglichkeiten.
(21) Frage
Welches Ergebnis erhlt man, wenn man folgendes Programm kompiliert und
startet?
public class A {
public static void main(String[ ] args) {
double a = Math.round(-3.6d);
float b = Math.abs(-6.6f);
double c = Math.sqrt(-4);
System.out.println(a + + b + + c);
}
}
a) -3 -6.6 2.0
b) -4 -6.6 2.0
c) -4 6.6 2.0
d) Kompilierfehler
e) Keine dieser Mglichkeiten.
292
(22) Frage
Welches Ergebnis erhlt man, wenn man folgendes Programm kompiliert und
startet?
public class A {
public static void main(String[ ] args) {
double a = Math.round(-3.6d);
float b = Math.abs(-6.6f);
float c = Math.sqrt(4);
System.out.println(a + + b + + c);
}
}
a) -3 -6.6 2.0
b) -4 -6.6 2.0
c) -4 6.6 2.0
d) Kompilierfehler
e) Keine dieser Mglichkeiten.
(23) Frage
Welches Ergebnis erhlt man, wenn man folgendes Programm kompiliert und
startet?
public class A {
public static void main(String[ ] args) {
double a = Math.min(-3.6d, 6.7d);
float b = Math.max(-6.6f, 5.6f);
int c = Math.min(-4, -5);
System.out.println(a + + b + + c);
}
}
a) 6.7 -6.6 -4
b) -3.6 5.6 -5
c) -3.6 -6.6 -5
d) Kompilierfehler
e) Keine dieser Mglichkeiten.
7.3
293
(24) Frage
Welches Ergebnis erhlt man, wenn man folgendes Programm kompiliert und
startet?
public class A {
public static void main(String[ ] args) {
double a = Math.min(-3.6d, 6.7d);
float b = Math.max(-6.6f, 5.6f);
byte c = Math.min((byte)-4,(byte) -5);
System.out.println(a + + b + + c);
}
}
a) 6.7 -6.6 -4
b) -3.6 5.6 -5
c) -3.6 -6.6 -5
d) Kompilierfehler
e) Keine dieser Mglichkeiten.
(25) Frage
Welches Ergebnis erhlt man, wenn man folgendes Programm kompiliert und
startet?
public class A {
public static void main(String[ ] args) {
double a = Math.min(-3.6d, 6.7d);
float b = Math.max(-6.6f, 5.6f);
int c = Math.min((byte)-4,(byte) -5);
System.out.println(a + + b + + c);
}}
a) 6.7 -6.6 -4
b) -3.6 5.6 -5
c) -3.6 -6.6 -5
d) Kompilierfehler
e) Keine dieser Mglichkeiten.
294
(26) Frage
Welches Ergebnis erhlt man, wenn man folgendes Programm kompiliert und
startet?
public class A {
public static void main(String[ ] args) {
double a = Math.min(-3.6d, 6.7d);
float b = Math.max(-6.6f, 5.6f);
int c = Math.min(s,g);
System.out.println(a + + b + + c);
}
}
Welches Ergebnis erhlt man, wenn man folgendes Programm kompiliert und
startet?
public class A {
public static void main(String[ ] args) {
double a = Math.min(-3.6d, 6.7d);
float b = Math.max(-6.6f, 5.6f);
char c = Math.min(s,g);
System.out.println(a + + b + + c);}}
Welches Ergebnis erhlt man, wenn man folgendes Programm kompiliert und
startet?
public class A {
public static void main(String[ ] args) {
7.3
295
Welche der unten stehenden Funktionen aus java.lang.Math ist keine statische Methode?
a) min
b) sin
c) sqrt
d) round
e) ceil
f) floor
g) Keine dieser Mglichkeiten.
(30) Frage
296
(31) Frage
Lsungen
(1) Frage
(2) Frage
(3) Frage
Die Methode round() hat fr den Parameter float den Rckgabetyp int
und fr den Parameter double den Rckgabtyp long.
(4) Frage
Die Methode round() hat fr den Parameter float den Rckgabetyp int
und fr den Parameter double den Rckgabtyp long.
7.3
297
(5) Frage
Die Methode random() gibt eine Zufallszahl vom Typ double zurck.
(6) Frage
(7) Frage
Die Methode random() gibt eine Zufallszahl vom Typ double zurck, die
grer oder gleich 0.0 oder kleiner 1.0 ist.
(8) Frage
Sie erhalten 6.0 als Ergebnis. Die Methode static double floor (double
d) rundet immer auf. Die Methode round mit den berladenen Versionen static int round(float f) und static long round(double d) addiert zuerst
0.5 zu der ursprnglichen Zahl und fhrt dann die Funktion floor durch.
Die Methode round() hat fr den Parameter float den Rckgabetyp int
und fr den Parameter double den Rckgabetyp long. Werden unterschiedliche Datentypen miteinander addiert, wird der kleinere in den
greren Typ berfhrt, so erhalten Sie eine Zahl vom Typ double zurck, da die Methode floor(double d) den Rckgabetyp double hat.
(9) Frage
Achtung: Es handelt sich hier um negative Zahlen. Sie erhalten -7.0 als
Ergebnis. Die Methode static double floor (double d) rundet immer auf.
Die Methode round mit den berladenen Versionen static int round(float
f) und static long round(double d) addiert zuerst 0.5 zu der ursprnglichen Zahl und fhrt dann die Funktion floor durch. Die Methode round()
hat fr den Parameter float den Rckgabetyp int und fr den Parameter
double den Rckgabetyp long. Werden unterschiedliche Datentypen
miteinander addiert, wird der kleinere in den greren Typ berfhrt, so
erhalten Sie eine Zahl vom Typ double zurck, da die Methode
floor(double d) den Rckgabetyp double hat.
(10) Frage
Das Resultat ist -6.0. Die Methode static double ceil (double d) rundet
immer ab. Die Methode round mit den berladenen Versionen static int
round(float f) und static long round(double d) addiert zuerst 0.5 zu der
ursprnglichen Zahl und fhrt dann die Funktion floor durch. Die Methode round() hat fr den Parameter float den Rckgabetyp int und fr
den Parameter double den Rckgabetyp long. Werden unterschiedliche
Datentypen miteinander addiert, wird der kleinere in den greren Typ
298
berfhrt, so erhalten Sie eine Zahl vom Typ double zurck, da die Methode ceil(double d) den Rckgabetyp double hat.
(11) Frage
(12) Frage
(13) Frage
Vergleichen Sie die Lsung von Aufgabe 10. Das Ergebnis lautet 9.0.
(14) Frage
Die Methode round() hat fr den Parameter float den Rckgabetyp int
und fr den Parameter double den Rckgabetyp long und die Methode
ceil(double d) hat den Rckgabetyp double. So erhalten Sie folgendes
Ergebnis: 6 -6 6.0.
(15) Frage
(16) Frage
Die Methode round() hat fr den Parameter float den Rckgabetyp int
und fr den Parameter double den Rckgabetyp long und die Methode
ceil(double d) hat den Rckgabetyp double. So erhalten Sie folgendes
Ergebnis: -6 -6 -5.0.
(17) Frage
Die Funktion abs() liefert den absoluten Wert einer Zahl: Sie geben eine
negative Zahl ein und erhalten eine positive. Es gibt vier berladene
Methoden mit den entsprechenden Rckgabetypen: static int abs(int i),
static long abs(long l), static float abs(float f), static double abs(double
d). So bekommen Sie als Ausgabe folgende Zahlen: 6.7 6.6 5.
(18) Frage
7.3
299
(19) Frage
Die Funktion abs() liefert den absoluten Wert einer Zahl: Sie geben eine
negative Zahl ein und erhalten eine positive. Es gibt vier berladene
Methoden mit den entsprechenden Rckgabetypen: static int abs(int i),
static long abs(long l), static float abs(float f), static double abs(double
d). So bekommen Sie als Ausgabe folgende Zahlen: 6.7 6.6 5.
(20) Frage
Die Methode round() rundet auf, die Methode abs() gibt den absoluten
Wert einer Zahl zurck und sqrt() gibt die Quadratwurzel als double zurck.
(21) Frage
(22) Frage
(23) Frage
Die Minimum-Methode gibt den kleinsten von zwei Werten zurck, wohingegen die Maximum-Methode den grten von zwei Werten zurckgibt. Es gibt jeweils vier berladene Methoden.
(24) Frage
Es gibt keine Funktion min fr den Typ byte, deshalb kommt es zu einem Kompilierfehler. Der entsprechende Rckgabetyp msste int lauten, da die eingegebene Zahl vom Typ byte automatisch in den Typ int
umgewandelt wird.
(25) Frage
Sie erhalten -3.6 5.6 -5 als Ausgabe. Siehe auch Lsung Aufgabe 24.
(26) Frage
300
(27) Frage
(28) Frage
(29) Frage
(30) Frage
(31) Frage
c, e, Folgende Methoden haben keinen Rckgabetyp int: sqrt(), random() und sin().
f
(32) Frage
Die Methoden min() und max() besitzen vier berladene Methoden vom
Typ int, long, float und double. Die sqrt()-Methode hat den Rckgabetyp
double und sie gibt fr eine negative Zahl oder fr NaN (not a Number)
NaN zurck.
301
Alle String-Objekte werden einem so genannten String-Pool hinzugefgt, wobei mit new immer ein neues String-Objekt mit einer neuen Adresse erzeugt
wird. Im Gegensatz hierzu wird bei einem String-Literal der String-Pool nach
einem exakt gleichen String durchsucht. Ist ein solcher vorhanden, wird ihm
eine Referenz auf den bereits vorhanden String zugewiesen. Sprich sie besitzen anschlieend beide eine Referenz auf das gleiche Objekt, sie haben
die gleiche Adresse. Dieser Umstand spielt beim Vergleich von String-Objekten, der weiter unten nher erlutert wird, eine Rolle.
Hier nun eine weitere Eigenschaft von String-Objekten: String-Objekte sind
im Gegensatz zu StringBuffer-Objekten unvernderbar. So ndern z. B. die
Methoden toUpperCase() oder toLowerCase(), die den String in Gro- oder
Kleinbuchstaben umwandeln sollen, nicht den vorhandenen String, sondern
erzeugen eine neuen String.
public class Texte {
public static void main(String[ ] args) {
String s = ich;
s.toUpperCase();
System.out.println(s);
}
}
Der neu entstandene String muss der Variablen s erneut zugewiesen werden, damit ICH in Grobuchstaben ausgegeben werden kann.
public class Texte {
public static void main(String[ ] args) {
String s = ich;
s = s.toUpperCase();
System.out.println(s);
}
}
302
10
11
Die Methode int indexOf(String str) gibt die Position eines Zeichens oder einer Zeichenkette wieder, wohingegen die Methode int indexOf(String str, int
303
fromIndex) erst ab einer bestimmten Stelle anfngt zu suchen. In unten stehendem Beispiel fngt sie erst an der Position 4 an zu suchen, an der Stelle,
an der das erste o steht. So wird das zweite i, an der Indexposition 10, als
Ergebnis ermittelt.
public class Texte {
public static void main(String[ ] args) {
String s = Mario, Mario;
int a = s.indexOf(i);
int b = s.indexOf(i, 4);
System.out.println(a);
System.out.println(b);
}
}
Wie wir unten sehen, funktioniert die Methode int lastIndexOf(String str) hnlich: Sie beginnt aber hinten zu suchen und zhlt die gefundene Position von
vorne durch. Die Methode int lastIndexOf(String str, int fromIndex) fngt erst
an der Position fromIndex an zu suchen. Die Stelle fromIndex wird aber wieder von vorne durchgezhlt.
public class Texte {
public static void main(String[ ] args) {
String s = Mario, Mario;
int a = s.lastIndexOf(i);
int b = s.lastIndexOf(i, 4);
System.out.println(a);
System.out.println(b);
}
}
304
305
306
b) concat
c) delete
d) substring
e) insert
f) sqrt
g) append
(2) Frage
Welches Ergebnis erhlt man, wenn man folgendes Programm kompiliert und
startet?
public class A {
public static void main(String[ ] args) {
String s = Fenster;
char b = s.charAt(3);
System.out.println(b);
}
}
a) ster
b) s
c) t
d) ter
e) n
f) nster
g) Kompilierfehler
(3) Frage
Welches Ergebnis erhlt man, wenn man folgendes Programm kompiliert und
startet?
public class A {
public static void main(String[ ] args) {
String s = Fenster;
String b = s.charAt(3);
System.out.println(b);
}
}
a) ster
307
b) s
c) t
d) ter
e) n
f) nster
g) Kompilierfehler
(4) Frage
Welches Ergebnis erhlt man, wenn man folgendes Programm kompiliert und
startet?
public class A {
public static void main(String[ ] args) {
String s = Fenster;
s.concat( zum Hof);
System.out.println(s); }
}
a) Fenster
b) Fenster zum Hof
c) Fensterzum Hof
d) Kompilierfehler
(5) Frage
Welches Ergebnis erhlt man, wenn man folgendes Programm kompiliert und
startet?
public class A {
public static void main(String[ ] args) {
String s = Fenster;
s = s.concat( zum Hof);
System.out.println(s);
}
}
a) Fenster
b) Fenster zum Hof
c) Fensterzum Hof
d) Kompilierfehler
308
(6) Frage
Welches Ergebnis erhlt man, wenn man folgendes Programm kompiliert und
startet?
public class A {
public static void main(String[ ] args) {
String s = Honig ;
s.trim();
s.concat( zum Frhstck);
System.out.println(s);
}}
Honig
c) Honig
d) Kompilierfehler
(7) Frage
Welches Ergebnis erhlt man, wenn man folgendes Programm kompiliert und
startet?
public class A {
public static void main(String[ ] args) {
String s = Honig ;
s = s.trim();
s.concat( zum Frhstck);
System.out.println(s);
}
}
Honig
c) Honig
d) Kompilierfehler
(8) Frage
Welches Ergebnis erhlt man, wenn man folgendes Programm kompiliert und
startet?
public class A {
public static void main(String[ ] args) {
String s = Honig ;
s = s.trim();
s = s.concat( zum Frhstck);
309
System.out.println(s);
}
}
Honig
c) Honig
d) Kompilierfehler
(9) Frage
Welches Ergebnis erhlt man, wenn man folgendes Programm kompiliert und
startet?
public class A {
public static void main(String[ ] args) {
String s = maus;
s = s.toUpperCase();
s = s.replace(u, i);
System.out.println(s);
}
}
a) maus
b) MAUS
c) MAIS
d) Kompilierfehler
(10) Frage
Welches Ergebnis erhlt man, wenn man folgendes Programm kompiliert und
startet?
public class A {
public static void main(String[ ] args) {
String s = maus;
s = s.toUpperCase();
s = s.replace(U, I);
System.out.println(s); }}
a) maus
b) MAUS
c) MAIS
310
d) Kompilierfehler
(11) Frage
Welches Ergebnis erhlt man, wenn man folgendes Programm kompiliert und
startet?
public class A {
public static void main(String[ ] args) {
String s = Das Haus ist neu!;
int i = s.indexOf(a);
System.out.println(s);
}
}
Welches Ergebnis erhlt man, wenn man folgendes Programm kompiliert und
startet?
public class A {
public static void main(String[ ] args) {
String s = Das Haus ist neu!;
int i = s.indexOf(a);
System.out.println(i);
}
}
311
(13) Frage
Welches Ergebnis erhlt man, wenn man folgendes Programm kompiliert und
startet?
public class A {
public static void main(String[ ] args) {
String s = Das Haus ist neu!;
int i = s.lastIndexOf(a);
System.out.println(i);
}
}
Welches Ergebnis erhlt man, wenn man folgendes Programm kompiliert und
startet?
public class A {
public static void main(String[ ] args) {
String s = Das Haus ist neu!;
int i = s.lastIndexOf(a, 3);
System.out.println(i);
}}
312
(15) Frage
Welches Ergebnis erhlt man, wenn man folgendes Programm kompiliert und
startet?
public class A {
public static void main(String[ ] args) {
String s = Das Haus ist neu!;
int i = s.lastIndexOf(a, 10);
System.out.println(i);
}
}
Welches Ergebnis erhlt man, wenn man folgendes Programm kompiliert und
startet?
public class A {
public static void main(String[ ] args) {
String s = Das Haus ist neu!;
int i = s.indexOf(a, 10);
System.out.println(i);
}
}
313
(17) Frage
Welches Ergebnis erhlt man, wenn man folgendes Programm kompiliert und
startet?
public class A {
public static void main(String[ ] args) {
String s = Die Sonne scheint!;
String a = s.substring(4);
String b = s.substring(4, 7);
System.out.println(a);
System.out.println(b);}}
Welches Ergebnis erhlt man, wenn man folgendes Programm kompiliert und
startet?
public class A {
public static void main(String[ ] args) {
String s = Honigmund;
String a = s.substring(7);
String b = s.substring(4, 7);
System.out.println(a);
System.out.println(b);
}
}
a) n g n
b) nd gmu
c) Kompilierfehler
d) Keine dieser Mglichkeiten.
(19) Frage
Welches Ergebnis erhlt man, wenn man folgendes Programm kompiliert und
startet?
public class A {
public static void main(String[ ] args) {
314
a) fa a
b) of o
c) a fa
d) o of
e) Kompilierfehler
f) Keine dieser Mglichkeiten.
(20) Frage
Welches Ergebnis erhlt man, wenn man folgendes Programm kompiliert und
startet?
public class A {
public static void main(String[ ] args) {
String s = Ledersofa;
String a = s.substring(6);
char b = s.charAt(6);
System.out.println(a);
System.out.println(b);
}
}
a) ofa s
b) sofa s
c) o ofa
d) ofa o
e) Kompilierfehler
f) Keine dieser Mglichkeiten.
Lsungen
(1) Frage
315
(2) Frage
Mit der Methode char charAt(int index) wird das Zeichen ermittelt, das
sich an einer bestimmten Indexposition befindet. Denken Sie daran,
dass die erste Indexposition 0 und nicht 1 ist.
(3) Frage
(4) Frage
(5) Frage
(6) Frage
(7) Frage
Strings sind unvernderbar. Es ist ein neuer String entstanden, bei dem
die Leerzeichen gelscht worden sind und dieses Ergebnis ist erneut
der Variablen s zugewiesen worden. Somit kommt es zur Ausgabe von
Honig, da s.concat( zum Frhstck) nicht einer neuen Variablen zugewiesen worden ist.
(8) Frage
Nach dem Lschen der Leerzeichen und dem Anhngen eines Textes
ist der String einer neuen Variablen zugewiesen worden, deswegen
kommt es zu der Ausgabe Honig zum Frhstck.
(9) Frage
316
(10) Frage
Der String ist in Grobuchstaben umgewandelt worden und anschlieend ist der Grobuchabe U durch I ersetzt worden.
(11) Frage
Achtung: Die Variable s wird auf dem Bildschirm ausgegeben und nicht
die Variable i.
(12) Frage
Achtung: Die Variable i wird auf dem Bildschirm ausgegeben und nicht
die Variable s. Die indexOf()-Methode stellt fest, an welcher Stelle sich
ein bestimmtes Zeichen befindet.
(13) Frage
Die lastIndexOf()-Methode stellt fest, an welcher Stelle sich ein bestimmtes Zeichen befindet, wobei sie allerdings nicht von vorne anfngt
zu suchen, sondern von hinten.
(14) Frage
Die Methode int lastIndexOf(String str, int fromIndex) fngt erst an der
Position fromIndex an zu suchen, aber durchsucht den String von hinten ab der Position fromIndex. Die Stelle fromIndex wird aber von vorne
durchgezhlt.
(15) Frage
Die Methode int lastIndexOf(String str, int fromIndex) fngt erst an der
Position fromIndex an zu suchen, aber durchsucht den String von hinten ab der Position fromIndex. Die Stelle fromIndex wird aber von vorne
durchgezhlt.
(16) Frage
Die Methode int indexOf(String str, int fromIndex) fngt erst ab einer bestimmten Stelle an zu suchen. So kommt als Lsung keine dieser Mglichkeiten in Frage, da erst ab der 10. Position gesucht wird und a nicht
gefunden werden kann. Das Ergebnis ist -1.
(17) Frage
7.5
317
(18) Frage
(19) Frage
(20) Frage
318
Wir haben also gesehen: Unter Kapazitt wird die potentielle Lnge, sprich
das Fassungsvermgen, verstanden und nicht die tatschliche Lnge. Wollen Sie einem StringBuffer direkt ein Stringobejekt oder einen String-Literal
zuweisen, wie z. B. StringBuffer buf = Ich bin ein String!, fhrt dies zu einem
Kompilierfehler.
Noch eine Methode: setLength(), mit der Sie die Lnge des StringBuffers verndern knnen. Wenden Sie diese Methode an, kann dies zur Folge haben,
dass der bereits existierende Text abgeschnitten wird. Nehmen wir unten stehendes Beispiel: Im Gegensatz zu String-Objekten lsst sich der ursprngliche StringBuffer verndern. Es entsteht kein neuer StringBuffer, der einer
Variablen zugewiesen werden muss. StringBuffers sind im Unterschied zu
Strings vernderbar.
public class VeraenderbarerText {
public static void main(String[ ] args) {
StringBuffer str = new StringBuffer(ich);
str.setLength(2);
System.out.println(str);
}
}
7.5
319
320
7.5
321
gelscht werden soll, darstellt. Das Zeichen, das sich an der Anfangsposition
befindet wird mit gelscht, wohingegen, das Zeichen an der Endposition ist
bereits das erste Element, das nicht mehr gelscht wird.
public class VeraenderbarerText {
public static void main(String[ ] args) {
StringBuffer str = new StringBuffer(Meinung);
str.deleteCharAt(1);
System.out.println(str);
str.delete(0, 2);
System.out.println(str);
}
}
Welches Ergebnis erhlt man, wenn man folgendes Programm kompiliert und
startet?
public class B {
public static void main(String[ ] args) {
StringBuffer str = new StringBuffer(Die Sonne scheint!);
str.setLength(3);
System.out.println(str);
322
Welches Ergebnis erhlt man, wenn man folgendes Programm kompiliert und
startet?
public class B {
public static void main(String[ ] args) {
StringBuffer str = new StringBuffer(Die Sonne scheint!);
str.getLength();
System.out.println(str);
}
}
Welches Ergebnis erhlt man, wenn man folgendes Programm kompiliert und
startet?
public class B {
public static void main(String[ ] args) {
StringBuffer str = new StringBuffer(Die Sonne scheint!);
int a = str.length();
System.out.println(a);
}
}
7.5
323
b) Die
c) 18
d) 34
e) Kompilierfehler
f) Keine dieser Mglichkeiten.
(4) Frage
Welches Ergebnis erhlt man, wenn man folgendes Programm kompiliert und
startet?
public class B {
public static void main(String[ ] args) {
StringBuffer str = new StringBuffer(heute);
str.append( morgen);
System.out.println(str);
}
}
a) heute
b) heute morgen
c) Kompilierfehler
d) Keine dieser Mglichkeiten.
(5) Frage
Welches Ergebnis erhlt man, wenn man folgendes Programm kompiliert und
startet?
public class B {
public static void main(String[ ] args) {
String str = new String(heute);
str.append( morgen);
System.out.println(str);
}
}
a) heute
b) heute morgen
c) Kompilierfehler
d) Keine dieser Mglichkeiten.
324
(6) Frage
Welches Ergebnis erhlt man, wenn man folgendes Programm kompiliert und
startet?
public class B {
public static void main(String[ ] args) {
String str = new String(heute);
str.concat(" morgen");
System.out.println(str);
}
}
a) heute
b) heute morgen
c) Kompilierfehler
d) Keine dieser Mglichkeiten.
(7) Frage
Welches Ergebnis erhlt man, wenn man folgendes Programm kompiliert und
startet?
public class B {
public static void main(String[ ] args) {
String str = new String(heute);
str = str.concat( morgen);
System.out.println(str);
}
}
a) heute
b) heute morgen
c) Kompilierfehler
d) Keine dieser Mglichkeiten.
(8) Frage
Welches Ergebnis erhlt man, wenn man folgendes Programm kompiliert und
startet?
public class B {
public static void main(String[ ] args) {
String s = new String(A);
s.concat(B);
StringBuffer str = new StringBuffer(A);
str.append(B);
7.5
325
System.out.println(s + str);
}
}
a) ABAB
b) AA
c) AAB
d) Kompilierfehler
e) Keine dieser Mglichkeiten.
(9) Frage
Welches Ergebnis erhlt man, wenn man folgendes Programm kompiliert und
startet?
public class B {
public static void main(String[ ] args) {
StringBuffer str = new StringBuffer(Haus);
str.insert(1, B);
System.out.println(str);
}
}
a) BHaus
b) HBaus
c) Kompilierfehler
d) Keine dieser Mglichkeiten.
(10) Frage
Welches Ergebnis erhlt man, wenn man folgendes Programm kompiliert und
startet?
public class B {
public static void main(String[ ] args) {
StringBuffer str = new StringBuffer(Haus);
str.delete(1, 2);
System.out.println(str);
}
}
a) Hs
b) Hus
c) us
326
d) Kompilierfehler
e) Keine dieser Mglichkeiten.
(11) Frage
Welches Ergebnis erhlt man, wenn man folgendes Programm kompiliert und
startet?
public class B {
public static void main(String[ ] args) {
StringBuffer str = new StringBuffer(Haus);
str.reverse();
System.out.println(str);
}
}
a) Haus
b) suaH
c) aus
d) Kompilierfehler
e) Keine dieser Mglichkeiten.
(12) Frage
7.5
327
d) trim
e) delete
f) insert
Lsungen
(1) Frage
Im Gegensatz zu der Klasse String, die nicht vernderbare Strings erstellt, knnen Objekte der Klasse StringBuffer verndert werden, ohne
dass dabei ein neues Objekt entsteht. Also wird in dieser Aufgabe das
ursprngliche Objekt verndert, indem die Gre auf 3 reduziert wird.
(2) Frage
(3) Frage
(4) Frage
Im Gegensatz zu der Klasse String, die nicht vernderbare Strings erstellt, knnen Objekte der Klasse StringBuffer verndert werden, ohne
dass dabei ein neues Objekt entsteht, somit wird der Inhalt des StringBuffers in heute morgen gendert.
(5) Frage
(6) Frage
(7) Frage
328
(8) Frage
(9) Frage
(10) Frage
Die Methode StringBuffer delete(int start, int end) lscht mehrere Zeichen, wobei int start die Anfangsposition und int end die Endposition der
Zeichenkette, die gelscht werden soll, darstellt. Das Zeichen, das sich
an der Anfangsposition befindet wird mit gelscht, wohingegen das Zeichen an der Endposition, bereits das erste Element ist, das nicht mehr
gelscht wird.
(11) Frage
(12) Frage
a, e, Die Methoden append(), insert() und delete() gehren zur Klasse StringBuffer.
f
(13) Frage
7.6 Stringkonkatenation
7.6.1 Verketten von Objekten der String-Klasse mit Objekten der
String-Klasse
Mit dem Operator + kann man an das Ende eines Strings ein anderes
String-Objekt anfgen. Wie Sie in unten stehendem Beispiel sehen knnen,
wird der String s an den String st angehngt.
public class Stringkonkatenation {
public static void main(String[ ] args) {
7.6
Stringkonkatenation
329
Das gleiche gilt fr Zahlen. In der Klasse java.lang.String ist der binre
Operator + berladen, das bedeutet, dass zwei Zahlen, die von Typ String
sind, nicht miteinander addiert werden. Stattdessen werden die Zahlen wie
Text behandelt und es wird, wie Sie unten sehen knnen, Text an Text gehngt. So erhalten Sie das Ergebnis 55 und nicht 10, da die zwei Zahlen nicht
zusammengezhlt werden.
public class Stringkonkatenation {
public static void main(String[ ] args) {
String s = new String(5);
System.out.println(s + s);
}
}
330
Stehen die beiden Zahlen vom Typ int am Anfang, sieht das Ergebnis anders
aus. Nun werden beide Zahlen miteinander addiert, da sie in diesem Fall
nicht automatisch in einen String abgendert werden, wobei aber nach der
Addition wieder ein String entsteht.
public class Stringkonkatenation {
public static void main(String[ ] args) {
String s = new String(Ich habe );
System.out.println(5 + 5 + s);
}
}
10Ich habe
7.6
Stringkonkatenation
331
Welches Ergebnis erhlt man, wenn man folgendes Programm kompiliert und
startet?
public class S {
public static void main(String[ ] args) {
String st = new String(1);
String s = new String(Die Summe ist: );
System.out.println(s + st + st);
}
}
Welches Ergebnis erhlt man, wenn man folgendes Programm kompiliert und
startet?
public class S {
public static void main(String[ ] args) {
StringBuffer st = new StringBuffer(1);
StringBuffer s = new StringBuffer(Die Summe ist: );
System.out.println(s + st + st);
}
}
332
Welches Ergebnis erhlt man, wenn man folgendes Programm kompiliert und
startet?
public class S {
public static void main(String[ ] args) {
StringBuffer st = new StringBuffer(1);
String s = new String (Die Summe ist: );
System.out.println(s + st + st);
}
}
Welches Ergebnis erhlt man, wenn man folgendes Programm kompiliert und
startet?
public class S {
public static void main(String[ ] args) {
StringBuffer st = new StringBuffer(1);
String s = new String (Die Summe ist: );
System.out.println(st + st + s);
}
}
7.6
Stringkonkatenation
333
(5) Frage
Welches Ergebnis erhlt man, wenn man folgendes Programm kompiliert und
startet?
public class S {
public static void main(String[ ] args) {
String s = new String( Die Summe ist: );
System.out.println(1+ 1 + s);
}
}
Welches Ergebnis erhlt man, wenn man folgendes Programm kompiliert und
startet?
public class S {
public static void main(String[ ] args) {
String st = new String(30);
String s = new String(20);
System.out.println(st + s);
}
}
a) 50
b) 3020
c) Kompilierfehler
d) Keine dieser Mglichkeiten.
(7) Frage
Welches Ergebnis erhlt man, wenn man folgendes Programm kompiliert und
startet?
public class S {
public static void main(String[ ] args) {
String st = new String(30);
String s = new String(20);
System.out.println(st + s + 20);
}
}
334
a) 70
b) 302020
c) Kompilierfehler
d) Keine dieser Mglichkeiten.
(8) Frage
Welches Ergebnis erhlt man, wenn man folgendes Programm kompiliert und
startet?
public class S {
public static void main(String[ ] args) {
String st = new String(30);
String s = new String(20);
System.out.println(30 + 20 + st + s);
}
}
a) 503020
b) 100
c) 30203020
d) Kompilierfehler
e) Keine dieser Mglichkeiten.
(9) Frage
Welches Ergebnis erhlt man, wenn man folgendes Programm kompiliert und
startet?
public class S {
public static void main(String[ ] args) {
String st = new String(30);
String s = new String(20);
System.out.println(st + s+ 30 + 20);
}
}
a) 302050
b) 100
c) 30203020
d) Kompilierfehler
e) Keine dieser Mglichkeiten.
7.6
Stringkonkatenation
335
Lsungen
(1) Frage
Mit dem Operator + kann man an das Ende eines Strings ein anderes
String-Objekt anfgen.
(2) Frage
(3) Frage
Zustzlich ist einiges zu beachten, wenn Objekte der Klasse StringBuffer durch den + Operator mit Objekten der Klasse String kombiniert werden. Steht das String-Objekt am Anfang, so werden die Objekte der
StringBuffer-Klasse implizit in ein String-Objekt umgewandelt.
(4) Frage
Wenn Objekte der Klasse StringBuffer durch den + Operator mit Objekten der Klasse String kombiniert werden und das StringBuffer-Objekt
am Anfang steht, kommt es zu einem Kompilierfehler.
(5) Frage
Wird ein String-Objekt mit int-Zahlen mit dem Operator + verknpft und
stehen die int-Zahlen am Anfang, werden diese beide Zahlen miteinander addiert, so erhalten Sie 2 Die Summe ist als Ergebnis.
(6) Frage
Mit dem Operator + kann man an das Ende eines Strings ein anderes
String-Objekt anfgen, so ist 3020 das Resultat.
(7) Frage
(8) Frage
Wird ein String-Objekt mit int-Zahlen mit dem Operator + verknpft und
stehen die int-Zahlen am Anfang, werden diese beide Zahlen miteinander addiert, so erhalten Sie 503020 als Ergebnis.
336
(9) Frage
337
338
kann also nicht den Inhalt von StringBuffer-Objekten mit der Methode equals
auf Gleichheit berprfen, da dies nicht den gewnschten Effekt hat.
public class Vergleich {
public static void main(String[ ] args) {
StringBuffer str = new StringBuffer(ich);
StringBuffer str1 = new StringBuffer (ich);
System.out.println(str == str1);
System.out.println(str.equals(str1));
}
}
339
Werden unterschiedliche Wrapper-Objekte gegenbergestellt, gibt die Methode equals() false zurck.
public class Vergleich {
public static void main(String[ ] args) {
Integer i = new Integer(7);
Long l = new Long(7);
System.out.println(i.equals(l));
}
}
Bei einem Vergleich mit == kommt es bei unterschiedlichen Wrappern zu einem Kompilierfehler.
340
Ein Vergleich mit der Methode equals() ist nicht mglich, da primitive Datentypen keine Methoden besitzen. Somit haben sie auch keine equals()-Methode.
341
Welches Ergebnis erhlt man, wenn man folgendes Programm kompiliert und
startet?
public class B {
public static void main(String[ ] args) {
long l = 2;
Long l1 = new Long(2);
boolean b = l1.equals(l);
boolean b1 = l1 == l;
System.out.println(b);
System.out.println(b1);
}
}
a) true true
b) true false
c) false true
d) false false
e) Kompilierfehler
(2) Frage
Welches Ergebnis erhlt man, wenn man folgendes Programm kompiliert und
startet?
public class B {
public static void main(String[ ] args) {
Long l = new Long(2);
Long l1 = new Long(2);
boolean b = l1.equals(l);
boolean b1 = l1 == l;
System.out.println(b);
System.out.println(b1);
}
}
a) true true
b) true false
c) false true
d) false false
342
e) Kompilierfehler
(3) Frage
Welches Ergebnis erhlt man, wenn man folgendes Programm kompiliert und
startet?
public class B {
public static void main(String[ ] args) {
String s = new String(neu);
String s1 = new String(neu);
boolean b = s.equals(s1);
boolean b1 = s == s1;
System.out.println(b);
System.out.println(b1);
}
}
a) true true
b) true false
c) false true
d) false false
e) Kompilierfehler
(4) Frage
Welches Ergebnis erhlt man, wenn man folgendes Programm kompiliert und
startet?
public class B {
public static void main(String[ ] args) {
String s = neu;
String s1 = new String(neu);
boolean b = s.equals(s1);
boolean b1 = s == s1;
System.out.println(b);
System.out.println(b1);
}
}
a) true true
b) true false
c) false true
d) false false
343
e) Kompilierfehler
(5) Frage
Welches Ergebnis erhlt man, wenn man folgendes Programm kompiliert und
startet?
public class B {
public static void main(String[ ] args) {
String s = neu;
String s1 = neu;
boolean b = s.equals(s1);
boolean b1 = s == s1;
System.out.println(b);
System.out.println(b1);
}
}
a) true true
b) true false
c) false true
d) false false
e) Kompilierfehler
(6) Frage
Welches Ergebnis erhlt man, wenn man folgendes Programm kompiliert und
startet?
public class B {
public static void main(String[ ] args) {
StringBuffer sb = new StringBuffer(neu);
StringBuffer sb1 = new StringBuffer(neu);
boolean b = sb.equals(sb1);
boolean b1 = sb == sb1;
System.out.println(b);
System.out.println(b1);
}
}
a) true true
b) true false
c) false true
d) false false
344
e) Kompilierfehler
(7) Frage
Welches Ergebnis erhlt man, wenn man folgendes Programm kompiliert und
startet?
public class B {
public static void main(String[ ] args) {
Integer i = new Integer(1);
Integer i1 = new Integer(1);
boolean b = i.equals(i1);
boolean b1 = i == i1;
System.out.println(b);
System.out.println(b1);
}
}
a) true true
b) true false
c) false true
d) false false
e) Kompilierfehler
(8) Frage
Welches Ergebnis erhlt man, wenn man folgendes Programm kompiliert und
startet?
public class B {
public static void main(String[ ] args) {
int i = 1;
Integer i1 = new Integer(1);
boolean b = i.equals(i1);
boolean b1 = i == i1;
System.out.println(b);
System.out.println(b1);
}
}
a) true true
b) true false
c) false true
d) false false
345
e) Kompilierfehler
(9) Frage
Welches Ergebnis erhlt man, wenn man folgendes Programm kompiliert und
startet?
public class B {
public static void main(String[ ] args) {
int i = 1;
long l = 1;
boolean b = i.equals(l);
System.out.println(b);
}
}
a) true
b) false
c) Kompilierfehler
(10) Frage
Welches Ergebnis erhlt man, wenn man folgendes Programm kompiliert und
startet?
public class B {
public static void main(String[ ] args) {
int i = 1;
long l = 1;
boolean b = i == l;
System.out.println(b);
}
}
a) true
b) false
c) Kompilierfehler
(11) Frage
Welches Ergebnis erhlt man, wenn man folgendes Programm kompiliert und
startet?
public class B {
public static void main(String[ ] args) {
Integer i = new Integer(1);
Long l = new Long (1);
boolean b = i == l;
346
a) true
b) false
c) Kompilierfehler
(12) Frage
Welches Ergebnis erhlt man, wenn man folgendes Programm kompiliert und
startet?
public class B {
public static void main(String[ ] args) {
Integer i = new Integer(1);
Long l = new Long (1);
boolean b = i.equals(l);
System.out.println(b);
}
}
a) true
b) false
c) Kompilierfehler
(13) Frage
Welches Ergebnis erhlt man, wenn man folgendes Programm kompiliert und
startet?
public class B {
public static void main(String[ ] args) {
String s = new String(neu);
StringBuffer sb = new StringBuffer (neu);
boolean b = s == sb;
System.out.println(b);
}
}
a) true
b) false
c) Kompilierfehler
347
(14) Frage
Welches Ergebnis erhlt man, wenn man folgendes Programm kompiliert und
startet?
public class B {
public static void main(String[ ] args) {
String s = new String(neu);
StringBuffer sb = new StringBuffer (neu);
boolean b = s.equals(sb);
System.out.println(b);
}
}
a) true
b) false
c) Kompilierfehler
(15) Frage
Welches Ergebnis erhlt man, wenn man folgendes Programm kompiliert und
startet?
public class B {
public static void main(String[ ] args) {
String s = new String(neu);
String sb = new String (neu);
boolean b = s.equals(sb);
System.out.println(b);
}
}
a) true
b) false
c) Kompilierfehler
(16) Frage
Welches Ergebnis erhlt man, wenn man folgendes Programm kompiliert und
startet?
public class B {
public static void main(String[ ] args) {
StringBuffer s = new StringBuffer(neu);
StringBuffer sb = new StringBuffer (neu);
boolean b = s.equals(sb);
System.out.println(b);
348
a) true
b) false
c) Kompilierfehler
(17) Frage
Welches Ergebnis erhlt man, wenn man folgendes Programm kompiliert und
startet?
public class B {
public static void main(String[ ] args) {
String s = neu;
String sb = neu;
boolean b = s.equals(sb);
System.out.println(b);
}
}
a) true
b) false
c) Kompilierfehler
(18) Frage
Welches Ergebnis erhlt man, wenn man folgendes Programm kompiliert und
startet?
public class B {
public static void main(String[ ] args) {
String s = neu;
String sb = neu;
boolean b = s == sb;
System.out.println(b);
}
}
a) true
b) false
c) Kompilierfehler
349
(19) Frage
Welches Ergebnis erhlt man, wenn man folgendes Programm kompiliert und
startet?
public class B {
public static void main(String[ ] args) {
StringBuffer s = new StringBuffer(neu);
StringBuffer sb = new StringBuffer (neu);
boolean b = s == sb;
System.out.println(b);
}
}
a) true
b) false
c) Kompilierfehler
(20) Frage
Welches Ergebnis erhlt man, wenn man folgendes Programm kompiliert und
startet?
public class B {
public static void main(String[ ] args) {
String s = new String (neu);
String sb = new String (neu);
boolean b = s == sb;
System.out.println(b);
}}
a) true
b) false
c) Kompilierfehler
(21) Frage
Vakatseite
g) Keine dieser Mglichkeiten.
(22) Frage
Lsungen
(1) Frage
Primitive Datentypen knnen weder mit der equals-Methode noch mit dem
Vergleichsoperator == mit Objekten der Wrapper-Klassen verglichen werden.
(2) Frage
Werden zwei Objekte der gleichen Wrapper-Klasse mit dem Vergleichsoperator == verglichen, werden nur die Referenzen verglichen und nicht der Inhalt, dies hat eine Ausgabe von false zur Folge. Vergleichen Sie allerdings
zwei Wrapper-Objekte mit der equals()-Methode, wird der Inhalt verglichen
und das Ergebnis ist true.
(3) Frage
Werden zwei String-Objekte mit dem Vergleichsoperator == verglichen, werden nur die Referenzen verglichen und nicht der Inhalt, wohingegen ein Vergleich von zwei String-Objekten mit der equals()-Methode den Inhalt vergleicht. So ist das Ergebnis true false.
(4) Frage
351
(5) Frage
(6) Frage
Beim Vergleich von StringBuffer-Objekten erhalten Sie bei beiden Vergleichen die Ausgabe von false, da die Methode equals() in der Klasse
StringBuffer nicht berschrieben wurde und somit auch nicht den Inhalt
der beiden StringBuffer-Objekte vergleicht.
(7) Frage
(8) Frage
(9) Frage
(10) Frage
(11) Frage
(12) Frage
(13) Frage
Objekte der Klasse String und der Klasse String-Buffer knnen nicht mit
dem Operator == verglichen werden.
352
(14) Frage
Werden String-Objekte mit StringBuffer-Objekten mit equals() miteinander in Beziehung gesetzt, erhalten Sie false als Ergebnis.
(15) Frage
(16) Frage
(17) Frage
(18) Frage
(19) Frage
Werden zwei StringBuffer-Objekte mit dem Vergleichoperator verglichen, gibt dies false zurck.
(20) Frage
(21) Frage
(22) Frage
In der StringBuffer-Klasse und der Klasse Number gibt es keine berschriebene equals()-Methode.
353
Exceptions
8.1 Begriffserluterung
Immer wieder tauchen in Programmen Fehler auf, Fehler, die entweder durch
externe Quellen entstehen oder durch den Programmierer selbst. Mgliche
Pannen knnen bei Datenbankabfragen auftauchen oder wenn dem Programmierer ein Denkfehler unterluft. Dann werden so genannte Exceptions
geworfen. Exceptions versuchen Schwierigkeiten abzufangen und zu lokalisieren, indem sie Fehlermeldungen auf dem Bildschirm ausgeben. Sie stehen im Gegensatz zu den bereits kennen gelernten Kompilierfehlern, die auf
Unrichtigkeiten bei der Syntax beruhen. Vergessen Sie also ein Komma oder
eine Klammer, wird keine Exception geworfen, sondern es kommt zu einem
Kompilierfehler. Und vergessen Sie bitte nicht, dass der Kompiler nicht alle
Ihre Fehler entdecken kann.
Hier knnen Sie einen Ausschnitt aus der API (Javadocs) sehen: Die Klasse
Exception und die Klasse Error sind Subklassen der Klasse Throwable.
354
8 Exceptions
Class
Throwable
Class
Exception
Class
Error
Class
RuntimeException
Verschiedene Subklassen,
die Checked Exceptions sind,
wie z. B. java.io.IOExceptions
Verschiedene Subklassen,
die RuntimeExceptions sind.
a) Checked Exceptions
Wir sehen also in oben stehender Abbildung: Alle Checked Exceptions sind
Subklassen der Klasse Exception. In unten stehender Tabelle stelle ich einige Checked Exceptions vor:
Exception
Beschreibung
ClassNotFoundException Sie wird geworfen, wenn eine bestimmte Klasse nicht vorhanden ist oder nicht gefunden wird.
IOException
Sie gehrt dem Package java.io und ist eine direkte Subklasse
der Klasse Exception.
FileNotFoundException Sie tritt auf, wenn eine Datei nicht vorhanden ist oder nicht gefunden werden kann. Sie ist eine direkte Subklasse der Klasse
IOException.
Sicherlich denken Sie jetzt: Warum kann ein Programmierer nicht direkt kontrollieren bzw. nur begrenzt Einfluss nehmen, ob es eine Datei gibt oder
355
nicht? Ganz einfach: In der Regel erstellen andere Personen zu einem anderen Zeitpunkt diese Dateien!
Class
Exception
Class
IOException (java.io)
Class
ClassNotFoundException
(java.lang)
Class FileNotFoundException
b) RuntimeExceptions
Wir erinnern uns, RuntimeExceptions beruhen in der Regel auf Denkfehlern
des Programmierers. In den folgenden Abschnitten werde ich einige RuntimeExceptions (Unchecked Exceptions) nher erlutern. Hier als erstes eine
Abbildung ber die Verwandschaftsverhltnisse der RuntimeExceptions:
Auch zu den Unchecked Exceptions gehren die Errors und ihre Subklassen
(vgl. hierzu auch Kapitel 9 Assertions).
356
8 Exceptions
Class
ClassCastException
Class
Exception
Class
ArithmeticException
Class
RuntimeException
Class
NullPointerException
Class
IllegalArgumentException
Class
IndexOutOfBoundsException
Class
NumberFormatException
Class
ArrayIndexOutOfBoundsException
(1) ClassCastException
Wir haben bereits eine RuntimeException kennen gelernt, und zwar die
ClassCastException (vgl. Kapitel 3.7 Subtyping und Casting von Objekten
ab Seite 114). Man kann ein Objekt der Vaterklasse nicht in ein Objekt der
Kindklasse umwandeln, auch mit einem Cast nicht. Dies merkt der Kompiler
nicht zur Kompilierzeit, sondern erst zur Laufzeit und es wird zur Laufzeit eine
ClassCastException geworfen. Bei einem Kompilierfehler wrde NetBeans
dies bereits bei der Eingabe anzeigen, indem es den Code rot unterkringelt,
was hier nicht der Fall ist.
357
(2) ArithmeticException
Begehen Sie den Fehler, in Java eine Zahl durch 0 dividieren zu wollen,
kommt es zu einem Problem, da man eine Zahl nicht durch 0 teilen kann. Es
wird eine ArithmeticException geworfen. Das gleiche gilt fr die Moduloberechnung (z. B. 10%0).
(3) ArrayIndexOutOfBoundsException
Diese Exception wird geworfen, wenn Sie auf ein Arrayelement zugreifen
wollen, das es nicht gibt. In unten stehendem Beispiel haben wir ein Array mit
zwei Elementen erstellt. Nun wollen wir dem dritten Element, das nicht existiert, einen Wert zuweisen, was zu einer ArrayIndexOutOfBoundsException
fhrt (vgl. Kapitel 6 Arrays ab Seite 241). Diese ist eine direkte Subklasse
358
8 Exceptions
(4) NumberFormatException
Eine NumberFormatException wird geworfen, wenn einem Wrapper-Konstruktor ein Wert bergeben wird, der sich nicht in eine Zahl umwandeln
lsst: So ist beispielsweise der String = gut nicht in die Zahl 2 umformbar
(vgl. Kapitel 7.2 Die Wrapper-Klassen (Hllklassen) ab Seite 255).
(5) IllegalArgumentException
Wird einer Methode ein ungltiger Wert bergeben, wird eine IllegalArgumentException geworfen.
359
360
8 Exceptions
b) Der finally-Block
Zustzlich zu den try- und catch-Blcken kann noch ein finally-Block stehen,
der auf jeden Fall ausgefhrt werden muss. Klassischerweise handelt es sich
hierbei um einen Programmcode, der reservierte Ressourcen freigibt, indem
er geffnete Dateien oder Programme schliet. Finally-Blcke haben nicht
die Aufgabe, Exceptions abzufangen. Es ist zu beachten, dass ein catchBlock nicht einem finally-Block folgen darf, da es andernfalls zu einem Kompilierfehler kommt.
public class Rechenfehler {
public static void main(String[ ] args) {
try{
int i = 0;
System.out.println(5/i);
}catch(ArithmeticException rechenFehler){
System.out.println(Dies ist eine ArithmeticException);
}finally {
System.out.println(Ich werde auf jeden Fall ausgefhrt);
}
}
}
Es darf zwar ein finally-Block mit einem try-Block alleine dastehen, sprich es
kommt zu keinem Kompilierfehler, aber zur Laufzeit wird trotzdem eine Exception geworfen und das Programm wird abgebrochen, da der finally-Block
keine Exception auffangen kann und dennoch in jedem Fall ausgefhrt wird.
Es wird also sowohl der try- und finally-Block abgearbeitet als auch zur Laufzeit eine Exception geworfen. In unserem Beispiel handelt es sich um eine
explizite Exception, die wir im nchsten Abschnitt nher betrachten wollen
(siehe Kapitel 8.4 Der throw-Ausdruck).
public class TryFinally {
public static void main(String[ ] args) {
try{
System.out.println(try);
throw new RuntimeException();
}finally{
System.out.println(finally);
}
}
}
361
Steht ein try- mit einem finally-Block alleine da, wird das Programm nicht abgebrochen, wenn, wie in unten stehendem Beispiel, im try-Block keine Exception geworfen wird. Es werden sowohl der try-Block als auch der finally-Block
problemlos abgearbeitet.
public class TryFinally {
public static void main(String[ ] args) {
try{
System.out.println(try);
}finally{
System.out.println(finally);
}
}
}
362
8 Exceptions
Befindet sich unterhalb des try-, catch und finally-Blocks noch Code, wird dieser nach Auffangen der Exception ausgefhrt.
public class ExpliziteException {
public static void main(String[ ] args) {
try{
throw new ArithmeticException();
}catch (ArithmeticException rechenfehler){
System.out.println(A );
}catch (RuntimeException fehler){
System.out.println(B );
}finally{
System.out.println(C );
}
System.out.println(D );
}
}
363
gabe nur A und C. Also bitte beachten Sie, dass eine Exception nur in einem
try-Block geworfen werden kann, es sei denn, Sie fgen in einen catch-Block
wieder einen vollstndigen try-catch-Block ein.
364
8 Exceptions
Sollten Sie die Methode mit der throws-Klausel in einer Subklasse berschreiben wollen, geht dies mit folgenden Klassen: Erstens mit allen RuntimeExceptions, den so genannten Unchecked Exceptions (einschlielich Errors). Zweitens mit der gleichen Exception der Checked Exceptions (hier die
FileNotFoundException) und den Subklassen dieser Exception. Wrde in der
Methode ausnahme( ) der Subklasse eine Exception, wie z. B. IOException,
geworfen werden, wrde es zu einem Kompilierfehler kommen, da diese Exception eine Superklasse zu FileNotFoundException ist.
public class ThrowsOverride extends ThrowsKlausel {
public static void main(String[ ] args) {
try{
ThrowsOverride neueAusnahme = new ThrowsOverride();
neueAusnahme.ausnahme();
}catch(Exception rechenfehler){
System.out.println(Ich fange!);
}
}
public void ausnahme()throws ArithmeticException{
throw new ArithmeticException();
}
}
365
Welches Ergebnis erhlt man, wenn man folgendes Programm kompiliert und
startet?
public class Fehler {
public static void main(String[ ] args) {
try{
throw new ArithmeticException();
}
catch (ArithmeticException rechenfehler){
System.out.println(Rechenfehler);
}
catch (Exception fehler){
System.out.println(Fehler);
}
finally{
System.out.println(finally);
}
System.out.println(Ende);
}
}
366
8 Exceptions
(2) Frage
Welches Ergebnis erhlt man, wenn man folgendes Programm kompiliert und
startet?
public class Fehler {
public static void main(String[ ] args) {
try{
throw new ClassCastException();
}
catch (ArithmeticException rechenfehler){
System.out.println(Rechenfehler);
}
catch (Exception fehler){
System.out.println(Fehler);
}
finally{
System.out.println(finally);
}
System.out.println(Ende);
}}
Welches Ergebnis erhlt man, wenn man folgendes Programm kompiliert und
startet?
public class Fehler {
public static void main(String[ ] args) {
try{
throw new ArithmeticException();
}
catch (ArithmeticException rechenfehler){
System.out.println(Rechenfehler );
}
finally{
System.out.println(finally);
}
catch (Exception fehler){
367
System.out.println(Fehler);
}
System.out.println(Ende);
}
}
Welches Ergebnis erhlt man, wenn man folgendes Programm kompiliert und
startet?
public class Fehler {
public static void main(String[ ] args) {
try{
throw new ClassCastException();
}
catch (ArithmeticException rechenfehler){
System.out.println(Rechenfehler );
}
catch (InterruptedException fehler){
System.out.println(Fehler);
}
finally{
System.out.println(finally);
}
System.out.println(Ende);
}
}
368
8 Exceptions
g) Laufzeitfehler
(5) Frage
Welches Ergebnis erhlt man, wenn man folgendes Programm kompiliert und
startet?
public class Fehler {
public static void main(String[ ] args) {
try{
throw new ClassCastException();
}
catch (ClassCastException fehler){
System.out.println(Fehler);
throw new ArithmeticException();
}
catch (ArithmeticException rechenfehler){
System.out.println(Rechenfehler);
}
finally{
System.out.println(finally);
}
System.out.println(Ende);
}
}
In unten stehendem Code wird eine Exception abgefangen, um welche handelt es sich?
public class Fehler {
public static void main(String[ ] args) {
try
{int[ ] a = new int[5];
a[5]= 2;
}catch (Exception fehler){
System.out.println(Fehler);
}
369
}
}
a) Error
b) RuntimeException
c) InterruptedException
d) ClassCastException
e) NullPointerException
f) ArrayIndexOutOfBoundsException
(7) Frage
Welches Ergebnis erhlt man, wenn man folgendes Programm kompiliert und
startet?
public class Fehler {
public static void main(String[ ] args) {
try{
System.out.println(try);
}finally{
System.out.println(finally);
}
}
}
a) try finally
b) finally try
c) finally
d) Laufzeitfehler
e) Kompilierfehler
f) Keine dieser Mglichkeiten.
(8) Frage
Welches Ergebnis erhlt man, wenn man folgendes Programm kompiliert und
startet?
public class Fehler {
public static void main(String[ ] args) {
try{
System.out.println(try);
}finally{
System.out.println(finally);
}
System.out.println(Ende);
370
8 Exceptions
}
Welches Ergebnis erhlt man, wenn man folgendes Programm kompiliert und
startet?
public class Fehler {
public static void main(String[ ] args) {
try{
System.out.println(try);
throw new RuntimeException();
}finally{
System.out.println(finally);
}
}
}
a) try finally
b) finally try
c) finally
d) Laufzeitfehler
e) Kompilierfehler
f) Keine dieser Mglichkeiten.
(10) Frage
Welches Ergebnis erhlt man, wenn man folgendes Programm kompiliert und
startet?
public class Fehler {
public static void main(String[ ] args) {
try{
throw new ClassCastException();
371
System.out.println(werfen);
}
catch (ArithmeticException rechenfehler){
System.out.println(fangen);
}
catch (ClassCastException fehler){
System.out.println(nochmals fangen);
}
finally{
System.out.println(Restarbeit);
}
System.out.println(Ende);
}
}
Welches Ergebnis erhlt man, wenn man folgendes Programm kompiliert und
startet?
public class Fehler {
public static void main(String[ ] args) {
try{
throw new ClassCastException();
}
catch (ArithmeticException rechenfehler){
System.out.println(fangen);
}
catch (ClassCastException fehler){
System.out.println(nochmals fangen);
}
finally{
System.out.println(Restarbeit);
}
System.out.println(Ende);
}
}
372
8 Exceptions
Welches Ergebnis erhlt man, wenn man folgendes Programm kompiliert und
startet?
import java.io.FileNotFoundException;
public class Fehler {
public static void main(String[ ] args) throws
FileNotFoundException {
try{
throw new FileNotFoundException();
}
catch (FileNotFoundException dokumentfehler){
System.out.println(fangen);
}
catch (ClassCastException fehler){
System.out.println(nochmals fangen);
}
finally{
System.out.println(Restarbeit);
}
System.out.println(Ende);
}
}
373
(13) Frage
Welches Ergebnis erhlt man, wenn man folgendes Programm kompiliert und
startet?
import java.io.FileNotFoundException;
public class Fehler {
public static void main(String[ ] args) throws
FileNotFoundException {
try{
throw new FileNotFoundException();
}
catch (ArithmeticException dokumentfehler){
System.out.println(fangen);
}
catch (ClassCastException fehler){
System.out.println(nochmals fangen);
}
finally{
System.out.println(Restarbeit);
}
System.out.println(Ende);
}
}
Welches Ergebnis erhlt man, wenn man folgendes Programm kompiliert und
startet?
import java.io.FileNotFoundException;
public class Fehler {
public static void main(String[ ] args) throw
FileNotFoundException {
try{
throw new FileNotFoundException();
}
catch (FileNotFoundException dokumentfehler){
System.out.println(fangen);
374
8 Exceptions
}
catch (ClassCastException fehler){
System.out.println(nochmals fangen);
}
finally{
System.out.println(Restarbeit);
}
System.out.println(Ende);
}
Welches Ergebnis erhlt man, wenn man folgendes Programm kompiliert und
startet?
public class Fehler {
public static void main(String[ ] args) {
try{
Fehler fehler = new Fehler ();
fehler.ausnahme();
}catch(FileNotFoundException fehler){
System.out.println(Ich fange!);
}
}
public void ausnahme() throws FileNotFoundException {
throw new FileNotFoundException();
}
}
a) Ich fange!
b) Kompilierfehler
c) Laufzeitfehler
d) Keine dieser Mglichkeiten.
375
(16) Frage
Welches Ergebnis erhlt man, wenn man folgendes Programm kompiliert und
startet?
public class Fehler {
public static void main(String[ ] args) {
try{
Fehler fehler = new Fehler ();
fehler.ausnahme();
}catch(FileNotFoundException fehler){
System.out.println(Ich fange!);
}
}
public void ausnahme(){
throw new FileNotFoundException();
}
}
a) Ich fange!
b) Kompilierfehler
c) Laufzeitfehler
d) Keine dieser Mglichkeiten.
(17) Frage
Welches Ergebnis erhlt man, wenn man folgendes Programm kompiliert und
startet?
public class Fehler {
public static void main(String[ ] args) {
try{
Fehler fehler = new Fehler ();
fehler.ausnahme();
}catch(ClassCastException fehler){
System.out.println(Ich fange!);
}
}
public void ausnahme() throws FileNotFoundException {
throw new FileNotFoundException();
}
}
a) Ich fange!
b) Kompilierfehler
376
8 Exceptions
c) Laufzeitfehler
d) Keine dieser Mglichkeiten.
(18) Frage
Welches Ergebnis erhlt man, wenn man folgendes Programm kompiliert und
startet?
public class Fehler {
public static void main(String[ ] args) {
FileNotFoundException fehler = new FileNotFoundException();
boolean a = fehler instanceof Throwable;
boolean b = fehler instanceof Exception;
System.out.println(a);
System.out.println(b);
}
}
a) true true
b) true false
c) false true
d) false false
e) Kompilierfehler
f) Keine dieser Mglichkeiten.
(19) Frage
Welches Ergebnis erhlt man, wenn man folgendes Programm kompiliert und
startet?
public class Fehler {
public static void main(String[ ] args) {
FileNotFoundException fehler = new
FileNotFoundException();
boolean a = fehler instanceof Throwable;
boolean b = fehler instanceof Error;
System.out.println(a);
System.out.println(b);}}
a) true true
b) true false
c) false true
d) false false
377
e) Kompilierfehler
f) Keine dieser Mglichkeiten.
(20) Frage
Welches Ergebnis erhlt man, wenn man folgendes Programm kompiliert und
startet?
public class Fehler {
public static void main(String[ ] args) {
FileNotFoundException fehler = new
FileNotFoundException();
Throwable throwable = new Throwable();
boolean a = throwable instanceof FileNotFoundException;
boolean b = fehler instanceof Throwable;
System.out.println(a);
System.out.println(b);
}
}
a) true true
b) true false
c) false true
d) false false
e) Kompilierfehler
f) Keine dieser Mglichkeiten.
(21) Frage
Welche der unten stehenden Klassen ist die direkte Superklasse von FileNotFoundException?
a) Exception
b) Error
c) Throwable
d) IOException
e) RuntimeException
f) IndexOutOfBoundsException
g) IllegalArgumentException
378
8 Exceptions
(22) Frage
Welche der unten stehenden Klassen ist die direkte Superklasse von Exception?
a) Exception
b) Error
c) Throwable
d) IOException
e) RuntimeException
f) IndexOutOfBoundsException
g) IllegalArgumentException
(23) Frage
Welche der unten stehenden Klassen ist die direkte Superklasse von NumberFormatException?
a) Exception
b) Error
c) Throwable
d) IOException
e) RuntimeException
f) IndexOutOfBoundsException
g) IllegalArgumentException
(24) Frage
Welche der unten stehenden Klassen ist die direkte Superklasse von ClassCastException?
a) Exception
b) Error
c) Throwable
d) IOException
e) RuntimeException
f) IndexOutOfBoundsException
g) IllegalArgumentException
379
(25) Frage
Welche Klasse der unten stehenden Klassen ist die direkte Superklasse von
NullPointerException?
a) Exception
b) Error
c) Throwable
d) IOException
e) RuntimeException
f) IndexOutOfBoundsException
g) IllegalArgumentException
Lsungen
(1) Frage
(2) Frage
(3) Frage
(4) Frage
(5) Frage
Das Array hat nur fnf Elemente, sie wollen aber auf das sechste zugreifen, so wird eine ArrayIndexOutOfBoundsException geworfen. Die
Vakatseite
erste Position eines Arrays ist 0, deswegen greifen Sie mit a[5] nicht auf das
fnfte, sondern auf das sechste Element zu. Nheres zu Arrays erfahren Sie
auch im Kapitel 6 Arrays ab Seite 241.
(7) Frage
Da im try-Block keine Exception geworfen wird, reicht es aus, nur einen finally-Block zu haben.
(8) Frage
Siehe auch Lsung Aufgabe 7. Es erscheint noch zustzlich das Wort Ende
auf der Konsole.
(9) Frage
a, d Sowohl der try- als auch der finally-Block werden ausgefhrt, es existiert allerdings kein catch-Block, der die geworfene RuntimeException auffangen
wrde.
(10) Frage
Nach der geworfenen Exception muss sofort ein catch-Block stehen. Es darf
kein anderer Code dazwischen stehen.
(11) Frage
(12) Frage
(13) Frage
Die Exception, die geworfen wird, wird nicht aufgefangen. Dies fhrt zu einem
Laufzeitfehler.
(14) Frage
Im Methodenkopf steht throw statt throws, dies wird bereits zur Kompilierzeit
bemerkt.
(15) Frage
Die Exception, die in der Methode ausnahme() geworfen wird, wird aufgefangen und Ich fange! wird ausgegeben.
381
(16) Frage
(17) Frage
(18) Frage
(19) Frage
Die Klasse Error ist zwar eine Subklasse von Throwable, aber keine Superklasse von Exception, deswegen kommt es zu einem Kompilierfehler.
(20) Frage
Die Klasse Throwable ist eine Superklasse von FileNotFoundException, was zur Aufgabe von false und true fhrt.
(21) Frage
(22) Frage
(23) Frage
(24) Frage
(25) Frage
382
8 Exceptions
383
Assertions
9.1 Begriffserluterung
Jetzt kommt die nchste Frage: Wie verhindern wir Programmierfehler? Eine
neben vielen Mglichkeiten dies zu tun, sind die Assertions. Assertions sind
ein einfaches Werkzeug zum Debuggen von Programmcode. Fr groe Projekte und komplexe Probleme gibt es allerdings zustzliche Lsungen, die
aber nicht Thema der Zertifizierung sind. Assertions dienen dazu, sicherzustellen, dass Methoden einer Klasse korrekt und ohne Fehler aufgerufen
werden. Wie geschieht dies? Es werden Bedingungen als Boolean-Ausdruck
formuliert, die erfllt werden mssen oder zum Abbruch des Programms fhren. Assertions werden nur aktiviert, solange ein Programm entwickelt und
erprobt wird, im Einsatz vor Ort beim Kunden werden sie deaktiviert. Sie ersetzen das bisher bliche Vorgehen, mit System.out.print( )-Befeh len mglichen Bugs auf die Spur zu kommen. System.out.print( )-Befehle musste
man nach der Debugging-Phase wieder lschen. Dies ist jetzt nicht mehr notwendig, da die Ausgabebefehle durch assert-Statements ersetzt und je nach
Bedarf an- oder ausgeschaltet werden.
Beginnen wir wieder mit einem Beispiel: Es soll ein negativer Preis verhindert
werden. Aber: Trifft die Bedingung nicht zu, so wird ein AssertionError geworfen. Es wird allerdings trotzdem der Satz Ich bin ein Stuhl! ausgegeben. Wre der Preis eine positive Zahl, wrde das Programm normal weiter laufen.
Die Klasse AssertionError ist eine direkte Subklasse von Error, die wiederum
eine Subklasse von Throwable ist, genauso wie die Klasse Exception (vgl.
Kapitel 8 Exceptions). So kann ein assert-Statement auch in einem trycatch-Block stehen, um zu verhindern, dass ein Programm abbricht, wenn ein
Assertion-Error geworfen wird.
384
9 Assertions
Sind die Assertions nicht aktiviert, luft das Programm, wie Sie unten sehen
knnen, normal weiter. Nun ist es dem Programm egal, ob der Preis positiv
oder negativ ist, da der assert-Ausdruck ignoriert wird. Weiter unten lernen
wir, wie Assertions an- und ausgeschaltet werden knnen.
public class Stuhl{
double preis;
public static void main(String[ ] args){
Stuhl stuhl = new Stuhl();
stuhl.stehen(-8.0);
}
private void stehen(double preis) {
System.out.println(Ich bin ein Stuhl!);
assert preis > 0.0;
}
}
Es gibt zwei Arten von Assertions: Die erste Form besteht aus einem assertStatement und einer Bedingung. Die Bedingung ist ein primitiver BooleanAusdruck, wie z. B. assert preis > 0;. Dem assert-Statement darf nichts anderes als ein Boolean-Ausdruck folgen, sprich, achten Sie insbesondere darauf, dass dort keine Zuweisung steht, da dies sonst, wie Sie in unten stehender Abbildung sehen knnen, zu einem Kompilierfehler fhrt. Dies ist ein
Syntaxfehler, der bereits zur Kompilierzeit bemerkt wird und zur Laufzeit einen Error wirft. Hierbei spielt es keine Rolle, ob die Assertions aktiviert oder
deaktiviert sind. Dort darf aber ein Methodenaufruf stehen, der einen Boolean-Wert zurckgibt.
9.1
Begriffserluterung
385
386
9 Assertions
9.4
387
sehen knnen links Run aus und suchen Sie die entsprechende Datei aus,
fr die Sie den Befehl -ea im Feld VM Options eingeben wollen.
388
9 Assertions
389
Welche Klasse der unten stehenden Klassen ist eine direkte Superklasse
von AssertionError?
a) Exception
b) Error
c) Throwable
d) IOException
e) RuntimeException
f) IndexOutOfBoundsException
g) IllegalArgumentException
h) Keine dieser Mglichkeiten.
(2) Frage
Welche der unten stehenden Befehle dienen dazu, Assertions fr Nicht-Systemdateien zu aktivieren?
a) - ea
b) - da
c) - esa
d) - dsa
e) -eda
f) -dea
g) Keine dieser Mglichkeiten.
390
9 Assertions
(3) Frage
Welche der unten stehenden Befehle dienen dazu, Assertions fr Systemdateien zu aktivieren?
a) - ea
b) - da
c) - esa
d) - dsa
e) -eda
f) -dea
g) Keine dieser Mglichkeiten.
(4) Frage
Welche der unten stehenden Befehle dienen dazu, Assertions fr Nicht-Systemdateien zu aktivieren?
a) -enableassertion
b) -disableassertions
c) -enablesystemassertions
d) -disablesystemassertions
e) -enablesystemassertion
f) -esa
g) Keine dieser Mglichkeiten.
(5) Frage
Welche der unten stehenden Befehle dienen dazu, Assertions fr Systemdateien zu aktivieren?
a) -enableassertion
b) -disableassertions
c) -enablesystemassertions
d) -disablesystemassertions
e) -enablesystemassertion
f) -esa
g) Keine dieser Mglichkeiten.
391
(6) Frage
Welche der unten stehenden Befehle dienen dazu, Assertions fr Nicht-Systemdateien zu aktivieren?
a) -enableassertions
b) -dsa
c) -enablesystemassertions
d) -ea
e) -enablesystemassertion
f) -esa
g) Keine dieser Mglichkeiten.
(7) Frage
Welche der unten stehenden Befehle dienen dazu, Assertions fr Systemdateien zu aktivieren?
a) -enableassertions
b) -dsa
c) -enablesystemassertions
d) -ea
e) -enablesystemassertion
f) -esa
g) Keine dieser Mglichkeiten.
(8) Frage
392
9 Assertions
393
Was wird bei unten stehendem Code, fr den Fall, dass die Assertions fr
diese Klasse aktiviert sind, auf der Konsole ausgegeben?
public class A{
int x;
public static void main(String[ ] args){
A a = new A();
a.mc(8);
}
public void mb(){
System.out.println(Ich bin ein Fehler);
}
private void mc(int x) {
System.out.println(Ich bin Methode mc);
assert x == 0;
}
}
394
9 Assertions
(15) Frage
Was wird bei unten stehendem Code, fr den Fall, dass die Assertions fr
diese Klasse aktiviert sind, auf der Konsole ausgegeben?
public class A{
int x;
public static void main(String[ ] args){
A a = new A();
a.mc(0);
}
public void mb(){
System.out.println(Ich bin ein Fehler);
}
private void mc(int x) {
System.out.println(Ich bin Methode mc);
assert x == 0;
}
}
Was wird bei unten stehendem Code, fr den Fall, dass die Assertions fr
diese Klasse nicht aktiviert sind, auf der Konsole ausgegeben?
public class A{
int x;
public static void main(String[ ] args){
A a = new A();
a.mc(8);
}
public void mb(){
System.out.println(Ich bin ein Fehler);
}
private void mc(int x) {
System.out.println(Ich bin Methode mc);
assert x == 0;
}
}
395
Was wird bei unten stehendem Code, fr den Fall, dass die Assertions fr
diese Klasse aktiviert sind, auf der Konsole ausgegeben?
public class A{
int x;
public static void main(String[ ] args){
A a = new A();
a.mc(0);
}
public void mb(){
System.out.println(Ich bin ein Fehler);
}
private void mc(int x) {
System.out.println(Ich bin Methode mc);
assert x = 0;
}
}
Was wird bei unten stehendem Code, fr den Fall, dass die Assertions fr
diese Klasse aktiviert sind, auf der Konsole ausgegeben?
public class A{
int x;
public static void main(String[ ] args){
A a = new A();
a.mc(0);
}
public void mb(){
System.out.println(Ich bin ein Fehler);
}
396
9 Assertions
private void mc(int x) {
System.out.println(Ich bin Methode mc);
assert x < 0;
}
Was wird bei unten stehendem Code, fr den Fall, dass die Assertions fr
diese Klasse aktiviert sind, auf der Konsole ausgegeben?
public class A{
int x;
public static void main(String[ ] args){
A a = new A();
a.mc(0);
}
public void mb(){
System.out.println(Ich bin ein Fehler);
}
private void mc(int x) {
System.out.println(Ich bin Methode mc);
assert x <= 0: mb();
}
}
397
b) assert i == 8;
c) assert i == 1: i;
d) assert i == 1: Fehler;
e) assert i == 1: i++;
f) Keine dieser Mglichkeiten.
(21) Frage
398
9 Assertions
Welche der unten stehenden Aussagen treffen, fr den Fall, dass Assertions
aktiviert sind, zu?
public class SwitchStruktur {
public static void main(String[ ] args) {
for (int j = 1; j < 5; j++){
switch (j){
case 1: System.out.println(1); break;
case 2: System.out.println(2); break;
case 3: System.out.println(3); break;
case 4: System.out.println(4); break;
default: assert false;
}
}
}
}
Welche der unten stehenden Aussagen treffen, fr den Fall, dass Assertions
aktiviert sind, zu?
public class SwitchStruktur {
public static void main(String[ ] args) {
for (int j = 1; j < 6; j++){
switch (j){
case 1: System.out.println(1); break;
399
Welche der unten stehenden Aussagen treffen, fr den Fall, dass Assertions
nicht aktiviert sind, zu?
public class SwitchStruktur {
public static void main(String[ ] args) {
for (int j = 1; j < 6; j++){
switch (j){
case 1: System.out.println(1); break;
case 2: System.out.println(2); break;
case 3: System.out.println(3); break;
case 4: System.out.println(4); break;
default: assert false;
}
}
}
}
400
9 Assertions
Lsungen
(1) Frage
(2) Frage
(3) Frage
Es ist der Befehl -esa, mit dem Sie Assertions fr Systemdateien aktivieren knnen.
(4) Frage
(5) Frage
c, f
(8) Frage
b, d Wenn der Boolean-Ausdruck einer Assertion false wird, wir ein AssertionError geworfen. Dies ist aber nur der Fall, wenn Assertions aktiviert
sind.
(9) Frage
(10) Frage
Nach dem Doppelpunkt darf keine Zuweisung stehen, da dies zu unerwnschten Nebeneffekten fhren kann.
401
(11) Frage
(12) Frage
Nach dem assert-Statement muss ein primitiver Boolean-Ausdruck stehen, es darf keine Zuweisung stehen.
(13) Frage
Nach dem assert-Statement muss ein primitiver Boolean-Ausdruck stehen, es darf keine Zuweisung (i++) stehen.
(14) Frage
b, d Da genau der Fall eintritt, der verhindert werden soll, wird ein AssertionError geworfen. Es wird aber trotzdem Ich bin Methode mc ausgegeben.
(15) Frage
Der Wert 0 entspricht genau dem Wert, der sichergestellt werden soll,
also kommt es nur zur Ausgabe von Ich bin Methode mc.
Vakatseite
(16) Frage
Sind die Assertions nicht aktiviert, wird das assert-Statement ignoriert, also
kommt es nur zur Ausgabe von Ich bin Methode mc.
(17) Frage
(18) Frage
b, d Es tritt genau der Fall ein, der verhindert werden soll, so wird ein AssertionError geworfen. Es kommt aber trotzdem zur Ausgabe von Ich bin Methode mc.
(19) Frage
(20) Frage
(21) Frage
(22) Frage
b, d Assertions lassen sich fr einzelne Klassen aktivieren und sie wurden mit
J2SE 1.4 eingefhrt. Assertions sollen keine Nebeneffekte haben und sie sollen nicht in Methoden verwendet werden, die public sind. Es sei denn in Fllen, in denen davon ausgegangen werden kann, dass sie niemals eintreten.
(23) Frage
a, c, Assertions sollen keine Nebeneffekte haben und sie sollen nicht in Methoden
d
verwendet werden, die public sind. Es sei denn in Fllen, in denen davon ausgegangen werden kann, dass sie niemals eintreten. Assertions sollen in Methoden verwendet werden, die private sind.
(24) Frage
403
Fr j=5 tritt der Default-Fall ein, deswegen wird zustzlich bei aktivierten
Assertions ein AssertionError geworfen.
(26) Frage
Fr j=5 tritt der Default-Fall ein, bei nicht aktivierten Assertions hat dies
keinerlei Fehler zur Folge.
404
9 Assertions
405
10
Threads
10.1 Begriffserluterung
Threads, zu deutsch Fden, sind quasi parallel ablaufende Aktivitten innerhalb eines Programms. So knnen Sie sich beispielsweise Ihr Textverarbeitungsprogramm vorstellen, in dem Sie gleichzeitig drucken und Ihren Text
formatieren knnen. Dem User wird hierbei vorgegaukelt, dass diese Prozesse gleichzeitig ablaufen. Tatschlich aber wechseln sie sich in der Bearbeitung plattformabhngig ab. Nehmen wir einmal an, Sie haben drei
Threads in Gang gebracht. So knnten die Threads wie folgt abgearbeitet
werden:
thread a
thread a
thread b
thread c
thread a
thread a
Wie Sie sehen knnen, ist keinerlei Systematik erkennbar. Die Threads werden abwechselnd aufgerufen und dieser Prozess ist herstellerabhngig.
Diese Reihenfolge kann theoretisch beeinflusst werden, indem wir hhere
Prioritten setzen, de facto ist dies aber plattformabhngig. Die Standardprioritt liegt bei 5 (Thread.NORM_PRIORITY), die minimale bei 1
(Thread_MIN_PRIORITY) und die hchste bei 10 (Thread.MAX_PRIORITY).
Threads sind plattformabhngig: Von Computer zu Computer und von Betriebssystem zu Betriebssystem knnen so unterschiedliche Ergebnisse die
Folge sein.
406
10
Threads
bung ab Seite 68 und das Kapitel 3.3 Interfaces und abstrakte Klassen
ab Seite 73. Hier zum besseren Verstndnis ein Auszug der Javadocs (Api):
10.2
407
}
}
Die Methode public void start( ) der Klasse Thread startet den Thread. Bei
b.start( ) wird zuerst die start( )-Methode ausgefhrt und dann automatisch
die run( )-Methode. Somit gibt die Klasse Run auf der Konsole den Satz Dies
ist ein Thread aus. Hierbei ist zu beachten, dass ein Thread nur einmal mit
der Methode start( ) zum Laufen gebracht werden kann, ein zweiter Versuch
fhrt zu einem Fehler (java.lang.IllegalThreadStateException). Wrde nun
b.start( ) durch b.run( ); ersetzt werden, kme es zur gleichen Ausgabe. Es
wrde allerdings kein Thread gestartet, sondern nur die run( )-Methode ausgefhrt werden.
Was passiert jedoch, wenn Sie vergessen das Run-Objekt an den Thread zu
bergeben? Dies fhrt lediglich zu keiner Ausgabe und zu keinem Kompilieroder Laufzeitfehler.
In diesem Zusammenhang ist es wichtig zu wissen, welche Thread-Konstruktoren es gibt. Hier ein Auszug aus der Api (Javadocs):
408
10
Threads
10.3
409
Wird nun aber der Thread meinThread mit der start( )-Methode ins Leben gerufen, wird der Name des Thread meinThread ausgegeben: eins.
public class MeinThread extends Thread{
MeinThread(String s){
super(s);
}
public void run(){
System.out.print(Thread.currentThread().getName());
}
public static void main(String[ ] args) {
410
10
Threads
MeinThread meinThread = new
MeinThread(eins);
//Der Thread wird gestartet!
meinThread.start();
}
}
10.4 Synchronisation
Es gibt manche Situationen, in denen es wnschenswert ist, dass nur ein
Thread auf eine gemeinsame Ressource zugreifen kann. So wre es z. B. fatal, wenn man von Ihrem Bankkonto gleichzeitig an mehreren Stellen, am
Bankautomat und am Schalter, Geld abheben und auf diese Art und Weise
der Kreditrahmen ohne Probleme berzogen werden knnte. Es ist sinnvoll,
wenn diese Vorgnge hintereinander stattfinden. Synchronisierte Methoden
und Blcke stellen dies sicher. Sind Daten synchronisiert und ist der Zugriff
auf die Daten sicher, nennt man diesen Zustand threadsicher. Es knnen nur
Blcke und Methoden synchronisiert werden und nicht Konstruktoren oder
Klassen (vgl. auch Kapitel 3.4 Modifier ab Seite 82). Versucht man es
trotzdem, kommt es zu einem Kompilierfehler.
Hier ein Beispiel fr Threads, die nicht synchronisiert sind. Wie Sie sehen
knnen, laufen die Threads nicht hintereinander ab, sondern in einer nicht
vorhersehbaren Reihenfolge. Der zweite Thread startet irgendwann, whrend der erste Thread noch luft. Die Ausgabe ist plattformabhngig und somit bei jedem Durchlauf eine andere.
public class SynchronizedThread extends Thread{
public static void main(String[ ] args) {
SynchronizedThread synchronizedThread1 = new
SynchronizedThread();
synchronizedThread1.start();
SynchronizedThread synchronizedThread2 = new
SynchronizedThread();
synchronizedThread2.start();
}
public void run() {
for (int i=0; i<200; i++ ){
System.out.println(i);
}
}
}
10.4
Synchronisation
411
412
10
Threads
}
}
Hier noch ein Beispiel eines gelockten Blocks. Jetzt werden zwei Threads,
die mit Hilfe des Runnable Interfaces erstellt wurden, gestartet.
public class Synchronized implements Runnable{
private static Object LOCK = new Object();
public void run( ) {
synchronized (LOCK) {
for (int i=0; i<200; i++){
System.out.println(i);
}
}
}
public static void main(String[ ] args) {
Synchronized synchronized1 = new Synchronized();
Thread a = new Thread(synchronized1);
Thread b = new Thread(synchronized1);
a.start();
b.start();
}
}
10.4
Synchronisation
413
Noch ein paar weitere Bemerkungen zur Synchronisation: Sie knnen auch
andere Objekte zum Synchronisieren benutzen. Nehmen Sie z. B. ein statisches String-Objekt, dann hat dies den gleichen Effekt wie ein statischer
Lock, da es das statische String-Objekt pro Klasse auch nur einmal gibt. Bei
String-Literalen verhlt es sich gleich, da String-Literale mit gleichem Inhalt,
auch nur ein einziges Mal im String-Pool vorkommen. Nur bei nicht statischen Stringobjekten ist es anders, jedes Objekt besitzt ein separates StringObjekt (vgl. Kapitel 7.4 Die Klasse String).
414
10
Threads
415
einmal beendet, kann er nicht wieder zum Leben erweckt werden, er ist tot.
Befindet sich ein Thread im wartenden Stadium, wartet er darauf, dass ihm
der Schlssel des Locks (zu deutsch: Schloss), den es nur einmal gibt,
bergeben wird.
In der folgenden Aufstellung werden alle wichtige Methoden die Threads betreffend in eine Systematik gebracht. Es ist fr das Zertifikat notwendig zu
wissen, welcher Klasse oder welchem Interface sie angehren:
Klasse java.lang.Object
Klasse java.lang.Thread
Interface Runnable
wait( )
notify( )
notifyAll( )
start( )
yield( ) (statische Methode)
sleep( ) (statische Methode)
join( )
run( )
Zunchst einige allgemein fr die Zertifizierung relevante Eigenschaften dieser Methoden: Den Methoden wait( ) und join( ) kann man einen Zeitparameter bergeben, wohingegen man der Methode sleep(long) einen Zeitparameter bergeben muss. Zustzlich gibt es Methoden, von denen abgeraten
wird, sie in Zukunft zu benutzen, die es aber noch gibt, sie sind deprecated
(resume, stop, suspend). Die Methoden wait( ), notify( ) und notifyAll( ) drfen nur in synchronisierten Blcken verwendet werden und die Methoden
sleep, join und wait mssen sich in einem try/catch-Block befinden und werfen eine InterruptedException.
416
10
Threads
In unten stehendem Beispiel knnen Sie sehen, wie zwischen der Ausgabe
von Hallo und eins mindestens 1 Sekunde (1000 Millisekunden) vergeht!
Als Parameter muss der Methode sleep(long) eine Zeitangabe bergeben
werden, um so einen Kompilierfehler zu verhindern. Ruft ein Thread die Methode sleep( ) in einem synchronisierten Code auf, gibt er das Lock nicht an
einen anderen Thread ab.
public class MeinFaden extends Thread{
public void run(){
try{
System.out.println(Hallo);
Thread.sleep(1000);
System.out.println(Thread.
417
Unten stehende Threads zeigen anhand eines Beispiels die Funktionen der
Methoden wait( ) und notify( ). Die Methode wait( ) stellt sicher, dass die forSchleife von der Klasse ThreadNotify bis zum Ende durchlaufen werden
418
10
Threads
kann. Ist die for-Schleife beendet, kommt notify( ) zum Zuge und die Klasse
ThreadWait luft weiter. Wir erhalten also als Ausgabe fr den letzten Eintrag
die Zahl 99. Die Methode notify( ) muss in einem synchronized-Block stehen,
der den Schlssel zu dem Lock des Objektes besitzen muss, das die wait( )Methode aufgerufen hat. So muss dort in unten stehendem Fall synchronized
(this) stehen. Ist dies nicht der Fall, wird eine java.lang.IllegalMonitorStateException geworfen. Das Thread-Objekt, das sich jeweils im ausfhrbaren Zustand befindet, verfgt ber den Schlssel des LOCKs. Beide Threads wechseln sich also mit dem Besitz ab.
class ThreadWait {
public static void main(String[ ] args) {
ThreadNotify n = new ThreadNotify();
n.start();
//wait() muss in einem synchronized und in
//einem try/catch-Block stehen
synchronized (n) {
try {
//wait() veranlasst das Programm zu warten
n.wait();
} catch (InterruptedException e) {
}
}
System.out.println(Der letzte Eintrag ist: + n.last);
}
}
class ThreadNotify extends Thread {
int last;
public void run() {
//notify() muss in einem synchronized Block
//stehen
synchronized (this) {
for (int i = 0; i < 100; i++) {
last = i;
}
//notify() benachrichtigt wait(), dass das Warten ein Ende hat
notify();
}
}
}
Was wrde passieren, wenn die wait( )-Methode fehlen wrde? Das Programm wrde nach dem Starten des Threads sofort, nach einmaligem
419
Durchlaufen der for-Schleife, weiterlaufen und die Funktion System.out.println(Der letzte Eintrag ist: + b.last); wrde ausgefhrt werden,
wobei dann auf der Konsole der Satz Der letzte Eintrag ist 0 erscheinen
wrde, wie Sie in unten stehendem Beispiel sehen knnen.
class ThreadWait {
public static void main(String[ ] args) {
ThreadNotify n = new ThreadNotify();
n.start();
System.out.println(Der letzte Eintrag ist: + n.last);
}
}
class ThreadNotify extends Thread {
int last;
public void run() {
synchronized (this) {
for (int i = 0; i < 100; i++) {
last = i;
}
notify();
}
}
}
420
10
Threads
421
(3) Frage
422
10
Threads
h) Thread.MAX_PRIORITY == 15
(6) Frage
Welche Methode muss bei public class MyRunnable implements Runnable{..} implementiert werden?
a) wait( )
b) sleep( )
c) join( )
d) notify( )
e) notifyAll( )
f) start( )
g) yield( )
h) run( )
(8) Frage
Welche Methode darf bei public class MyThread extends Thread{..} berschrieben werden?
a) wait( )
b) sleep( )
c) join( )
d) notify( )
e) notifyAll( )
f) start( )
g) yield( )
h) run( )
(9) Frage
a) Zeile 1
b) Zeile 2
c) Zeile 3
d) Zeile 4
e) Zeile 5
f) Zeile 6
g) Keine dieser Mglichkeiten.
Zeile 1
Zeile 2
Zeile 3
Zeile 4
Zeile 5
Zeile 6
423
424
10
Threads
(11) Frage
Zeile 1
Zeile 2
Zeile 3
Zeile 4
Zeile 5
Zeile 6
a) Zeile 1
b) Zeile 2
c) Zeile 3
d) Zeile 4
e) Zeile 5
f) Zeile 6
g) Keine dieser Mglichkeiten.
(12) Frage
a) Zeile 1
b) Zeile 2
c) Zeile 3
d) Zeile 4
Zeile 1
Zeile 2
Zeile 3
Zeile 4
Zeile 5
Zeile 6
Zeile 7
425
e) Zeile 5
f) Zeile 6
g) Zeile 7
h) Keine dieser Mglichkeiten.
(13) Frage
Welches Ergebnis erhlt man, wenn man folgendes Programm kompiliert und
startet?
public class Run implements Runnable{
public static void main(String[ ] args) {
Run a = new Run();
Thread b = new Thread(a);
b.start();
}
public void run() {
System.out.println(Dies ist ein Thread);}}
Welches Ergebnis erhlt man, wenn man folgendes Programm kompiliert und
startet?
public class Run implements Runnable{
public static void main(String[ ] args) {
Run a = new Run();
Thread b = new Thread();
b.start();
}
public void run() {
System.out.println(Dies ist ein Thread);
}
}
426
10
Threads
(15) Frage
Welche der folgenden Phasenbergnge zwischen den verschieden Threadstadien gibt es?
a) Vom beendeten Zustand zum Laufenden.
b) Vom ausfhrbaren Zustand in den laufenden Zustand.
c) Vom laufenden Zustand in den ausfhrbaren Zustand.
d) Vom laufenden Zustand in den beendeten Zustand.
e) Vom wartenden Zustand in den laufenden Zustand.
f) Vom wartenden Zustand in den ausfhrbaren Zustand.
(16) Frage
427
(18) Frage
Welches Ergebnis erhlt man, wenn man folgendes Programm kompiliert und
startet?
public class MyThread extends Thread{
public static void main(String[ ] args) {
MyThread myThread1 = new MyThread();
myThread1.start();
MyThread myThread2 = new MyThread();
myThread2.start();
}
public void run() {
synchronized (this) {
for (int i=0; i<10; i++ ){
428
10
Threads
System.out.println(i);
}
}
}
}
Welches Ergebnis erhlt man, wenn man folgendes Programm kompiliert und
startet?
public class MyThread extends Thread{
public static void main(String[ ] args) {
MyThread myThread1 = new MyThread();
myThread1.start();
MyThread myThread2 = new MyThread();
myThread2.start();
}
public void run() {
for (int i=0; i<10; i++ ){
System.out.println(i);
}
}
}
Welches Ergebnis erhlt man, wenn man folgendes Programm kompiliert und
startet?
public class MyThread extends Thread{
private static Object Lock = new Object();
429
Welches Ergebnis erhlt man, wenn man folgendes Programm kompiliert und
startet?
public class MyThread extends Thread{
public static void main(String[ ] args) {
MyThread myThread = new MyThread();
myThread.start();
myThread.start();
}
public void run() {
synchronized (this) {
for (int i=0; i<10; i++ ){
System.out.println(i);
}
}
}
}
430
10
Threads
Lsungen
(1) Frage
a, d, Die Methoden wait( ), notify( ) und notifyAll gehren zur Klasse Object.
e
(2) Frage
b, c, f, Folgende Methoden sind Teil der Klasse Thread: start(), yield(), sleep() und
g
join().
(3) Frage
Das Interface Runnable besitzt nur eine einzige Methode: die run()-Methode.
(4) Frage
b, g Die Methoden yield() und sleep() sind statische Methoden der Klasse
Thread.
(5) Frage
b, d Die Standardprioritt liegt bei 5 (Thread.NORM_PRIORITY), die minimale bei 1 (Thread_MIN_PRIORITY) und die hchste bei 10
(Thread.MAX_PRIORITY).
(6) Frage
Das Interface Runnable besitzt genau ein Methode, die Methode run(),
diese muss implementiert werden, wenn Sie in einer Klasse das Runnable Interface implementieren wollen.
431
(8) Frage
Wird eine Klasse durch die Klasse Thread mit extends erweitert, drfen
Sie die run()-Methode berschreiben, Sie mssen aber nicht.
(9) Frage
a, c Die Klasse Thread implementiert das Runnable Interface und sie besitzt
zwei statische Methoden: yield() und sleep(). Die Methode wait() gehrt
zu Klasse Object. Ein Thread kann nur einmal gestartet werden, und
zwar mit der Methode start() und nicht mit der Methode run().
(10) Frage
(11) Frage
(12) Frage
Die Methode start() darf nicht zweimal aufgerufen werden und dies wird
nicht zur Kompilierzeit bemerkt, sondern es kommt erst zur Laufzeit zu
einer IllegalThreadStateException.
(13) Frage
(14) Frage
Vakatseite
(15) Frage
b, c, Ein Thread kann zwischen folgenden Phasen wechseln: vom ausfhrbaren Zud, f stand in den laufenden Zustand, vom laufenden Zustand in den ausfhrbaren
Zustand, vom laufenden Zustand in den beendeten Zustand und vom wartenden Zustand in den ausfhrbaren Zustand.
(16) Frage
(17) Frage
(18) Frage
b, h Die Methoden notify() und notifyAll() wecken einen wartenden Thread auf.
(19) Frage
Der synchronized-Block msste mit einem Lock synchronisiert sein und nicht
mit this, so kommt es zu einer chaotischen Ausgabe.
(21) Frage
Die beiden Threads haben jeweils eine eigene Methode run() und die
Threads werden abwechselnd in plattformabhngiger Reihenfolge durchgefhrt.
(22) Frage
(23) Frage
Die Methode start() darf nicht zweimal aufgerufen werden und dies wird nicht
zur Kompilierzeit bemerkt, sondern es kommt erst zur Laufzeit zu einer IllegalThreadStateException.
433
11
Garbage Collection
11.1 Begriffserluterung
In der Programmiersprache Java gibt es einen Papierkorb in Form eines automatischen Aufrumvorgangs, der nicht mehr referenzierte Objekte einsammelt und vernichtet. Auf diese Art und Weise wird nicht mehr bentigter Speicher freigegeben. Kommt ein Objekt fr die Garbage Collection in Frage,
kann nicht genau vorhergesagt werden, wann und ob das Objekt tatschlich
beseitigt wird.
Nun schauen wir uns Schritt fr Schritt an, was genau passiert.
1. Schritt
434
11
Garbage Collection
In den Zeilen 5 und 6 sehen die Beziehungen zwischen Objekt und Referenzvariable wie folgt aus:
eins
zwei
Objekt
zeigt auf
zeigt auf
zeigt auf
s1
s2
Referenzvariable
2. Schritt
In Zeile 8 wird der Objektreferenz s1 = null zugewiesen, so zeigt auf das
Stringobjekt, das den Inhalt eins hat, keine Referenzvariable mehr, d. h. es
ist isoliert. Das Objekt ist nicht mehr erreichbar und kommt aus diesem Grund
fr die Garbage Collection in Frage.
eins
s1
zwei
Objekt
zeigt auf
zeigt auf
s2
Referenzvariable
zeigt auf
zeigt auf
null
Objekt
435
436
11
Garbage Collection
eins
zwei
Objekt
zeigt auf
zeigt auf
zeigt auf
s1
s2
Referenzvariable
2. Schritt
In Zeile 7 wird eine erneute Zuweisung durchgefhrt s2 = new String (drei),
was unten stehende Vernderungen zur Folge hat. Nun kommt das Objekt,
das den Inhalt zwei hat, fr die Garbage Collection in Frage.
eins
zwei
drei
437
Objekt
zeigt auf
zeigt auf
zeigt auf
s1
s2
Referenzvariable
Wird allerdings der Code wie unten stehend verndert, kommt das Stringobjekt mit dem Inhalt zwei bereits nach der Zeile 5 fr die Garbage Collection
in Frage, da nun das Stringobjekt mit dem Inhalt zwei isoliert dasteht.
public class GarbageCollector {
public static void main(String[ ] args) {
Zeile 1
Zeile 2
438
11
Garbage Collection
String s1 = new String(eins);
String s2 = new String(zwei);
s2 = new String(drei);
arbeite(s2);
Zeile 3
Zeile 4
Zeile 5
Zeile 6
}
private static void arbeite(String s2){
//Hier steht viel Code!
}
}
Zeile 1
Zeile 2
Zeile 3
Zeile 4
Zeile 5
Zeile 6
Lassen Sie uns nun schrittweise die einzelnen Vorgnge genauer betrachten:
1. Schritt
In den Zeilen 1 und 2 sehen die Beziehungen zwischen Objekt und Referenzvariable wie folgt aus:
Einsammeln
(oben)
Einsammeln
(unten)
zeigt auf
zeigt auf
zeigt auf
e1
e2
Referenzvariable
439
Objekt
2. Schritt
Ab Zeile 3 und 4 weist die Referenzvariable e1.e auf das Objekt e2 und die
Referenzvariable e2.e auf das Objekt e1.
Einsammeln
(oben)
Einsammeln
(unten)
e1.e
Objekt
e2.e
zeigt auf
zeigt auf
zeigt auf
e1
e2
Referenzvariable
3. Schritt
In Zeile 5 und 6 wird e1 und e2 dem Objekt null zugewiesen, wobei eine so
genannte Isolierte Insel ensteht. Von auen zeigt keine Referenz mehr auf
e1.e und e2.e. Sie sind also von auen nicht mehr erreichbar, obwohl sie untereinander noch gltige Referenzen besitzen.
440
11
Garbage Collection
Einsammeln
(oben)
Einsammeln
(unten)
e1.e
e2.e
e1
e2
Referenzvariable
zeigt auf
zeigt auf
zeigt auf
null
null
Objekt
441
ner berschriebenen finalize( )-Methode die Freigabe fr die Garbage Collection wieder rckgngig machen.
Eine Implementierung der finalize( )-Methode nennt sich Finalizer. Ruft der
Garbage Collector aber in jedem Fall den Finalizer auf? Nein! Man sollte sich
also niemals darauf verlassen. Die finalize( )-Methode wird u. U. niemals aufgerufen und die Garbage Collection nie durchgefhrt. Sollte die finalize( )Methode eine Exception werfen, wenn sie vom Garbage Collector aufgerufen
wird, und sollte diese nicht aufgefangen werden, so wird diese ignoriert und
das Objekt bleibt weiterhin freigegeben fr die Garbage Collection.
442
11
Garbage Collection
e1.arbeite(ja);
System.gc();
}
}
}
443
Welches Ergebnis erhlt man, wenn man folgendes Programm kompiliert und
startet?
public class E {
private String s;
public void hole(String s){
System.out.println(s);
}
protected void finalize (){
System.out.println(zerstre );
}
public static void main(String[ ] args) {
for (int i = 0; i < 2; i++){
E e1 = new E();
e1.hole(hole);
System.gc();
}
}
}
444
11
Garbage Collection
(5) Frage
Wann kommt das Stringobjekt mit dem Inhalt ich, das in Zeile 1 erstellt
wurde, fr die Garbage Collection in Frage?
public class G {
public static void main(String[ ] args) {
String s1 = new String(ich);
String s2 = new String(bin);
arbeite(s2);
s1 = s2;
}
private static void arbeite(String s) {
// Hier steht viel Code!
}
}
Zeile 1
Zeile 2
Zeile 3
Zeile 4
a) Zeile 1
b) Zeile 2
c) Zeile 3
d) Zeile 4
e) Keine dieser Mglichkeiten.
(6) Frage
Wann kommt das Stringobjekt mit dem Inhalt ich, das in Zeile 1 erstellt
wurde, fr die Garbage Collection in Frage?
public class G {
public static void main(String[ ] args) {
String s1 = new String(ich);
String s2 = new String(bin);
arbeite(s1);
s2 = s1;
}
private static void arbeite(String s) {
// Hier steht viel Code!
}}
a) Zeile 1
b) Zeile 2
c) Zeile 3
d) Zeile 4
e) Keine dieser Mglichkeiten.
Zeile 1
Zeile 2
Zeile 3
Zeile 4
445
(7) Frage
Wann kommt das Stringobjekt mit dem Inhalt ich, das in Zeile 1 erstellt
wurde, fr die Garbage Collection in Frage?
public class G {
public static void main(String[ ] args) {
String s1 = new String(ich);
String s2 = new String(bin);
s1 = s2;
arbeite(s1);
}
private static void arbeite(String s) {
// Hier steht viel Code!
}}
Zeile 1
Zeile 2
Zeile 3
Zeile 4
a) Zeile 1
b) Zeile 2
c) Zeile 3
d) Zeile 4
e) Keine dieser Mglichkeiten.
(8) Frage
Wieviele Objekte kommen nach Ablauf dieses Codes fr die Garbage Collection in Frage?
public class G {
public static void main(String[ ] args) {
String s1 = new String(ich);
String s2 = new String(bin);
String s3 = new String(ein);
String s4 = new String(Genie!);
s2 = s1;
s3 = s4;
s4 = s2;
}
}
a) 1
b) 2
c) 3
d) 4
e) Keine dieser Mglichkeiten.
446
11
Garbage Collection
(9) Frage
Wieviele Objekte kommen nach Ablauf dieses Codes fr die Garbage Collection in Frage?
public class G {
public static void main(String[ ] args) {
String s1 = new String(ich);
String s2 = new String(bin);
String s3 = new String(ein);
String s4 = new String(Genie!);
s2 = s1;
s3 = s4;
s4 = s2;
s1 = null;
}
}
a) 1
b) 2
c) 3
d) 4
e) Keine dieser Mglichkeiten.
(10) Frage
Wieviele Objekte kommen nach Ablauf dieses Codes fr die Garbage Collection in Frage?
public class G {
public static void main(String[ ] args) {
String s1 = new String(ich);
String s2 = new String(bin);
String s3 = new String(ein);
String s4 = new String(Genie!);
s2 = s1;
s3 = s4;
s4 = s2;
s3 = null;
}
}
a) 1
b) 2
c) 3
d) 4
e) Keine dieser Mglichkeiten.
447
(11) Frage
Wieviele Objekte kommen nach Ablauf dieses Codes fr die Garbage Collection in Frage?
public class G {
public static void main(String[ ] args) {
String s1 = new String(ich);
String s2 = new String(bin);
String s3 = new String(ein);
String s4 = new String(Genie!);
s2 = s1;
s3 = s2;
s4 = s2;
}
}
a) 1
b) 2
c) 3
d) 4
e) Keine dieser Mglichkeiten.
(12) Frage
Wieviele Objekte kommen nach Ablauf dieses Codes fr die Garbage Collection in Frage?
public class G {
public static void main(String[ ] args) {
String s1 = new String(ich);
String s2 = new String(bin);
String s3 = new String(ein);
String s4 = new String(Genie!);
s2 = s1;
s3 = s2;
s4 = new String(Hugo);
}
}
a) 1
b) 2
c) 3
d) 4
e) Keine dieser Mglichkeiten.
448
11
Garbage Collection
(13) Frage
Wieviele Objekte kommen nach Ablauf dieses Codes fr die Garbage Collection in Frage?
public class E {
E e;
public static void main(String[ ] args) {
E e1 = new E();
E e2 = new E();
E e3 = new E();
E e4 = new E();
e1.e = e2;
e2.e = e1;
e3 = null;
e4 = null;
}
}
a) 1
b) 2
c) 3
d) 4
e) Keine dieser Mglichkeiten.
(14) Frage
Wieviele Objekte kommen nach Ablauf dieses Codes fr die Garbage Collection in Frage?
public class E {
E e;
public static void main(String[ ] args) {
E e1 = new E();
E e2 = new E();
E e3 = new E();
E e4 = new E();
e1.e = e2;
e2.e = e1;
e1 = null;
e2 = null;
e3 = null;
e4 = null;
}
}
a) 1
b) 2
449
c) 3
d) 4
e) Keine dieser Mglichkeiten.
Lsungen
(1) Frage
Jede Klasse erbt die finalize( )-Methode der Klasse Object und sie kann
berschrieben werden. Die Implementierung der finalize( )-Methode
nennt sich Finalizer. Die letzte Methode, die auf einem Objekt vor dem
Einsammeln ausgefhrt wird, ist die finalize( )-Methode, wobei man
sich aber nicht darauf verlassen kann, dass es tatschlich zerstrt wird.
(2) Frage
Die Garbage Collection kann nicht erzwungen werden, man kann sie
nur bitten. Die finalize( )-Methode kann sowohl berladen als auch
berschrieben werden und sie kann nur einmal aufgerufen werden. So
genannte Isolierte Inseln kommen fr die Garbage Collection in Frage.
(3) Frage
Beachten Sie, dass dort nicht richtig steht. Alle Antworten sind richtig.
Die Implementierung der finalize( )-Methode nennt sich Finalizer. Die
letzte Methode, die auf einem Objekt ausgefhrt wird, ist die
finalize( )-Methode, bevor es eingesammelt wird, man kann sich aber
nicht darauf verlassen, dass dies tatschlich geschieht. Die Garbage
Collection kann nicht erzwungen werden, man kann sie nur bitten. Die
finalize( )-Methode wird von der Klasse Object geerbt.
(4) Frage
(5) Frage
(6) Frage
Vakatseite
(7) Frage
(8) Frage
Durch die Zuweisung von s2 = s1 ist das Objekt mit dem Inhalt bin isoliert,
und mit der Zuweisung s3 = s4 ist das Objekt mit dem Inhalt ein nicht mehr
erreichbar, somit kommen am Ende zwei Objekte fr die Garbage Collection
in Frage. Alle anderen Zuweisungen ndern nichts an der Erreichbarkeit der
Objekte.
(9) Frage
Die Zuweisung von s2 = s1 fhrt zur Isolierung des Objektes mit dem Inhalt
bin und die Zuweisung s3 = s4 macht das Objekt mit dem Inhalt ein unerreichbar. Somit kommen am Ende zwei Objekte fr die Garbage Collection in
Frage. Alle anderen Zuweisungen ndern nichts an der Erreichbarkeit der Objekte.
(10) Frage
Durch die Zuweisung von s2 = s1 ist das Objekt mit dem Inhalt bin nicht
mehr erreichbar, mit der Zuweisung s3 = s4 ist das Objekt mit dem Inhalt ein
abgeschnitten, und nach der Zuweisung s4 = s2 und s3 = null ist auch das
Objekt mit dem Inhalt Genie nicht mehr greifbar. Somit kommen am Ende
drei Objekte fr die Garbage Collection in Frage.
(11) Frage
Durch alle drei Zuweisungen wird ein Objekt isoliert, und alle Referenzen zeigen zum Schluss auf das Objekt mit dem Inhalt ich.
(12) Frage
Durch alle drei Zuweisungen wird ein Objekt abgeschnitten, die Referenzvariablen s1, s2 und s3 zeigen am Ende auf das Objekt mit dem Inhalt ich und
s4 zeigt auf das neue Stringobjekt mit dem Inhalt Hugo.
(13) Frage
451
(14) Frage
452
11
Garbage Collection
453
12
Das Collections-Framework
12.1 Begriffsbestimmung
Das Collections-Framework stellt Mglichkeiten, wie z. B. Sets, Maps oder
Listen, zur Verfgung, die es Ihnen erlauben, mehrere Objekte ein- und auszulesen. So ist beispielsweise ein Set ein Container, der mehrere Stringobjekte enthlt:
Set
String st = new String(Hallo);
String st1 = new String(Bye);
String st2 = new String(Auf Wiedersehen);
String st3 = new String(Goodbye);
454
12
Das Collections-Framework
Interface
Set
Class
LinkedList
Class
Hashset
Interface
SortedSet
Class
ArrayList
Class
Vector
Class
Linked
HashSet
Class
TreeSet
Interface
SortedMap
Class
Hashtable
Class
HashMap
Class
TreeMap
Class
LinkedHashMap
12.2
455
456
12
Das Collections-Framework
s.add(st);
s.add(st1);
s.add(st2);
s.add(st3);
//Elemente werden wieder ausgegeben
for (Iterator i = s.iterator();i.hasNext();){
Object o = i.next();
System.out.println(o);
}
}
}
12.2
457
}
}
b) TreeSet
Bei einem TreeSet werden die Elemente, im Gegensatz zu den anderen
Sets, in eine natrliche Ordnung gebracht, sprich in eine alphabetische.
Diese Reihenfolge hat aber zur Folge, dass ein TreeSet relativ langsam ist,
da das alphabetische Sortieren der Elemente Zeit braucht. In ein TreeSet
knnen Sie nur bestimmte Elemente einfgen, wie z. B. Objekte der Klasse
String, die das Comparable Interface implementiert. Weiter unten, im Kapitel
12.5, gehe ich genauer auf die Voraussetzungen ein, die ein Objekt, das in
ein TreeSet eingefgt wird, erfllen muss.
import java.util.TreeSet;
import java.util.Iterator;
public class CollectionSet {
public static void main(String[ ] args) {
TreeSet s = new TreeSet();
String st = new String(Hallo);
String st1 = new String(Bye);
String st2 = new String(Auf Wiedersehen);
String st3 = new String(Goodbye);
s.add(st);
s.add(st1);
s.add(st2);
s.add(st3);
for (Iterator i = s.iterator();i.hasNext();){
Object o = i.next();
System.out.println(o);
}
}
}
458
12
Das Collections-Framework
Element
String st = new String(delta);
String st1 = new String(aber);
String st2 = new String(beta);
a) LinkedList
Eine LinkedList ist zu bevorzugen, wenn fter innerhalb, in der Mitte oder am
Anfang und am Ende Elemente hinzugefgt oder gelscht werden mssen,
sofern nicht ber die Indexposition zugegriffen wird. Der Zugriff auf die Elemente mit Hilfe der Indexposition ist sehr langsam, da es sich intern nicht um
ein Array handelt, sondern um eine Zweifach-Verkettete-Liste, sprich jedes
Element ist ber seinen Vorgnger und Nachfolger innerhalb der Liste informiert.
Es ist die effizienteste Mglichkeit des Prinzips der identischen Reihenfolge
der Ein- und Ausgabe (FiFo = First in - First out) von allen Listen, Sets und
Maps. Auerdem gibt es Methoden, wie z. B. void addFirst(Object o) oder
Object removeFirst( ), die es ermglichen, am Anfang oder Ende, Elemente
hinzuzufgen oder zu lschen, ohne auf den Index zugreifen zu mssen.
import java.util.Iterator;
import java.util.LinkedList;
public class CollectionList {
public static void main(String[ ] args) {
LinkedList s = new LinkedList();
String st = new String(delta);
String st1 = new String(aber);
String st2 = new String(beta);
s.add(st);
s.add(st1);
s.add(st2);
for (Iterator i = s.iterator(); i.hasNext(); ) {
Object o = i.next();
System.out.println( o );
}
12.2
459
}
}
Will man nicht alle Elemente auslesen, sondern nur ein bestimmtes, an einer
speziellen Indexposition, bentigt man die Methode Object get (int index). In
unten stehendem Beispiel befindet sich an der Stelle 1 der String aber, da
wie bei Arrays bei 0 angefangen wird zu zhlen.
import java.util.LinkedList;
public class CollectionList {
public static void main(String[ ] args) {
LinkedList s = new LinkedList();
String st = new String(delta);
String st1 = new String(aber);
String st2 = new String(beta);
s.add(st);
s.add(st1);
s.add(st2);
Object o = s.get(1);
System.out.println( o );
}
}
b) ArrayList
Die ArrayList ist in den meisten Fllen die beste Implementierung aller Listen.
Man hat mit ihr einen indexierten und sehr schnellen wahlfreien Zugriff (random access). Eine ArrayList basiert auf einem Array, das in der Gre flexibel und dynamisch wachsen und schrumpfen kann.
c) Vector
Der Vector ist ein Array, das sich von der Gre her verndern kann. Er hat
zwar auch einen schnellen wahlfreien Zugriff (random access), ist aber langsamer als die ArrayList, da er synchronisiert, d. h. thread-safe (thread-sicher), ist (vgl. Kapitel 10 Threads).
460
12
Das Collections-Framework
Element
String w1 = hallo;
String w2 = bye;
12.3.1 Hashtable
Eine Hashtable ist synchronisiert und somit thread-sicher (thread-safe). Die
Elemente werden nicht sortiert, somit ist die Reihenfolge der Eingabe und
Ausgabe nicht identisch, wie Sie in unten stehendem Beispiel sehen knnen.
Dieses Mal habe ich das Interface Enumeration zur Hilfe genommen, um die
einzelnen
Objekte
der
Hashtable
auszulesen.
Die
Methode
hasMoreElements( ) stellt fest, ob es noch mehr Elemente in der Hashtable
gibt, die Methode nextElement( ) gibt die Schlssel zurck und die Methode
get(o) whlt den Eintrag an der entsprechenden Schlsselposition aus.
import java.util.Enumeration;
import java.util.Hashtable;
public class MapHashtable {
public static void main(String[ ] args) {
String s1 = 1;
String s2 = 2;
String w1 = hallo;
String w2 = bye;
Hashtable h = new Hashtable();
h.put(s1, w1);
h.put(s2, w2);
for (Enumeration en = h.keys(); en.hasMoreElements(); ) {
Object o = en.nextElement();
System.out.println(Schlssel: + o );
System.out.println(Wert: + h.get(o) );
}
12.3
461
}
}
Zu einer NullPointerException kommt es, wenn als Inhalt eines Feldes oder
eines Schlssels der Standardwert null eingegeben wird. Bei der HashMap
indes ist dies erlaubt.
462
12
Das Collections-Framework
12.3.3 TreeMap
Das TreeMap implementiert das SortedMap-Interface. Der Inhalt der Elemente wird nach dem Schlssel (key) in einer natrlichen Reihenfolge sortiert, also alphabetisch oder bei Zahlen aufsteigend. Sowohl beim TreeMap
als auch beim TreeSet knnen nur bestimmte Objekte eingefgt werden. Nheres hierzu finden Sie in unten stehendem Kapitel 12.5.
Keine Ordnung
LinkedHashSet
HashSet
TreeSet
ArrayList
HashMap
LinkedList
Hashtable
(thread-safe)
Vector (thread-safe)
LinkedHashMap
12.5
463
mentiert wird, und wie Sie anschlieend Objekte der Klasse Buch, z. B. dem
TreeSet, hinzufgen knnen.
public class Buch implements Comparable{
String autor;
public Buch(String a){
setAutor( a);
}
//Dieser Methode muss als Parameter ein Objekt bergeben werden
public int compareTo(Object o) {
/*Das bergebene Objekt wird in ein Objekt der Klasse
java.lang.Object umgewandelt und muss somit wieder
in ein Buch gecastet werden */
return autor.compareTo(((Buch)o).getAutor());
}
public String getAutor() {
return autor;
}
public void setAutor(String autor) {
this.autor = autor;
}
}
Wir haben eine Klasse Buch erstellt, die das Comparable Interface implementiert: Objekte dieser Klasse knnen Sie nun ohne Probleme in ein TreeSet einlesen. Htte die Klasse Buch das Interface Comparable nicht implementiert, wrde es zwar zur Kompilierzeit zu keinem Fehler fhren, aber zur
Laufzeit wrde eine Exception (ClassCastException) geworfen. Fr die
Klasse TreeMap muss analog vorgegangen werden. Objekte, die in ein TreeSet oder in ein TreeMap eingefgt werden, werden alphabetisch sortiert wieder ausgegeben.
import java.util.TreeSet;
public class TreeSetSortieren{
public static void main(String[ ] args) {
TreeSet s = new TreeSet();
Buch st = new Buch(delta);
Buch st1 = new Buch(aber);
Buch st2 = new Buch(beta);
s.add(st);
s.add(st1);
s.add(st2);
for (Object r:s){
System.out.println(((Buch)r).getAutor());
}
464
12
Das Collections-Framework
}
}
12.5
465
import java.util.Comparator;
public class BuchVergleich implements Comparator{
public int compare(Object o1, Object o2) {
/*Das bergebene Objekt wird in ein Objekt der Klasse
java.lang.Object umgewandelt und muss somit wieder in ein Buch
gecastet werden */
return (((Buch)o1).getAutor().compareTo(((Buch)o2).getAutor()));
}
}
Nun knnen Sie ein Objekt der so entstandenen Klasse, die das Comparator-Interface implementiert, dem berladenen TreeSet-Konstruktor als Parameter bergeben und diesem TreeSet knnen Sie anschlieend Buchobjekte hinzufgen.
466
12
Das Collections-Framework
import java.util.TreeSet;
public class TreeSetSortieren{
public static void main(String[ ] args) {
BuchVergleich b = new BuchVergleich();
TreeSet s = new TreeSet(b);
Buch st = new Buch(delta);
Buch st1 = new Buch(aber);
Buch st2 = new Buch(beta);
s.add(st);
s.add(st1);
s.add(st2);
for (Object r:s){
System.out.println(((Buch)r).getAutor());
}
}
}
467
Welches Ergebnis erhlt man, wenn man folgendes Programm kompiliert und
startet?
public class Auto{
}
import java.util.*;
public class Collections {
public static void main(String[ ] args) {
LinkedHashMap l = new LinkedHashMap();
Auto auto = new Auto();
System.out.println(l instanceof Auto);
System.out.println(l instanceof Map);
System.out.println(l instanceof Object);
}
}
Welches Ergebnis erhlt man, wenn man folgendes Programm kompiliert und
startet?
import java.util.*;
public class Collections {
public static void main(String[ ] args) {
LinkedHashSet l = new LinkedHashSet();
System.out.println(l instanceof Collection);
System.out.println(l instanceof Map);
System.out.println(l instanceof Object);
}
}
468
12
Das Collections-Framework
Welches Ergebnis erhlt man, wenn man folgendes Programm kompiliert und
startet?
import java.util.*;
public class Collections {
public static void main(String[ ] args) {
LinkedList l = new LinkedList();
System.out.println(l instanceof Collection);
System.out.println(l instanceof Map);
System.out.println(l instanceof Object);
}
}
469
(4) Frage
Welches Ergebnis erhlt man, wenn man folgendes Programm kompiliert und
startet?
import java.util.*;
public class Collections {
public static void main(String[ ] args) {
Hashtable l = new Hashtable();
System.out.println(l instanceof Collection);
System.out.println(l instanceof Map);
System.out.println(l instanceof Object);
}
}
Welches Ergebnis erhlt man, wenn man folgendes Programm kompiliert und
startet?
import java.util.*;
public class Collections {
public static void main(String[ ] args) {
ArrayList l = new ArrayList();
System.out.println(l instanceof Collection);
System.out.println(l instanceof Map);
System.out.println(l instanceof List);
}
}
470
12
Das Collections-Framework
Welches Ergebnis erhlt man, wenn man folgendes Programm kompiliert und
startet?
import java.util.*;
public class Collections {
public static void main(String[ ] args) {
TreeMap l = new TreeMap();
System.out.println(l instanceof Collection);
System.out.println(l instanceof Map);
System.out.println(l instanceof SortedMap);
}
}
Welches Ergebnis erhlt man, wenn man folgendes Programm kompiliert und
startet?
import java.util.*;
public class Collections {
public static void main(String[ ] args) {
Vector l = new Vector();
System.out.println(l instanceof Set);
System.out.println(l instanceof Map);
System.out.println(l instanceof List);
471
}
}
Welches Ergebnis erhlt man, wenn man folgendes Programm kompiliert und
startet?
import java.util.*;
public class Collections {
public static void main(String[ ] args) {
LinkedList l = new LinkedList();
System.out.println(l instanceof Set);
System.out.println(l instanceof Map);
System.out.println(l instanceof List);
}
}
472
12
Das Collections-Framework
(9) Frage
Welches Ergebnis erhlt man, wenn man folgendes Programm kompiliert und
startet?
import java.util.*;
public class Collections {
public static void main(String[ ] args) {
TreeSet l = new TreeSet();
System.out.println(l instanceof SortedSet);
System.out.println(l instanceof Map);
System.out.println(l instanceof List);
}}
Welches Ergebnis erhlt man, wenn man folgendes Programm kompiliert und
startet?
import java.util.*;
public class Collections {
public static void main(String[ ] args) {
HashSet l = new HashSet();
System.out.println(l instanceof SortedSet);
System.out.println(l instanceof Map);
System.out.println(l instanceof List);
}}
473
Welche der unten stehenden Klassen ermglicht es, die Elemente in der gleichen Reihenfolge auszugeben, in der sie eingegeben worden sind?
a) Hashtable
b) HashMap
c) TreeMap
d) HashSet
e) TreeSet
f) Keine dieser Mglichkeiten.
(12) Frage
Welche der unten stehenden Klassen ermglicht es, die Elemente in der gleichen Reihenfolge auszugeben, in der sie eingegeben worden sind?
a) Hashtable
b) LinkedHashMap
c) TreeMap
d) LinkedHashSet
e) TreeSet
f) Keine dieser Mglichkeiten.
(13) Frage
474
12
Das Collections-Framework
Welche der unten stehenden Klasse, die das List-Interface implementiert, ermglicht es, die Elemente in der gleichen Reihenfolge auszugeben, in der sie
eingegeben worden sind?
a) Hashtable
b) LinkedHashMap
c) TreeMap
d) LinkedHashSet
e) TreeSet
f) Keine dieser Mglichkeiten.
(16) Frage
Welche der unten stehenden Klassen ist die effizienteste Umsetzung des
Prinzips First in - First out?
a) Hashtable
b) LinkedHashMap
c) TreeMap
d) LinkedHashSet
e) TreeSet
f) Keine dieser Mglichkeiten.
475
(17) Frage
Welche der unten stehenden Klassen ist die effizienteste Umsetzung des
Prinzips First in - First out?
a) Hashtable
b) LinkedList
c) TreeMap
d) LinkedHashSet
e) TreeSet
f) Keine dieser Mglichkeiten.
(18) Frage
Welche der unten stehenden Klassen ermglicht es, am Anfang oder Ende
Elemente hinzuzufgen oder zu lschen, ohne auf den Index zugreifen zu
mssen?
a) Hashtable
b) Vector
c) LinkedList
d) ArrayList
e) LinkedHashSet
f) TreeSet
g) Keine dieser Mglichkeiten.
(19) Frage
Welche der unten stehenden Klassen ist relativ langsam, wenn auf die Elemente mit Hilfe eines Indexes zugegriffen wird?
a) Hashtable
b) Vector
c) LinkedList
d) ArrayList
e) LinkedHashSet
f) TreeSet
g) Keine dieser Mglichkeiten.
476
12
Das Collections-Framework
(20) Frage
Welche der unten stehenden Klassen ist hnlich schnell wie ein Array und erlaubt keine Duplikate?
a) Hashtable
b) Vector
c) LinkedList
d) HashSet
e) LinkedHashSet
f) TreeMap
g) Keine dieser Mglichkeiten.
(21) Frage
Welches der unten stehenden Interfaces hat einen Index und Felder?
a) List
b) Set
c) Map
d) Keine dieser Mglichkeiten.
(23) Frage
477
(24) Frage
Welches der unten stehenden Interfaces hat keinen Index, sondern nur Felder?
a) List
b) Set
c) Map
d) Keine dieser Mglichkeiten.
(25) Frage
Welche der Listen ermglicht es am schnellsten, in der Mitte Elemente hinzuzufgen oder zu lschen?
a) Vector
b) LinkedList
c) ArrayList
d) Keine dieser Mglichkeiten.
(26) Frage
478
12
Das Collections-Framework
e) LinkedHashSet
f) TreeMap
g) Keine dieser Mglichkeiten.
(28) Frage
Welche der unten stehenden Klassen basieren auf einem Array, das sich von
der Gre her anpassen kann?
a) TreeSet
b) HashSet
c) LinkedList
d) Hashtable
e) LinkedHashSet
f) TreeMap
g) Keine dieser Mglichkeiten.
(29) Frage
Welche der unten stehenden Klassen basieren auf einem Array, das sich von
der Gre her anpassen kann?
a) TreeSet
b) HashSet
c) ArrayList
d) Hashtable
e) LinkedHashSet
f) Vector
g) Keine dieser Mglichkeiten.
(30) Frage
Welche der unten stehenden Klassen hat Felder und Schlssel, erlaubt null
als Element und die Elemente werden nicht sortiert?
a) TreeSet
b) HashSet
c) ArrayList
479
d) Hashtable
e) LinkedHashSet
f) Vector
g) Keine dieser Mglichkeiten.
(31) Frage
Welche der unten stehenden Klassen hat Felder und Schlssel, erlaubt null
nicht als Element und die Elemente werden nicht sortiert?
a) TreeSet
b) HashSet
c) ArrayList
d) Hashtable
e) LinkedHashSet
f) Vector
g) Keine dieser Mglichkeiten.
(32) Frage
Welche der unten stehenden Klassen ist synchronisiert und hat Felder und
Schlssel?
a) TreeSet
b) HashSet
480
12
Das Collections-Framework
c) ArrayList
d) Hashtable
e) LinkedHashSet
f) Vector
g) Keine dieser Mglichkeiten.
(34) Frage
Welches Ergebnis erhlt man, wenn man folgendes Programm kompiliert und
startet?
import java.util.*;
public class C {
public static void main(String[ ] args) {
LinkedList s = new LinkedList();
String st = new String(eins);
String st1 = new String(zwei);
String st2 = new String(drei);
s.add(st);
s.add(st1);
s.add(st2);
Object o1 = s.get(1);
System.out.println(o1);
}
}
a) eins
b) zwei
c) drei
d) eins zwei drei
e) drei eins zwei
f) Keine dieser Mglichkeiten.
(35) Frage
Welches Ergebnis erhlt man, wenn man folgendes Programm kompiliert und
startet?
import java.util.Iterator;
import java.util.TreeSet;
public class CollectionSet {
public static void main(String[ ] args) {
TreeSet s = new TreeSet();
481
a) eins
b) zwei
c) drei
d) eins zwei drei
e) drei eins zwei
f) Keine dieser Mglichkeiten.
(36) Frage
Welches Ergebnis erhlt man, wenn man folgendes Programm kompiliert und
startet?
import java.util.Iterator;
import java.util.HashSet;
public class CollectionSet {
public static void main(String[ ] args) {
HashSet s = new HashSet();
String st = new String(eins);
String st1 = new String(zwei);
String st2 = new String(drei);
s.add(st);
s.add(st1);
s.add(st2);
for (Iterator i = s.iterator(); i.hasNext();){
Object o = i.next();
System.out.println(o);
}}}
a) eins
b) zwei
482
12
Das Collections-Framework
c) drei
d) eins zwei drei
e) drei eins zwei
f) Keine dieser Mglichkeiten.
(37) Frage
Welches Ergebnis erhlt man, wenn man folgendes Programm kompiliert und
startet?
import java.util.Iterator;
import java.util.LinkedHashSet;
public class CollectionSet {
public static void main(String[ ] args) {
LinkedHashSet s = new LinkedHashSet();
String st = new String(eins);
String st1 = new String(zwei);
String st2 = new String(drei);
s.add(st);
s.add(st1);
s.add(st2);
for (Iterator i = s.iterator(); i.hasNext();){
Object o = i.next();
System.out.println(o);
}
}}
a) eins
b) zwei
c) drei
d) eins zwei drei
e) drei eins zwei
f) Keine dieser Mglichkeiten.
Lsungen
(1) Frage
Die Klassen LinkedHashMap und Auto haben kein Verwandtschaftsverhltnis zueinander, deswegen kommt es zu einem Kompilierfehler (vgl.
Kapitel 3.7.3 Operator: instanceof ab Seite 120)
483
(2) Frage
(3) Frage
Die Klasse LinkedList hat ein Verwandschaftsverhltnis zu dem Interface Collection und der Klasse Object, aber nicht zu dem Interface Map.
(4) Frage
Die Klasse Hashtable hat ein Verwandschaftsverhltnis zu dem Interface Map und der Klasse Object, aber nicht zu dem Interface Collection.
(5) Frage
Eine ArrayList ist eine List und eine Collection, aber keine Map.
(6) Frage
Eine TreeMap implementiert das Interface SortedMap und dieses wiederum implementiert das Interface Map, so erhalten Sie bei dem Operator instanceof true als Ergebnis. Aber es besteht keinerlei Verwandschaftsverhltnis zu dem Interface Map, so erhalten sie hier das
Resultat false.
(7) Frage
Ein Vector ist eine List, aber keine Map und kein Set.
(8) Frage
Eine LinkedList ist ein List, aber keine Map und kein Set.
(9) Frage
(10) Frage
Die Klasse HashSet besitzt keinerlei Verwandschaftsverhltnis zum Interface SortedSet, Map oder List.
484
12
Das Collections-Framework
(11) Frage
(12) Frage
b, d Siehe auch Lsung von Aufgabe 11. Es ist die Lsung LinkedHashMap
und LinkedHashSet.
(13) Frage
Es ist die LinkedHashMap, die das Interface Map implementiert und bei
der die Elemente in der gleichen Reihenfolge ausgegeben werden, in
der sie eingegeben worden sind.
(14) Frage
(15) Frage
(16) Frage
Es trifft keine dieser Lsungen zu. Die Klasse LinkedList ist die effizienteste Mglichkeit des Prinzips der identischen Reihenfolge der Ein- und
Ausgabe (FiFo = First in - First out) von allen Listen, Sets und Maps.
(17) Frage
Die Klasse LinkedList ist die effizienteste Mglichkeit des Prinzips der
identischen Reihenfolge der Ein- und Ausgabe (FiFo = First in - First
out) von allen Listen, Sets und Maps.
(18) Frage
Die Klasse LinkedList, die es ermglicht, am Ende und am Anfang, Elemente hinzuzufgen, ohne auf den Index zugreifen zu mssen.
(19) Frage
Es ist die Klasse LinkedList, auf die der Zugriff mit Hilfe der Indexposition sehr langsam ist.
485
(20) Frage
Bei der Klasse HashSet knnen Sie hnlich schnell auf die einzelnen
Elemente zugreifen wie bei einem Array.
(21) Frage
(22) Frage
(23) Frage
(24) Frage
(25) Frage
(26) Frage
(28) Frage
(29) Frage
c, f Die Klassen ArrayList und Vector beruhen auf einem Array, das sich
von der Gre her verndern kann.
(30) Frage
Bei der Klasse HashMap ist null als Element erlaubt und die Elemente
werden nicht sortiert.
486
12
Das Collections-Framework
(31) Frage
Bei der Klasse Hashtable ist null als Element nicht erlaubt und die Elemente werden nicht sortiert.
(32) Frage
Die Klasse Hashtable ist synchronisiert und hat Felder und Schlssel.
(34) Frage
An der Stelle eins innerhalb der LinkedList befindet sich das Element
mit dem Inhalt zwei, da die LinkedList ihre Elemente in der gleichen
Reihenfolge wieder ausgibt, in der sie eingegeben worden sind.
(35) Frage
(36) Frage
Bei einem HashSet kann nicht vorausgesagt werden, in welcher Reihenfolge die Elemente ausgelesen werden.
(37) Frage
12.7
487
sen und die String-Klasse berschreiben die hashCode()- und die equals()Methode. Nur die StringBuffer-Klasse und die Klasse java.lang.Number
berschreiben diese beiden Methoden nicht.
Es gibt mehrere Richtlinien, die Sie einhalten mssen, wenn Sie die hashCode()-Methode und die equals()-Methode in einer Klasse berschreiben.
berschreiben Sie die hashCode()-Methode nicht, erhlt jedes Objekt einen
unterschiedlichen HashCode, auch wenn der Inhalt der Objekte gleich ist.
(1) Richtlinie
Ein Objekt gibt, solange ein Programm ausgefhrt wird, immer den gleichen
HashCode zurck. Bei jeder erneuten Ausfhrung darf ein anderer HashCode fr das gleiche Objekt zurckgegeben werden.
(2) Richtlinie
Objekte, die im Vergleich mit der equals()-Methode gleich sind (vgl. Kapitel 7
Wichtige Standardklassen (Fundamental Classes) ab Seite 255), haben
auch einen identischen HashCode.
public class HashCode {
public static void main(String[ ] args) {
String s = new String(eins);
String s1 = new String(eins);
boolean b1 = s.equals(s1);
boolean b2 = s.hashCode() == s1.hashCode();
System.out.println(b1);
System.out.println(b2);
}
}
(3) Richtlinie
Der Umkehrschluss gilt allerdings nicht. Objekte mit identischen HashCodes
sind nicht notwendigerweise auch beim Vergleich mit der equals()-Methode
gleich. Sprich der gleiche Mantel muss die gleiche Nummer haben, aber an
der gleichen Garderobennummer drfen zwei verschiedene Mntel hngen.
Objekte, die im Vergleich mit der equals()-Methode nicht gleich sind, haben
nicht notwendigerweise unterschiedliche HashCodes, d. h. Objekte mit gleichem HashCode sind im Vergleich mit der equals-Methode nicht unbedingt
488
12
Das Collections-Framework
gleich. Sind aber die HashCodes nicht gleich, so drfen zwei Objekte beim
Vergleich mit equals() auch nicht gleich sein.
public class HashCode {
public static void main(String[ ] args) {
String s = new String(eins);
String s1 = new String(zwei);
boolean b1 = s.equals(s1);
boolean b2 = s.hashCode() == s1.hashCode();
System.out.println(b1);
System.out.println(b2);
}
}
12.7
489
c) Objekte mit identischen HashCodes sind auch beim Vergleich mit der
equals()-Methode gleich.
d) Objekte, die im Vergleich mit der equals()-Methode gleich sind, haben
identische HashCodes.
e) Keine dieser Mglichkeiten.
(3) Frage
Nehmen wir an, s.equals(t) gibt true zurck, welche der unten stehenden
Mglichkeiten trifft dann zu?
a) s.hashCode() == t.hashCode()
b) s.hashCode() != t.hashCode()
c) Keine dieser Mglichkeiten.
(4) Frage
490
12
Das Collections-Framework
b) java.lang.Double
c) java.lang.Integer
d) java.util.Vector
e) java.util.LinkedHashSet
f) Keine dieser Mglichkeiten.
(7) Frage
Nehmen wir an o.equals(p) gibt true zurck, welche der unten stehenden
Mglichkeiten trifft dann zu?
a) o.hashCode() == p.hashCode()
b) o.hashCode() != p.hashCode()
c) Keine dieser Mglichkeiten.
(8) Frage
12.7
491
Nehmen wir an, s.hashCode() == t.hashCode() gibt false zurck, welche der
unten stehenden Mglichkeiten muss dann auch false zurckgeben?
a) !s.equals(t)
b) s.equals(t)
c) Keine dieser Mglichkeiten.
Lsungen
(1) Frage
(2) Frage
(4) Frage
Sind die HashCodes von zwei Objekten nicht gleich, so drfen diese
zwei Objekte auch beim Vergleich mit equals() nicht gleich sein.
492
12
Das Collections-Framework
(5) Frage
Es sind zwei Klassen, die die hashCode()-Methode und die equals()Methode nicht berschreiben: die Klassen StringBuffer und Number.
(6) Frage
(7) Frage
(8) Frage
(9) Frage
(10) Frage
Sind zwei HashCodes nicht gleich, so drfen zwei Objekte beim Vergleich mit equals() auch nicht gleich sein.
493
13
Innere Klassen
Wird die Klasse Pfirsich mit der inneren Klasse kompiliert, entstehen zwei
Klassen und nicht nur eine, wie man vielleicht annehmen knnte. Des Weiteren knnen auch Interfaces innere Klassen besitzen.
b) Innere Interfaces
In einer Klasse kann sich auch ein inneres Interface befinden. Innere Interfaces sind implizit static und das Schlsselwort static kann weggelassen werden. Sie knnen public, private, protected oder package local sein.
494
13
Innere Klassen
Eine nicht-statische innere Klasse wird innerhalb der ueren Klasse (TopLevel-Klasse) so instanziiert, wie Sie es bisher bei allen anderen Klassen
auch gewohnt sind und mit Hilfe der ueren Klasse.
public class Pfirsich {
//Instanziierung einer inneren Klasse innerhalb einer
//ueren Klasse
Kern kern = new Kern();
Pfirsich.Kern pfirsichKern = new Pfirsich().new Kern();
public class Kern{
}
}
Wird die nicht-statische innere Klasse in der main( )-Methode der ueren
Klasse instanziiert, kann auf die uere Klasse nicht verzichtet werden, da
es ansonsten zu einem Kompilierfehler kommen wrde. Sie mssen die innere mit der ueren instanziieren: Pfirsich.Kern pfirsich = new
Pfirsich( ).new Kern( );.
public class Pfirsich {
public class Kern{
}
public static void main(String args[ ]){
Kern kern = new Kern(); //Kompilierfehler
Pfirsich.Kern pfirsichKern = new Pfirsich().new Kern();
}
}
Damit ist ein groer Nachteil verbunden: Es wird sowohl eine Instanz der
ueren Klasse als auch der inneren erstellt. Es werden beide Standardkonstruktoren ausgefhrt und in unten stehendem Beispiel wird sowohl das Wort
Pfirsich als auch das Wort Kern auf der Konsole ausgegeben.
public class Pfirsich {
Pfirsich(){
System.out.println(Pfirsich);
}
public class Kern{
Kern(){
System.out.println(Kern);
}
13.1
495
}
public static void main(String args[ ]){
Pfirsich.Kern pfirsichKern = new Pfirsich().new Kern();
}
}
Wrde in der main( )-Methode nur new Pfirsich pfirsich = new Pfirsich( ); stehen, so wrde nur der Ausdruck Pfirsich ausgegeben werden.
public class Pfirsich {
Pfirsich(){
System.out.println(Pfirsich);
}
public class Kern{
Kern(){
System.out.println(Kern);
}
}
public static void main(String args[ ]){
Pfirsich pfirsich = new Pfirsich();
}
}
Statische innere Klassen werden innerhalb der ueren Klasse wie unten
stehend instanziiert. Wird aber die innere Klasse mit der ueren instanziiert,
wird die runde Klammer nach new Pflanze auf der rechten Seite weggelassen.
public class Pflanze {
//Instanziierung einer statischen inneren Klasse innerhalb einer
//ueren Klasse
Blatt blatt = new Blatt();
Pflanze.Blatt pflanzeBlatt = new Pflanze.Blatt();
public static class Blatt{
}
}
496
13
Innere Klassen
Es gibt aber bei der Objekterstellung innerhalb der main( )-Methode der ueren Klasse einen wichtigen Unterschied zu den nicht-statischen inneren
Klassen: Bei statischen inneren Klassen ist zustzlich eine Instanziierung
ohne die uere Klasse mglich. Wird aber die innere Klasse mit der ueren instanziiert, gibt es eine Abweichung in der Syntax: Es fehlt die runde Klammer nach new Pflanze auf der rechten Seite.
public class Pflanze {
public static class Blatt{
}
public static void main(String[ ] args){
Blatt blatt = new Blatt();
Pflanze.Blatt pflanzeBlatt = new Pflanze.Blatt();
}
}
Es liegt nahe zu fragen: Was wird bei den verschiedenen Instanziierungsarten auf dem Bildschirm ausgegeben? Die Ausgabe steht im Gegensatz zu
den nicht-statischen inneren Klassen: In beiden Fllen wird nur das Wort
Blatt ausgegeben. Aber es bleibt gleich: Eine Instanz der ueren Klasse
Pflanze gibt nur das Wort Pflanze aus.
public class Pflanze {
Pflanze(){
System.out.println(Pflanze);
}
public static class Blatt{
Blatt(){
System.out.println(Blatt);
}
}
public static void main(String[ ] args) {
Pflanze pflanze = new Pflanze();
Blatt blatt = new Blatt();
Pflanze.Blatt pflanzeBlatt = new Pflanze.Blatt();
}
}
13.1
497
Die Ausgabe bei der Instanziierung von nicht-statischen inneren Klassen auerhalb der ueren Klasse weicht von der Ausgabe bei statischen Klassen
ab: Es wird zustzlich eine Instanz der ueren Klasse erstellt. Es erscheinen bei Pfirsich.Kern pfirsichKern = new Pfirsich( ).new Kern( ); die Wrter
Pfirsich und Kern auf der Konsole. Bei der statischen Klasse hingegen
wird nur die innere Klasse instanziiert und somit auch nur Blatt ausgegeben.
public class Obstkorb {
public static void main(String[ ] args) {
Pfirsich.Kern pfirsichKern = new Pfirsich().new Kern();
Pflanze.Blatt pflanzeBlatt = new Pflanze.Blatt();
}
}
498
13
Innere Klassen
Wie knnen wir aber auf die Variable farbe der ueren Klasse zugreifen?
Wir ndern die Variable farbe in eine statische:
public class Pflanze {
static private String farbe = grn;
public static class Blatt{
Blatt(){
System.out.println(farbe);
}
}
}
13.1
499
13.1.5 Zugriff auf Variablen der inneren und ueren Klasse mit
this
a) Bei nicht-statischen Klassen
Wie kann man aber zwischen gleichnamigen Variablen der inneren und ueren Klasse unterscheiden und innerhalb einer nicht-statischen inneren
Klasse darauf zugreifen? Die Antwort ist einfach: mit this (vgl. Kapitel 3.6
Objektreferenz und Konstruktoraufruf mit this und super ab Seite 101).
In unten stehendem Beispiel knnen Sie innerhalb der nicht-statischen inneren Klasse auf die Variable farbe der Klasse Pfirsich nur mit Bezug auf die
Klasse Pfirsich und mit this zugreifen: Pfirsich.this.farbe. Dies entspricht in
etwa der Logik der Verwendung von super, wobei hier super aber nicht verwendet werden kann. Auf die Variable farbe der Klasse Kern knnen Sie in
der Klasse Kern auf zweierlei Arten zugreifen: mit farbe oder this.farbe.
public class Pfirsich {
private String farbe = rosa;
public class Kern{
private String farbe = grau;
Kern() {
System.out.println(Farbe des Pfirsichs:
+ Pfirsich.this.farbe);
System.out.println(Farbe des Kerns:
+ this.farbe);
System.out.println(Farbe des Kerns:
+ farbe);
}
}
public static void main(String args[ ]){
Pfirsich.Kern pfirsichKern = new Pfirsich().new Kern();
}
}
500
13
Innere Klassen
dings auf die Variable der inneren Klasse zugreifen, gelten weiterhin folgende zwei Alternativen: this.farbe und farbe.
public class Pflanze {
static private String farbe = grn;
public static class Blatt{
static private String farbe = dunkelgrn;
Blatt(){
System.out.println(Farbe der Pflanze: + Pflanze.farbe);
System.out.println(Farbe des Blatts: + this.farbe);
System.out.println(Farbe des Blatts: + farbe);
}
}
public static void main(String[ ] args) {
Pflanze.Blatt pflanzeBlatt = new Pflanze.Blatt();
}
}
13.1
501
nur statische
alle
alle
nur nicht-statische
aber: final static
Welche Mglichkeiten gibt es, die unten stehende innere Klasse innerhalb
der ueren Klasse an der Stelle zu instanziieren, an der das Wort hier
steht, ohne dass es zu einem Kompilierfehler kommt?
public class AKlasse {
hier
public class BKlasse{
}
}
Welche Mglichkeiten gibt es, die unten stehende innere Klasse innerhalb
der ueren Klasse an der Stelle zu instanziieren, an der das Wort hier
steht, ohne dass es zu einem Kompilierfehler kommt?
public class AKlasse {
hier
public static class BKlasse{
}
}
502
13
Innere Klassen
Welche Mglichkeiten gibt es, die unten stehende innere Klasse innerhalb
der main( )-Methode der ueren Klasse an der Stelle zu instanziieren, an
der das Wort hier steht, ohne dass es zu einem Kompilierfehler kommt?
public class AKlasse {
public class BKlasse{
}
public static void main(String args[ ]){
hier
}
}
Welche Mglichkeiten gibt es, die unten stehende innere Klasse innerhalb
der main( )-Methode der ueren Klasse an der Stelle zu instanziieren, an
der das Wort hier steht, ohne dass es zu einem Kompilierfehler kommt?
public class AKlasse {
public static class BKlasse{
}
public static void main(String args[ ]){
hier
}
}
13.1
503
(5) Frage
Welche Mglichkeiten gibt es, die unten stehende innere Klasse auerhalb
der ueren Klasse zu instanziieren, ohne dass es zu einem Kompilierfehler
kommt?
public class AKlasse {
public class BKlasse{
}
}
Welche Mglichkeiten gibt es, die unten stehende innere Klasse auerhalb
der ueren Klasse zu instanziieren, ohne dass es zu einem Kompilierfehler
kommt?
public class AKlasse {
public static class BKlasse{
}
}
Welches Ergebnis erhlt man, wenn man folgendes Programm kompiliert und
startet?
public class AKlasse {
AKlasse(){
System.out.println(A);
}
public class BKlasse{
BKlasse(){
System.out.println(B);
}
504
13
Innere Klassen
}
public static void main(String args[ ]){
AKlasse.BKlasse b = new AKlasse().new BKlasse();
a) A B
b) B
c) A
d) Kompilierfehler
(8) Frage
Welches Ergebnis erhlt man, wenn man folgendes Programm kompiliert und
startet?
public class AKlasse {
AKlasse(){
System.out.println(A);
}
public class BKlasse{
BKlasse(){
System.out.println(B);
}
}
public static void main(String args[ ]){
AKlasse a = new AKlasse();
}
}
a) A B
b) B
c) A
d) Kompilierfehler
(9) Frage
Welches Ergebnis erhlt man, wenn man folgendes Programm kompiliert und
startet?
public class AKlasse {
AKlasse(){
System.out.println(A);
}
public class BKlasse{
BKlasse(){
System.out.println(B);
}
13.1
505
}
public static void main(String args[ ]){
BKlasse b = new BKlasse();
}
}
a) A B
b) B
c) A
d) Kompilierfehler
(10) Frage
Welches Ergebnis erhlt man, wenn man folgendes Programm kompiliert und
startet?
public class AKlasse {
AKlasse(){
System.out.println(A);
}
public static class BKlasse{
BKlasse(){
System.out.println(B);
}
}
public static void main(String args[ ]){
AKlasse.BKlasse b = new AKlasse.BKlasse();
}
}
a) A B
b) B
c) A
d) Kompilierfehler
(11) Frage
Welches Ergebnis erhlt man, wenn man folgendes Programm kompiliert und
startet?
public class AKlasse {
AKlasse(){
System.out.println(A);
}
public static class BKlasse{
BKlasse(){
506
13
Innere Klassen
System.out.println(B);
}
}
public static void main(String args[ ]){
AKlasse a = new AKlasse();
}
}
a) A B
b) B
c) A
d) Kompilierfehler
(12) Frage
Welches Ergebnis erhlt man, wenn man folgendes Programm kompiliert und
startet?
public class AKlasse {
AKlasse(){
System.out.println(A);
}
public static class BKlasse{
BKlasse(){
System.out.println(B);
}
}
public static void main(String args[ ]){
BKlasse b = new BKlasse();
}
}
a) A B
b) B
c) A
d) Kompilierfehler
(13) Frage
13.1
507
508
13
Innere Klassen
b) package local
c) private
d) abstract
e) Keine dieser Mglichkeiten.
(18) Frage
13.1
509
d) Nicht-statische innere Klassen knnen auf statische Variablen der ueren Klasse zugreifen.
e) Statische innere Klassen knnen statische Variablen beinhalten.
f) Keine dieser Mglichkeiten.
(21) Frage
Auf welche Variablen knnen Sie innerhalb der inneren Klasse zugreifen,
sprich welche Variablen knnen Sie dort einsetzen, wo hier steht?
public class AKlasse {
private static String a;
private final int b = 1;
public class BKlasse{
BKlasse(){
System.out.println(hier);
}
}
}
a) a
b) b
c) Keine dieser Mglichkeiten.
(22) Frage
Auf welche Variablen knnen Sie innerhalb der inneren Klasse zugreifen,
sprich welche Variablen knnen Sie dort einsetzen, wo hier steht?
public class AKlasse {
private static String a;
private final int b = 1;
public static class BKlasse{
BKlasse(){
System.out.println(hier);
}
}
}
a) a
b) b
c) Keine dieser Mglichkeiten.
510
13
Innere Klassen
(23) Frage
Wie knnen Sie an der Stelle, an der hier steht, auf die Variable private
String a = a; der ueren Klasse zugreifen?
public class AKlasse {
private String a = a;
public class BKlasse{
private String a = b;
BKlasse(){
System.out.println(hier);
}
}
public static void main (String args[ ]){
AKlasse.BKlasse ab = new AKlasse().new BKlasse();
}
}
a) super.a
b) this.a
c) a
d) AKlasse.this.a
e) Keine dieser Mglichkeiten.
(24) Frage
Wie knnen Sie an der Stelle, an der hier steht, auf die Variable private
String a = b; der inneren Klasse zugreifen?
public class AKlasse {
private String a = a;
public class BKlasse{
private String a = b;
BKlasse(){
System.out.println(hier);
}
}
public static void main (String args[ ]){
AKlasse.BKlasse ab = new AKlasse().new BKlasse();
}
}
a) super.a
b) this.a
13.1
c) a
d) AKlasse.this.a
e) Keine dieser Mglichkeiten.
(25) Frage
Zeile 1
Zeile 2
Zeile 3
a) Zeile 1
b) Zeile 2
c) Zeile 3
d) Keine dieser Mglichkeiten.
(26) Frage
Zeile 1
Zeile 2
Zeile 3
a) Zeile 1
b) Zeile 2
c) Zeile 3
d) Keine dieser Mglichkeiten.
(27) Frage
Zeile 1
Zeile 2
511
512
13
Innere Klassen
String c;
int i;
Zeile 3
Zeile 4
}
}
a) Zeile 1
b) Zeile 2
c) Zeile 3
d) Zeile 4
e) Keine dieser Mglichkeiten.
(28) Frage
Zeile 1
Zeile 2
Zeile 3
Zeile 4
a) Zeile 1
b) Zeile 2
c) Zeile 3
d) Zeile 4
e) Keine dieser Mglichkeiten.
(29) Frage
a) Zeile 1
b) Zeile 2
Zeile 1
Zeile 2
Zeile 3
Zeile 4
13.1
513
c) Zeile 3
d) Zeile 4
e) Keine dieser Mglichkeiten.
(30) Frage
Zeile 1
Zeile 2
Zeile 3
Zeile 4
a) Zeile 1
b) Zeile 2
c) Zeile 3
d) Zeile 4
e) Keine dieser Mglichkeiten.
Lsungen
(1) Frage
514
13
Innere Klassen
(4) Frage
(6) Frage
(7) Frage
Es wird sowohl der Konstruktor der ueren und inneren Klasse durchgefhrt, so ist die Ausgabe A B.
(8) Frage
Es wird nur die uere Klasse instanziiert, so erhalten Sie als Ausgabe
nur A. Hierbei ist egal, ob diese Klasse eine statische oder nicht-statische innere Klasse besitzt.
(9) Frage
(10) Frage
Die statische innere Klasse wurde korrekt instanziiert und somit wird nur
B ausgeben.
(11) Frage
Es wird nur die uere Klasse instanziiert, so erhalten Sie als Ausgabe
nur A. Hierbei ist egal, ob diese Klasse eine statische oder nicht-statische innere Klasse besitzt.
13.1
515
(12) Frage
Es ist mglich, eine statische innere Klasse innerhalb der main( )-Methode der ueren Klasse wie folgt zu instanziieren: BKlasse b = new
BKlasse( );
(13) Frage
a, b, Es gibt sowohl statische als auch nicht statische innere Klassen. Folgende Moe
difier sind fr innere Klassen zugelassen: abstract, final, private, protected,
static, public und package local. Interfaces knnen innere Klassen besitzen. Auerdem knnen Klassen auch innere Interfaces besitzen und diese sind implizit
static.
(14) Frage
Achtung, in der Frage steht welche Aussagen sind nicht korrekt! Alle
Aussagen sind korrekt. Innere Klassen werden innerhalb einer Klasse
deklariert und knnen statisch oder nicht-statisch sein. Interfaces und
Klassen knnen innere Klassen besitzen. Innere Interfaces sind implizit
static. Folgende Modifier sind fr innere Klassen zugelassen: abstract,
final, private, protected, static, public und package local.
(15) Frage
(16) Frage
Keine dieser Aussagen ist richtig. Es gibt sowohl statische als auch
nicht-statische innere Klassen. Statische innere Klassen knnen nur
auf statische Bestandteile der ueren Klasse zugreifen. Wohingegen
516
13
Innere Klassen
(21) Frage
a, b Nicht-statische innere Klassen knnen von allen Bestandteile der ueren Klasse Gebrauch machen.
(22) Frage
(23) Frage
Wollen Sie innerhalb der nicht-statischen inneren Klasse auf eine Variable der ueren Klasse, die es mit gleichem Namen in der inneren und
ueren Klasse gibt, zugreifen, geht dies nur mit AKlasse.this.a.
(24) Frage
b, c Wollen Sie innerhalb der nicht-statischen innereren Klasse auf eine Variable der inneren Klasse zugreifen, die es mit gleichem Namen in der
inneren und ueren Klasse gibt, haben Sie zwei Mglichkeiten: this.a
und a.
(25) Frage
(26) Frage
In nicht-statischen inneren Klassen darf es nur nicht-statische Bestandteile geben, mit Ausnahme von final static.
517
(27) Frage
(28) Frage
(29) Frage
Es kommt in Zeile 4 zu einem Kompilierfehler, da in nicht-statischen inneren Klassen nur nicht-statische und final static-Bestandteile erlaubt
sind.
(30) Frage
518
13
Innere Klassen
Verndern Sie nun in oben stehendem Beispiel die statische Variable groesse in eine nicht-statische Variable, so kommt es zu einem Kompilierfehler.
519
520
13
Innere Klassen
521
Zugriff auf Bestand- Mgliche Deklaratioteile des Blocks (z. B. nen innerhalb der lokaMethode)
len Klasse
522
13
Innere Klassen
(2) Frage
In welcher Zeile tritt ein Kompilierfehler auf, wenn man folgendes Programm
kompiliert und startet?
public class LokaleAuen {
void neu(){
class Lokale {
String s1 = blau;
final static String s2 = blau;
String s = gelb;
}
}
}
a) Zeile 1
b) Zeile 2
c) Zeile 3
d) Keine dieser Mglichkeiten.
Zeile 1
Zeile 2
Zeile 3
523
(5) Frage
In welcher Zeile tritt ein Kompilierfehler auf, wenn man folgendes Programm
kompiliert und startet?
public class LokaleAuen {
void neu(){
class Lokale {
String s1 = blau;
static String s2 = blau;
String s = gelb;
}
}
}
Zeile 1
Zeile 2
Zeile 3
a) Zeile 1
b) Zeile 2
c) Zeile 3
d) Keine dieser Mglichkeiten.
(6) Frage
In welcher Zeile tritt ein Kompilierfehler auf, wenn man folgendes Programm
kompiliert und startet?
public class LokaleAuen {
static void neu(){
class Lokale {
String s1 = blau;
final static String s2 = blau;
String s = gelb;
}
}
}
Zeile 1
Zeile 2
Zeile 3
a) Zeile 1
b) Zeile 2
c) Zeile 3
d) Keine dieser Mglichkeiten.
(7) Frage
In welcher Zeile tritt ein Kompilierfehler auf, wenn man folgendes Programm
kompiliert und startet?
public class LokaleAuen {
void neu(){
class Lokale {
524
13
Innere Klassen
static String s1 = blau;
final static String s2 = blau;
String s = gelb;
Zeile 1
Zeile 2
Zeile 3
}
}
}
a) Zeile 1
b) Zeile 2
c) Zeile 3
d) Keine dieser Mglichkeiten.
(8) Frage
Auf welche Variablen knnen Sie innerhalb der lokalen Klasse zugreifen,
sprich welche Variablen knnen Sie dort einsetzen, wo hier steht, ohne
dass es zu einem Kompilierfehler kommt?
public class LokaleAuen {
void neu(){
String s1 = blau;
final String s2 = rot;
String s = gelb;
class Lokale {
Lokale(){
System.out.println(hier);
}
}
}
}
a) s
b) s1
c) s2
d) Keine dieser Mglichkeiten.
(9) Frage
Auf welche Variablen knnen Sie innerhalb der lokalen Klasse zugreifen,
sprich welche Variablen knnen Sie dort einsetzen, wo hier steht, ohne
dass es zu einem Kompilierfehler kommt?
public class LokaleAuen {
static void neu(){
String s1 = blau;
final String s2 = lila;
String s = gelb;
525
class Lokale {
Lokale(){
System.out.println(hier);
}
}
}
}
a) s
b) s1
c) s2
d) Keine dieser Mglichkeiten.
(10) Frage
Auf welche Variablen knnen Sie innerhalb der lokalen Klasse zugreifen,
sprich welche Variablen knnen Sie dort einsetzen, wo hier steht, ohne
dass es zu einem Kompilierfehler kommt?
public class LokaleAuen {
void neu(){
String s1 = blau;
String s2 = rot;
String s = gelb;
class Lokale {
Lokale(){
System.out.println(hier);
}
}
}
}
a) s
b) s1
c) s2
d) Keine dieser Mglichkeiten.
(11) Frage
Auf welche Variablen knnen Sie innerhalb der lokalen Klasse zugreifen,
sprich welche Variablen knnen Sie dort einsetzen, wo hier steht, ohne
dass es zu einem Kompilierfehler kommt?
public class LokaleAuen {
static String s1 = lila;
final String s2 = blau;
String s = gelb;
526
13
Innere Klassen
void neu(){
class Lokale {
Lokale(){
System.out.println(hier);
}
}
}
}
a) s
b) s1
c) s2
d) Keine dieser Mglichkeiten.
(12) Frage
Auf welche Variablen knnen Sie innerhalb der lokalen Klasse zugreifen,
sprich welche Variablen knnen Sie dort einsetzen, wo hier steht, ohne
dass es zu einem Kompilierfehler kommt?
public class LokaleAuen {
static String s1 = lila;
final String s2 = blau;
String s = gelb;
static void neu(){
class Lokale {
Lokale(){
System.out.println(hier);
}
}
}
}
a) s
b) s1
c) s2
d) Keine dieser Mglichkeiten.
(13) Frage
Auf welche Variablen knnen Sie innerhalb der lokalen Klasse zugreifen,
sprich welche Variablen knnen Sie dort einsetzen, wo hier steht, ohne
dass es zu einem Kompilierfehler kommt?
public class LokaleAuen {
String s1 = lila;
final String s2 = blau;
527
String s = gelb;
static void neu(){
class Lokale {
Lokale(){
System.out.println(hier);
}
}
}
}
a) s
b) s1
c) s2
d) Keine dieser Mglichkeiten.
(14) Frage
Auf welche Variablen knnen Sie innerhalb der lokalen Klasse zugreifen,
sprich welche Variablen knnen Sie dort einsetzen, wo hier steht, ohne
dass es zu einem Kompilierfehler kommt?
public class LokaleAuen {
static String a = eins;
static final String b = zwei;
String c = drei;
void neu(){
class Lokale {
Lokale(){
System.out.println(hier);
}
}
}
}
a) a
b) b
c) c
d) Keine dieser Mglichkeiten.
(15) Frage
Auf welche Variablen knnen Sie innerhalb der lokalen Klasse zugreifen,
sprich welche Variablen knnen Sie dort einsetzen, wo hier steht, ohne
dass es zu einem Kompilierfehler kommt?
public class LokaleAuen {
static String a = eins;
528
13
Innere Klassen
a) a
b) b
c) c
d) Keine dieser Mglichkeiten.
Lsungen
(1) Frage
Als Modifier fr lokale Klassen sind nur final und abstract mglich. Sie
knnen nicht gleichzeitig verwendet werden, da abstract und final sich
gegenseitig widersprechen (siehe Kapitel 3.4 Modifier ab Seite 82).
(2) Frage
(3) Frage
(4) Frage
(5) Frage
In lokalen Klassen darf es keine statischen Bestandteile geben. Vergleichen Sie hierzu auch die Lsung aus Frage 4.
(6) Frage
d,
529
(7) Frage
(8) Frage
Lokale Klassen knnen nur auf lokale Variablen des Blocks zugreifen,
die final sind. In diesem Zusammenhang spielt es keine Rolle, ob sich
die lokale Klassen in einem statischen oder nicht-statischen Block befindet.
(9) Frage
(10) Frage
Sie knnen innerhalb der lokalen Klasse auf keine der Variablen des
Blocks zugreifen, da keine einzige final ist.
(11) Frage
a, b, Lokale Klassen innerhalb eines nicht-statischen Blocks knnen auf alle Variabc
len der ueren Klasse zugreifen.
(12) Frage
Lokale Klassen innerhalb eines statischen Blocks knnen nur auf statische Variablen der ueren Klasse zugreifen.
(13) Frage
Lokale Klassen innerhalb eines statischen Blocks knnen nur auf statische Variablen der ueren Klasse zugreifen.
(14) Frage
a, b, Lokale Klassen innerhalb eines nicht-statischen Blocks knnen auf alle Variabc
len der ueren Klasse zugreifen.
(15) Frage
a, b Lokale Klassen innerhalb eines statischen Blocks knnen nur auf statische Variablen der ueren Klasse zugreifen.
530
13
Innere Klassen
Nun knnen Sie in der unten stehenden Klasse Haus eine anonyme Klasse
definieren, die als Basis die Klasse Zimmer hat. Anonyme Klassen haben am
Ende ein Semikolon, wenn Sie innerhalb einer Klasse oder einer Methode erstellt werden. Es wird bei diesem Vorgang implizit eine Subklasse der Klasse
Zimmer erzeugt, und gleichzeitig kann deren Methode wohne( ) berschrieben werden. Sie muss es aber nicht! Sie kann auch weggelassen werden,
ohne dass es zu einem Kompilierfehler kommt. Fr anonyme Klassen macht
es keinen Sinn, eigene Methoden zu haben.
public class Haus {
Zimmer z = new Zimmer(){
public void wohne() {
531
Wie kann man eine anonyme Klasse auf Basis einer Klasse in einer Methode
formulieren? Es gibt zwei verschiedene Mglichkeiten, ohne dass es zu einem Kompilierfehler kommt:
public class Haus {
public static void main(String[ ] args) {
new Zimmer(); //Achtung! Strichpunkt nicht vergessen!
Zimmer z = new Zimmer(); //Achtung! Strichpunkt nicht vergessen!
}
}
532
13
Innere Klassen
(2) Erstellen von anonymen Klassen auf Basis von inneren Klassen innerhalb einer
Methode
Sie fragen sich sicherlich, ob eine anonyme Klasse auf Basis von inneren
Klassen in einer Methode definiert werden kann? Natrlich! Es geht sowohl
mit statischen als auch mit nicht-statischen inneren Klassen. Erinnern wir uns
an die Beispiele zum Thema Innere Klassen und lassen Sie uns zwischen
statischen und nicht-statischen inneren Klassen unterscheiden.
Sie knnen eine anonyme Klasse einer nicht-statischen inneren Klasse in
der main( )-Methode der ueren Klasse wie unten stehend definieren. Wollen Sie das gleiche auerhalb der ueren Klasse in einer Methode einer anderen Klasse tun, funktioniert dies genauso.
public class Pfirsich {
public class Kern{
}
public static void main(String args[ ]){
new Pfirsich().new Kern();
}
}
Wie formuliert man eine anonyme Klasse in einer Methode auerhalb der
ueren Klasse? Die Antwort ist die folgende: Dies geht nur mit new
Pflanze.Blatt( );.
(3) Erstellen von anonymen Klassen auf Basis von einem Interface innerhalb einer
Methode
Unten stehend sehen Sie zwei verschiedene Wege, eine anonyme Klasse
auf Basis von einem Interface in einer Methode zu erzeugen, ohne dass es
zu einem Kompilierfehler kommt.
533
534
13
Innere Klassen
Kommen Sie der Aufforderung nach, ffnet unser ActionListener eine Message-Box mit der Meldung Mach mich wieder zu!.
Drcken Sie nun auf OK, wird das Fenster wieder geschlossen und es erscheint wieder der Button Drck mich!.
Hier der dazugehrige Code:
import java.awt.BorderLayout;
import java.awt.event.ActionEvent;
import java.awt.event.ActionListener;
import javax.swing.JButton;
import javax.swing.JFrame;
import javax.swing.JOptionPane;
public class EigenerActionListener extends JFrame implements
ActionListener{
public EigenerActionListener() {
setSize(600, 400);
setVisible(true);
getContentPane().setLayout(new BorderLayout());
JButton button = new JButton();
button.setText(Drck mich!);
button.setActionCommand(actionCommand);
button.addActionListener( this );
getContentPane().add(button, BorderLayout.CENTER);
button.addActionListener(new ActionListener() {
public void actionPerformed(ActionEvent e) {
JOptionPane.showMessageDialog(EigenerActionListener.this,
Mach mich wieder zu!,
Fehlermeldung,JOptionPane.INFORMATION_MESSAGE);
}
});
pack();
}
535
nur statische
alle
nur nicht-statische
aber: final static
536
13
Innere Klassen
c) Eine anonyme Klasse kann keine implizite implements-Beziehung zu einem Interface haben.
d) Anonyme Klassen knnen implements- und extends-Angaben haben.
e) Anonyme Klassen haben implizit keine extends-Beziehung zur Klasse
Object.
f) Keine dieser Mglichkeiten.
(2) Frage
a) new Runnable()
b) Runnable r = new Runnable()
c) new Runnable
d) Runnable r = new Runnable
(4) Frage
537
};
}
}
a) new Runnable()
b) Runnable r = new Runnable()
c) new Runnable
d) Runnable r = new Runnable
(5) Frage
b)
button.addActionListener(new ActionListener() {
public void actionPerformed(ActionEvent e) {
}
};
)
c)
button.addActionListener(new ActionListener() {
}
);
d)
button.addActionListener() {new ActionListener()
public void actionPerformed(ActionEvent e) {
}
}
);
538
13
Innere Klassen
a)
button.addActionListener(new ActionListener() {
public void actionPerformed(ActionEvent e) {
System.out.println(Ich bin ein Event!);
}
};
)
b)
button.addActionListener(){new ActionListener()
public void actionPerformed(ActionEvent e) {
System.out.println(Ich bin ein Event!);
}
};
);
c)
button.addActionListener(new ActionListener() {
public void actionPerformed(ActionEvent e) {
System.out.println(Ich bin ein Event!);
}
}
);
d)
button.addActionListener {new ActionListener()
public void actionPerformed(ActionEvent e) {
System.out.println(Ich bin ein Event!);
}
}
);
539
b)
void m() {
Runnable r = new Runnable() {
public void run() {
}
};
}
c)
void m() {
Runnable r = new Runnable() {
public void run() {
}
}
};
d)
void m() {
Runnable r = new Runnable() {
};
}
b)
public class Anonyme {
Runnable r = new Runnable() {
public void run() {
}
};
}
540
13
Innere Klassen
c)
public class Anonyme {
Runnable r = new Runnable() {
public void run() {
}
}
};
d)
public class Anonyme {
Runnable r = new Runnable() {
};
}
Auf welche Variablen knnen Sie innerhalb der anonymen Klasse zugreifen,
sprich welche Variablen knnen Sie dort einsetzen, wo hier steht, ohne
dass es zu einem Kompilierfehler kommt?
public class Anonyme {
int i;
void m() {
int a;
final String b = String;
Runnable r = new Runnable() {
String c;
public void run() {
System.out.println(hier);
}
};
}
}
a) i
b) a
c) b
d) c
e) Keine dieser Mglichkeiten.
541
(10) Frage
Auf welche Variablen knnen Sie innerhalb der anonymen Klasse zugreifen,
sprich welche Variablen knnen Sie dort einsetzen, wo hier steht, ohne
dass es zu einem Kompilierfehler kommt?
public class Anonyme {
int i;
static void m() {
int a;
final String b = String;
Runnable r = new Runnable() {
String c;
public void run() {
System.out.println(hier);
}
};
}
}
a) i
b) a
c) b
d) c
e) Keine dieser Mglichkeiten.
(11) Frage
Auf welche Variablen knnen Sie innerhalb der anonymen Klasse zugreifen,
sprich welche Variablen knnen Sie dort einsetzen, wo hier steht, ohne
dass es zu einem Kompilierfehler kommt?
public class Anonyme {
int i;
static void m() {
int a;
final String b = String;
String c;
Runnable r = new Runnable() {
public void run() {
System.out.println(hier);
}
};
}
}
a) i
b) a
542
13
Innere Klassen
c) b
d) c
e) Keine dieser Mglichkeiten.
(12) Frage
Auf welche Variablen knnen Sie innerhalb der anonymen Klasse zugreifen,
sprich welche Variablen knnen Sie dort einsetzen, wo hier steht, ohne
dass es zu einem Kompilierfehler kommt?
public class Anonyme {
int i;
void m() {
int a;
String b = String;
String c;
Runnable r = new Runnable() {
public void run() {
System.out.println(hier);
}
};
}
}
a) i
b) a
c) b
d) c
e) Keine dieser Mglichkeiten.
Lsungen
(1) Frage
Keine dieser Aussagen trifft zu. Anonyme Klassen haben eine implizite
extends-Beziehung zur Klasse Object und sie sind implizit final, sie
knnen aber nicht abstract oder static sein. Auerdem kann eine anonyme Klasse eine implizite implements-Beziehung zu einem Interface
haben. Wichtig ist hierbei, dass eine anonyme Klasse weder eine implements- noch eine extends-Angabe haben darf. Eine anonyme Klasse
darf auch keinen Konstruktor haben.
543
(2) Frage
b, d, eInnerhalb von anonymen Klassen darf es Methoden geben und eine anonyme
Klasse darf innerhalb einer Methode stehen und sie ist implizit final. Anonyme
Klassen haben keine implements- und extends-Angaben, aber eine implizite
extends-Beziehung zur Klasse Object.
(3) Frage
Innerhalb einer Klasse darf an dieser Stelle nur Folgenes stehen: Runnable r = new Runnable().
(4) Frage
a, b Innerhalb der Methode einer Klasse treffen folgende zwei Lsungen zu:
new Runnable() und Runnable r = new Runnable().
(5) Frage
Es trifft nur Lsung a zu, da eine anonyme Klasse, die als Argument eines Methodenaufrufs definiert wird, nicht mit einem Strichpunkt abgeschlossen wird. Da die Basis fr die anonyme Klasse das Interface ActionListener ist, das die Methode pulic void actionPerformed(Action e)
enthlt, muss diese auch in der anonymen Klasse implementiert werden. Achten Sie zustzlich darauf, dass sich die geschweiften und runden Klammern an den richtigen Stellen befinden.
(6) Frage
Es trifft nur Lsung c zu, da eine anonyme Klasse, die als Argument eines Methodenaufrufs definiert wird, nicht mit einem Strichpunkt abgeschlossen wird. Vergleichen Sie hierzu auch die Lsung von Frage 5.
(7) Frage
a, b Wollen Sie eine anonyme Klasse innerhalb einer Methode einer Klasse
erstellen, sind nur die Lsungsanstze a und b mglich. In diesem Fall
muss die anonyme Klasse mit einem Semikolon abgeschlossen werden. Wird eine Klasse auf Basis eines Interfaces erstellt, mssen die
Methoden des Interfaces implementiert werden. Das Interface Runnable besitzt ein Methode run(), die implementiert werden muss (vgl.
hierzu Kapitel 10 Threads).
(8) Frage
Wird eine anonyme Klasse innerhalb einer Klasse erstellt, ist nur die Lsung b mglich. In diesem Fall muss die anonyme Klasse mit einem Semikolon abgeschlossen werden. Wird eine Klasse auf Basis eines Inter-
544
13
Innere Klassen
(12) Frage
545
14
14.1 Kontrollstrukturen
In Java 2 Plattform 5.0 ist zu den bisherigen for-Schleifen die so genannte
erweiterte for-Schleife hinzugekommen.
546
14
Eine weitere Frage: Was passiert, wenn der Rckgabetyp Variable i vom Typ
her long ist? Die Antwort ist einfach: Der primitive Typ long ist grer als int
und es findet automatisch eine implizite Typanpassung statt.
public class ForSchleife {
public static void main(String[ ] args) {
int[ ] a = {1, 2, 3};
for (long i:a){
System.out.println(i);
}
}
}
Betrachten wir nun Arrays, die Objekte beinhalten. In unten stehendem Beispiel verwenden wir ein String-Array s, das der Variablen i, ebenfalls vom Typ
String, bergeben wird.
public class ForSchleife {
public static void main(String[ ] args) {
String[ ] s = {new String(1), new String(2), :
new String(3)};
for (String i:s){
System.out.println(i);
}
}
}
ndern wir nun den Typ String von i in den Typ Object, ist dies ohne Probleme mglich, da die Klasse Object die Mutter aller Klassen ist (Vgl. Kapitel
3.7 Subtyping und Casting von Objekten ab Seite 114).
public class ForSchleife {
public static void main(String[ ] args) {
String[ ] s = {new String(1), new String(2), :
new String(3)};
14.1 Kontrollstrukturen
547
Wollen Sie allerdings ein Objekt der Klasse Object einem String zuweisen,
fhrt dies, wie Sie unten sehen knnen, zu einem Kompilierfehler.
Weiter unten werden Sie sehen, dass uns diese neue for-Schleife auch gute
Dienste beim Auslesen von Collections/Generics leistet.
Welches Ergebnis erhlt man, wenn man folgendes Programm kompiliert und
startet?
public class FSchleife {
public static void main(String[ ] args) {
String[ ] s = {new String(44), new String(56), :
new String(73)};
for (String i:s){
System.out.println(i);
}
}
}
a) Keine Ausgabe.
b) 44 56 73
c) Kompilierfehler
(2) Frage
Welches Ergebnis erhlt man, wenn man folgendes Programm kompiliert und
startet?
public class FSchleife {
public static void main(String[ ] args) {
548
14
a) Keine Ausgabe.
b) 44 56 73
c) Kompilierfehler
(3) Frage
Welches Ergebnis erhlt man, wenn man folgendes Programm kompiliert und
startet?
public class FSchleife {
public static void main(String[ ] args) {
Object[ ] s = {new Object(), new Object(), new Object()};
for (String i:s){
System.out.println(i);
}
}
}
Welches Ergebnis erhlt man, wenn man folgendes Programm kompiliert und
startet?
public class FSchleife {
public static void main(String[ ] args) {
Object[ ] s = {new Object(), new Object(), new Object()};
for (Object i:s){
System.out.println(i);
}
}
}
14.2
Autoboxing
549
Lsungen
(1) Frage
(2) Frage
Das Programm luft ohne Probleme und hat 44 56 73 als Ausgabe, obwohl i vom Typ Object ist. Eine Zuweisung von einem Stringobjekt zu
einem Objekt der Klasse Object funktioniert ohne Probleme, da die
Klasse String eine Kindklasse der Klasse Object ist.
(3) Frage
(4) Frage
14.2 Autoboxing
14.2.1 Begriffsdefinition
Erinnern wir uns an das Kapitel 7.2 Die Wrapper-Klassen (Hllklassen): Die
Wrapper-Klassen waren dazu da, primitive Datentypen in Objekte umzuwandeln. Seit Java 1.5 muss man dies nicht mehr tun, da die Typumwandlung nun
automatisch geschieht. Dieser Vorgang nennt sich Autoboxing. Wird ein
Wrapper-Objekt automatisch in einen primitiven Datentyp berfhrt, spricht
man von Unboxing. Das englische Wort box kann mit Schachtel bersetzt
werden. Dies ist eine begriffliche Entsprechung zu den englischen Verben
wrap und unwrap, die die Bedeutung von ein- und auspacken haben. Das automatische Aufblasen von primitiven Datentypen in Objekte kostet sehr viel
Rechenzeit, wohingegen der umgekehrte Vorgang zu keinerlei Verzgerun-
550
14
gen fhrt. Wie Sie unten sehen knnen, besteht jetzt die Mglichkeit, einem
Wrapper-Objekt einen primitiven Datentyp direkt zuzuweisen:
public class AutoboxingAllgemein {
public static void main(String[ ] args) {
//seither: Instanziierung eines Integer-Wrapper-Objektes
Integer i = new Integer(10);
/*jetzt: Zuweisung primitiver Datentyp int zu einem einen IntegerWrapper*/
Integer i1 = 10;
//seither: Instanziierung eines Boolean-Wrapper-Objektes
Boolean b = new Boolean(true);
/*jetzt: Zuweisung primitiver Datentyp boolean zu einem einen BooleanWrapper*/
Boolean b1 = true;
}
}
Weisen Sie einem Boolean-Wrapper einen primitiven Datentyp zu, kann dieser nur zwei Ausprgungen annehmen: true und false. So wrde es zu einem
Kompilierfehler kommen, wenn Sie dem Boolean-Wrapper einen String-Literal, wie z. B. Boolean b = true;, zuweisen wrden.
Wenn Sie zu Kapitel 7.2 Die Wrapper-Klassen (Hllklassen) ab Seite 255
zurckblttern, werden Sie feststellen, dass es zustzliche Methoden zum
Umwandeln von primitiven Datentypen in Objekte und umgekehrt, wie z. B.
xxxValue( ) oder valueOf(String s), gibt. Diese Methoden knnen nach wie vor
problemlos verwendet werden.
14.2
Autoboxing
551
Nehmen wir ein weiteres Beispiel zur Verwendung von Operatoren: Eine Berechnung mit einem int und einem Integer-Objekt:
public class AutoboxingIntegerOperatoren {
public static void main(String[ ] args) {
Integer in = 500;
Integer i1 = new Integer(500);
int i = 19;
int ergebnis = i + in + i1;
Integer ergebnisInteger = i + in + i1;
System.out.println(ergebnis);
System.out.println(ergebnisInteger);
}
}
Was hat sich durch die Einfhrung des Autoboxings gendert? Seither konnten primitive Datentypen nicht mit ihren entsprechenden Wrapper-Objekten
verglichen werden. Es kam sowohl beim Vergleich mit dem Vergleichsopera-
552
14
tor (==) als auch mit der equals( )-Methode zu einem Kompilierfehler. Nun
knnen Sie beides und das Ergebnis des Vergleichs mit dem Vergleichsoperator == wird vom primitiven Datentyp bestimmt: Das Integer-Objekt wird in
eine primitive int-Zahl unboxed, wohingegen bei der equals( )-Methode die
int-Zahl automatisch in ein Wrapper-Objekt umgewandelt wird. So erhalten
Sie beide Male das Ergebnis true:
public class AutoboxingVergleich {
public static void main(String[ ] args) {
int i = 5;
Integer in = new Integer(5);
System.out.println(i == in);
System.out.println(in.equals(i));
}
}
Aber: Es kommt nach wie vor zu einem Kompilierfehler, wenn Sie versuchen
eine Methode auf einem primitiven Datentyp auszufhren, da primitive Datentypen keine Methoden besitzen. Der primitive Datentyp wird in diesem Fall
nicht automatisch in ein Wrapper-Objekt umgewandelt.
Beim Vergleich von Objekten und primitiven Datentypen, die sich zustzlich
noch durch den Datentyp unterscheiden, bekommen Sie beim Vergleich mit
== true als Ergebnis, da das Wrapper-Objekt in einen primitiven Datentyp
umgewandelt wird. Bei der equals( )-Methode erhalten Sie false als Resultat,
da hier der primitive Datentyp in ein Wrapper-Objekt umgewandelt wird
(siehe auch Kapitel 7 Wichtige Standardklassen (Fundamental Classes)
ab Seite 255).
public class UnterschiedlicheDatentypen {
public static void main(String[ ] args) {
double d = 2.0d;
Float f = 2.0f;
System.out.println(d == f);
System.out.println(f.equals(d));
}
}
14.2
Autoboxing
553
Welche Besonderheiten sind beim Vergleich von Integer-Objekten zu beachten, denen ein primitiver int zugewiesen worden ist? Die int-Werte im Intervall
von -128 bis +127 werden in einem Cache (Pool) als Immutable Objects gespeichert und nur einmal erzeugt, um Rechenzeit beim Autoboxing von int zu
Integer einzusparen. Entsprechendes gilt bei Byte- und Short-Objekten. Wir
erinnern uns in diesem Zusammenhang an die String-Literale, die es auch
nur einmal im String-Pool gab (siehe Kapitel 7.4 Die Klasse String und Kapitel 7.7.1 Vergleich von Strings). String-Literale werden allerdings nicht in
Objekte umgewandelt.
So erhalten Sie bei der Zahl -128 wider Erwarten unterschiedliche Ergebnisse: Beim Vergleich von Integer-Objekten, denen primitive int-Werte zugewiesen worden sind, erhalten Sie sowohl beim Vergleich mit dem Vergleichsoperator als auch beim Vergleich mit der equals( )-Methode true als
Ergebnis, da es diesen int-Wert im Cache nur einmal gibt. Bei Integer-Objekten werden dagegen nach wie vor beim Vergleichsoperator (==) die Referenzen verglichen und nicht der Inhalt. So erhalten Sie false als Resultat.
public class AutoboxingInteger {
public static void main(String[ ] args) {
Integer i = -128;
Integer in = -128;
Integer i1 = new Integer(-128);
Integer in1 = new Integer (-128);
System.out.println(i == in);
System.out.println(i.equals(in));
System.out.println(i1 == in1);
System.out.println(i1.equals(in1));
}
}
554
14
false
true
Bei der Zahl -129 erhalten Sie wieder gleiche Ergebnisse: Bei Zahlen auerhalb dieses Pools werden beim Vergleichsoperator (==), wie zu erwarten,
wieder die Referenzen miteinander verglichen.
public class AutoboxingInteger {
public static void main(String[ ] args) {
Integer i = -129;
Integer in = -129;
Integer i1 = new Integer(-129);
Integer in1 = new Integer (-129);
System.out.println(i == in);
System.out.println(i.equals(in));
System.out.println(i1 == in1);
System.out.println(i1.equals(in1));
}
}
Ebenfalls im Pool gespeicherte unvernderbare Objekte sind die BooleanWerte true and false, was bei unten stehendem Vergleich mit dem Vergleichsoperator eine Ausgabe von true zur Folge hat. Sollten Sie allerdings
zwei Boolean-Objekte miteinander vergleichen, erhalten Sie beim Vergleich
14.2
Autoboxing
555
mit == false als Ergebnis, da hiermit nach wie vor die Referenzen verglichen
werden und nicht der Inhalt.
public class AutoboxingBoolean {
public static void main(String[ ] args) {
Boolean b = true;
Boolean b1 = true;
System.out.println(b == b1);
System.out.println(b.equals(b1));
}
}
Hier nun eine Liste aller primitiven Datentypen, die als unvernderbare Objekte im Cache gespeichert werden:
alle byte-Werte
short-Werte von -128 bis +127
int-Werte -128 bis +127
char-Werte von \u0000 bis \u007F
Boolean-Werte true und false
(5) Vergleich von unterschiedlichen Wrapper-Objekten und unterschiedlichen
primitiven Datentypen
556
14
Gibt es allerdings keine entsprechende Methode, sondern nur noch berschriebene Methoden mit einem long- und einem Integer-Parameter, wird wider Erwarten die Methode mit dem long-Parameter aufgerufen. Es findet also
14.2
Autoboxing
557
kein Autoboxing statt, sondern eine implizite Typanpassung von int zu long
(vgl. Kapitel 2.6 Zuweisungen und Typumwandlung ab Seite 50).
public class AutoboxingMethoden {
public void schreiben(long i) {
System.out.println(long);
}
public void schreiben(Integer i) {
System.out.println(Integer);
}
public static void main(String[ ] args) {
AutoboxingMethoden a = new AutoboxingMethoden();
// Der Methode wird ein int bergeben
a.schreiben(9);
}
}
Existiert nur eine Methode schreiben( ) mit einem Integer-Objekt, wird diese
Methode aufgerufen, jetzt findet ein Autoboxing statt:
public class AutoboxingMethoden {
public void schreiben(Integer i) {
System.out.println(Integer);
}
public static void main(String[ ] args) {
AutoboxingMethoden a = new AutoboxingMethoden();
// Der Methode wird ein int bergeben
a.schreiben(9);
}
}
Was passiert, wenn es nur eine Methode schreiben( ) mit einem int-Wert als
Parameter gibt, und Sie der Methode ein Integer-Objekt bergeben? Jetzt
findet ein Unboxing statt: Das Integer-Objekt wird automatisch in einen primitiven Datentyp int umgewandelt.
public class AutoboxingMethoden {
public void schreiben(int i) {
System.out.println(int);
}
558
14
Wollen Sie allerdings einer Methode schreiben() mit dem Parameter Float einen Parameter int bergeben, kommt es zu einem Kompilierfehler. Es wird
nicht zuerst, wie man vielleicht erwarten knnte, ein int in ein float und dann
anschlieend dieser float-Wert automatisch in ein Float-Objekt umgewandelt, sondern es wird ein int-Wert automatisch in ein Integer-Objekt berfhrt.
Ein Integer-Objekt kann man auch nicht einer Methode bergeben, die einen
Parameter vom Typ Float vorgibt.
14.2
Autoboxing
559
560
14
Welches Ergebnis erhlt man, wenn man folgendes Programm kompiliert und
startet?
public class AutoboxingBool {
public static void main(String[ ] args) {
Boolean b = true;
boolean b2 = false;
Boolean b3 = b || b2;
boolean b4 = b && b2;
System.out.println(b3);
System.out.println(b4);
}
}
a) true false
b) false true
c) true true
d) false false
e) Kompilierfehler
f) Es wird eine Exception geworfen.
14.2
Autoboxing
561
(2) Frage
Welches Ergebnis erhlt man, wenn man folgendes Programm kompiliert und
startet?
public class AutoboxingB {
public static void main(String[ ] args) {
Boolean b = false;
Boolean b1 = false;
System.out.println(b == b1);
System.out.println(b.equals(b1));
}
}
a) true false
b) false true
c) true true
d) false false
e) Kompilierfehler
f) Es wird eine Exception geworfen.
(3) Frage
Welches Ergebnis erhlt man, wenn man folgendes Programm kompiliert und
startet?
public class AutoboxingB {
public static void main(String[ ] args) {
Boolean b = false;
Boolean b1 = false;
System.out.println(b == b1);
System.out.println(b.equals(b1));
}
}
a) true false
b) false true
c) true true
d) false false
e) Kompilierfehler
f) Es wird eine Exception geworfen.
562
14
(4) Frage
Welches Ergebnis erhlt man, wenn man folgendes Programm kompiliert und
startet?
public class AutoboxingB {
public static void main(String[ ] args) {
Boolean b = false;
Boolean b1 = new Boolean(false);
System.out.println(b == b1);
System.out.println(b1.equals(b));
}
}
a) true false
b) false true
c) true true
d) false false
e) Kompilierfehler
f) Es wird eine Exception geworfen.
(5) Frage
Welches Ergebnis erhlt man, wenn man folgendes Programm kompiliert und
startet?
public class AutoboxingB {
public static void main(String[ ] args) {
boolean b = false;
Boolean b1 = new Boolean(false);
System.out.println(b == b1);
System.out.println(b1.equals(b));
}
}
a) true false
b) false true
c) true true
d) false false
e) Kompilierfehler
f) Es wird eine Exception geworfen.
14.2
Autoboxing
563
(6) Frage
Welches Ergebnis erhlt man, wenn man folgendes Programm kompiliert und
startet?
public class AutoboxingB {
public static void main(String[ ] args) {
boolean b = false;
Boolean b1 = new Boolean(false);
System.out.println(b == b1);
System.out.println(b.equals(b1));
}
}
a) true false
b) false true
c) true true
d) false false
e) Kompilierfehler
f) Es wird eine Exception geworfen.
(7) Frage
Welches Ergebnis erhlt man, wenn man folgendes Programm kompiliert und
startet?
public class AutoboxingInt {
public static void main(String[ ] args) {
Integer in = 128;
Integer i1 = new Integer(128);
System.out.println(in == i1);
System.out.println(i1.equals(in));
}
}
a) true false
b) false true
c) true true
d) false false
e) Kompilierfehler
f) Es wird eine Exception geworfen.
564
14
(8) Frage
Welches Ergebnis erhlt man, wenn man folgendes Programm kompiliert und
startet?
public class AutoboxingInt {
public static void main(String[ ] args) {
Integer in = 128;
Integer i1 = 128;
System.out.println(in == i1);
System.out.println(i1.equals(in));
}
}
a) true false
b) false true
c) true true
d) false false
e) Kompilierfehler
f) Es wird eine Exception geworfen.
(9) Frage
Welches Ergebnis erhlt man, wenn man folgendes Programm kompiliert und
startet?
public class AutoboxingInt {
public static void main(String[ ] args) {
Integer in = 127;
Integer i1 = 127;
System.out.println(in == i1);
System.out.println(i1.equals(in));
}
}
a) true false
b) false true
c) true true
d) false false
e) Kompilierfehler
f) Es wird eine Exception geworfen.
14.2
Autoboxing
565
(10) Frage
Welches Ergebnis erhlt man, wenn man folgendes Programm kompiliert und
startet?
public class AutoboxingInt {
public static void main(String[ ] args) {
Integer in = new Integer(127);
Integer i1 = new Integer(127);
System.out.println(in == i1);
System.out.println(i1.equals(in));
}
}
a) true false
b) false true
c) true true
d) false false
e) Kompilierfehler
f) Es wird eine Exception geworfen.
(11) Frage
Welches Ergebnis erhlt man, wenn man folgendes Programm kompiliert und
startet?
public class AutoboxingM {
public void schreiben(int i) {
System.out.println(i);
}
public static void main(String[ ] args) {
AutoboxingM a = new AutoboxingM();
a.schreiben(9);}}
a) 9
b) Kompilierfehler
c) Es wird eine Exception geworfen.
(12) Frage
Welches Ergebnis erhlt man, wenn man folgendes Programm kompiliert und
startet?
public class AutoboxingM {
public void schreiben(long l) {
566
14
System.out.println(l);
}
public static void main(String[ ] args) {
AutoboxingM a = new AutoboxingM();
a.schreiben(9);
}
}
a) 9
b) Kompilierfehler
c) Es wird eine Exception geworfen.
(13) Frage
Welches Ergebnis erhlt man, wenn man folgendes Programm kompiliert und
startet?
public class AutoboxingM {
public void schreiben(byte b) {
System.out.println(b);
}
public static void main(String[ ] args) {
AutoboxingM a = new AutoboxingM();
a.schreiben(9);
}
}
a) 9
b) Kompilierfehler
c) Es wird eine Exception geworfen.
(14) Frage
Welches Ergebnis erhlt man, wenn man folgendes Programm kompiliert und
startet?
public class AutoboxingM {
public void schreiben(Float f) {
System.out.println(f);
}
public static void main(String[ ] args) {
AutoboxingM a = new AutoboxingM();
a.schreiben(9);
}}
14.2
Autoboxing
567
a) 9
b) Kompilierfehler
c) Es wird eine Exception geworfen.
(15) Frage
Welches Ergebnis erhlt man, wenn man folgendes Programm kompiliert und
startet?
public class AutoboxingM {
public void schreiben(long l) {
System.out.println(1);
}
public void schreiben(Integer i) {
System.out.println(2);
}
public static void main(String[ ] args) {
AutoboxingM a = new AutoboxingM();
a.schreiben(9);}}
a) 1
b) 2
c) Kompilierfehler
d) Es wird eine Exception geworfen.
(16) Frage
Welches Ergebnis erhlt man, wenn man folgendes Programm kompiliert und
startet?
public class AutoboxingM {
public void schreiben(long l) {
System.out.println(1);
}
public void schreiben(int i) {
System.out.println(2);
}
public static void main(String[ ] args) {
AutoboxingM a = new AutoboxingM();
a.schreiben(9);
}
}
a) 1
b) 2
568
14
c) Kompilierfehler
d) Es wird eine Exception geworfen.
(17) Frage
a) Double d = 100d;
b) Double d = 100;
c) Double d = 100,0;
d) Double d = 100.0;
Lsungen
(1) Frage
(2) Frage
Die Boolean-Werte true und false sind ebenfalls im Pool unvernderbare Objekte, so erhalten Sie bei Boolean-Werten, denen ein primitiver
Boolean-Wert zugewiesen worden ist, beim Vergleich mit == und mit
equals() jeweils true als Ergebnis.
(3) Frage
14.2
Autoboxing
569
(4) Frage
Beim Vergleich eines Boolean-Objektes, dem ein primitiver BooleanWert zugewiesen worden ist, und einem Boolean-Objekt werden beim
Vergleich mit dem Vergleichsoperator wieder die Referenzen miteinander verglichen.
(5) Frage
(6) Frage
(7) Frage
(8) Frage
(9) Frage
Die int-Werte im Intervall von -128 bis +127 werden in einem Cache
(Pool) als Immutable Object gespeichert und nur einmal erzeugt. Dies
hat beim Vergleich von Integer-Objekten, denen ein primitiver int-Wert
zugewiesen worden ist, zur Folge, dass Sie bei beiden Vergleichsarten
true als Ergebnis erhalten.
570
14
(10) Frage
(11) Frage
Der Methode schreiben() wird ein int-Wert bergeben und dies fhrt zur
Ausgabe der Zahl 9 auf der Konsole.
(12) Frage
Der Methode schreiben() wird ein int-Wert bergeben, der implizit in einen Wert long berfhrt wird, so wird die Zahl 9 auf der Konsole ausgegeben (vgl. Kapitel 2.6 Zuweisungen und Typumwandlung ab Seite
50).
(13) Frage
Es kommt zu einem Kompilierfehler, da der Methode schreiben() ein intWert bergeben wird, der nicht implizit in einen Wert byte umgewandelt
werden kann (vgl. Kapitel 2.6 Zuweisungen und Typumwandlung ab
Seite 50).
(14) Frage
(15) Frage
(16) Frage
Es wird die Methode, die einen int-Wert als Parameter hat, durchgefhrt.
(17) Frage
14.3
571
Es ist auch weitherhin mglich, Parameter unterschiedlichen Typs der Parameterliste hinzuzufgen, wobei darauf geachtet werden muss, dass die variable Argumentanzahl am Schluss steht. Ist dies nicht der Fall, kommt es zu
einem Kompilierfehler.
public class VariableArguments {
void aufrufen(int i, String... viele){
}
public static void main(String[ ] args) {
VariableArguments va = new VariableArguments();
va.aufrufen(1, eins, zwei, drei);
va.aufrufen(2, new String[ ]{hallo, Tschss});
}
}
572
14
14.3
573
Tschss
Welches Ergebnis erhlt man, wenn man folgendes Programm kompiliert und
startet?
public class VariableArgs {
void aufrufen(Integer... vieleZahlen){
for(Integer i: vieleZahlen){
System.out.println(i);
}
}
public static void main(String[ ] args) {
VariableArgs va = new VariableArgs();
va.aufrufen(1, 2, 3);
}
}
a) 1 2 3
b) Kompilierfehler
c) Es wird eine Exception geworfen.
574
14
(2) Frage
Welches Ergebnis erhlt man, wenn man folgendes Programm kompiliert und
startet?
public class VariableArgs {
void aufrufen(Integer... vieleZahlen, int i){
for(Integer i: vieleZahlen){
System.out.println(i);
}
}
public static void main(String[ ] args) {
VariableArgs va = new VariableArgs();
va.aufrufen(1, 2, 3);
}
}
a) 1 2 3
b) Kompilierfehler
c) Es wird eine Exception geworfen.
(3) Frage
Welches Ergebnis erhlt man, wenn man folgendes Programm kompiliert und
startet?
public class VariableArgs {
void aufrufen(Integer... vieleZahlen){
for(Integer i: vieleZahlen){
System.out.println(i);
}
}
public static void main(String[ ] args) {
VariableArgs va = new VariableArgs();
va.aufrufen(new Integer[ ] {1, 2, 3});
}
}
a) 1 2 3
b) Kompilierfehler
c) Es wird eine Exception geworfen.
14.3
575
(4) Frage
Welches Ergebnis erhlt man, wenn man folgendes Programm kompiliert und
startet?
public class VariableArgs {
void aufrufen(Integer... vieleZahlen){
for(Integer i: vieleZahlen){
System.out.println(i);
}
}
public static void main(String[ ] args) {
VariableArgs va = new VariableArgs();
va.aufrufen(new int[ ] {1, 2, 3});
}
}
a) 1 2 3
b) Kompilierfehler
c) Es wird eine Exception geworfen.
(5) Frage
Welches Ergebnis erhlt man, wenn man folgendes Programm kompiliert und
startet?
public class VariableArgs {
void aufrufen(Integer... vieleZahlen){
for(Integer i: vieleZahlen){
System.out.println(i);
}
}
void aufrufen(Integer[ ] vieleZahlen){
for(Integer i: vieleZahlen){
System.out.println(i);
}
}
public static void main(String[ ] args) {
VariableArgs va = new VariableArgs();
va.aufrufen(new Integer[ ] {1, 2, 3});
}
}
a) 1 2 3
b) Kompilierfehler
c) Es wird eine Exception geworfen.
576
14
Lsungen
(1) Frage
a Das Programm luft ohne Probleme und es wird 1 2 3 auf der Konsole
ausgegeben.
(2) Frage
b Sie knnen einer Methode, die ein Integer-Array vorgibt, kein int-Array
bergeben, da dies zu einem Kompilierfehler fhrt. Vergleichen Sie hierzu
auch das Kapitel 14.2.
(5) Frage
577
Mit der Einfhrung der Generics wird dieser Cast berflssig: Es werden
String-Objekte in die LinkedList ein- und wieder ausgegeben. Wie geschieht
dies? Folgendermaen: Das Objekt der Klasse LinkedList wird um den entsprechenden Typ <String> ergnzt. So wird sichergestellt, dass nur noch
Stringobjekte der LinkedList hinzugefgt werden drfen. Hiermit wird eine so
genannte Typsicherheit gewhrleistet, die nur fr Objekte und nicht fr primitive Datentypen gilt. Auerdem wird es durch die erweiterte for-Schleife einfacher, die Strings aus der LinkedList auszulesen, da der Iterator berflssig
wird. Verwenden Sie weiterhin den Iterator, werden auch in der neuen JavaVersion nur Objekte der Klasse java.lang.Object zurckgegeben.
import java.util.LinkedList;
public class GenericsCollectionList {
public static void main(String[ ] args) {
LinkedList<String> s = new LinkedList<String>();
//oder: LinkedList s = new LinkedList<String>();
//oder: LinkedList<String> s = new LinkedList();
//oder: List <String> s = new LinkedList<String>();
String st = new String(delta);
String st1 = new String(aber);
String st2 = new String(beta);
s.add(st);
s.add(st1);
s.add(st2);
for (String r:s){
System.out.println(r);
}
578
14
}
}
Wrden Sie die LinkedList wie folgt LinkedList<Object> s = new LinkedList<String>(); instanziieren, wrde dies zu einem Kompilierfehler fhren, da
man links nur Objekte der Klasse java.lang.Object und rechts nur Objekte der
Klasse java.lang.String einfgen darf. Es kommt zu Problemen, da ein String
zwar ein Subtyp von Object ist, aber LinkedList<String> kein Subtyp von LinkedList<Object>. Die Klasse String ist eine Kindklasse von Klasse Object,
wohingegen LinkedList<String> keine Kindklasse von LinkedList<Object> ist
(vgl. Kapitel 3.7 Subtyping und Casting von Objekten ab Seite 114).
import java.util.LinkedList;
public class GenericsCollectionList {
public static void main(String[ ] args) {
//folgende Zeile wrde zu einem Kompilierfehler fhren:
LinkedList<Object> s = new LinkedList<String>();
String st = new String(delta);
String st1 = new String(aber);
String st2 = new String(beta);
s.add(st);
s.add(st1);
s.add(st2);
for (String r:s){
System.out.println(r);
}
}
}
Sie knnen fr die Variable r auch weiterhin den Typ Object definieren, dies
funktioniert ohne weiteres, da Object eine Superklasse der Stringklasse ist
(vgl. Kapitel 14.1.1 Die erweiterte for-Schleife). Bitte beachten Sie, dass,
wenn Sie weiterhin den Iterator fr Generics benutzen wollen, nach wie vor
Objekte der Klasse java.lang.Object zurckgegeben werden.
Was allerdings ohne Probleme mglich ist, ist eine Zuweisung einer generischen LinkedList zu einer LinkedList. Dies macht allerdings wenig Sinn bzw.
widerspricht der Idee der Generics, da der LinkedList wieder Objekte hinzugefgt werden und wieder Objekte ausgelesen werden.
public class GenericsCollectionList {
public static void main(String[ ] args) {
LinkedList s = new LinkedList<String>();
579
In unten stehendem Beispiel kann man, obwohl es auf den ersten Blick dem
bisher Gesagten widerspricht, einer LinkedList<Object> Stringobjekte hinzufgen. Dies ist mglich, da ein Objekt der Klasse String ein Subtyp der Klasse
Object ist, oder will man es vereinfacht ausdrcken, ein String ist aufgrund
der Verwandtschaftsverhltnisse ein Objekt, da die Klasse Object eine Superklasse der Klasse String ist. Sie erhalten jedoch Objekte der Klasse Object zurck, obwohl Sie Stringobjekte hinzufgen. Deshalb wrde es zu einem Kompilierfehler fhren, wenn Sie fr r den Rckgabetyp String festlegen
wrden (vgl. Kapitel 14.1.1 Die erweiterte for-Schleife).
import java.util.LinkedList;
public class GenericsCollectionList {
public static void main(String[ ] args) {
LinkedList<Object> s = new LinkedList<Object>();
String st = new String(delta);
String st1 = new String(aber);
String st2 = new String(beta);
s.add(st);
s.add(st1);
s.add(st2);
for(Object r:s){
System.out.println(r);
}
}
}
580
14
581
Es liegt nahe zu fragen: Wie lse ich dieses Problem? Mit Wildcards. Ersetzen Sie nun List<Object> durch List<? extends Object>, knnen Sie der Methode public void auslesen(List<? extends Object> l) alle Listen, die Objekte
der Klasse Object und alle dazugehrigen Subklassen enthalten, als Parameter bergeben. Diese Beziehung heit fr Objekte und Interfaces extends:
<? extends MeinObjekt> und <? extends MeinInterface>. Es besteht die
Mglichkeit, auch nur <?> zu schreiben, dann sind mit dem Fragezeichen alle
Objekte aller Typen gemeint.
import java.util.List;
import java.util.LinkedList;
public class GenericsCollectionList {
public static void main(String[ ] args) {
LinkedList<String> s = new LinkedList<String>();
String st = new String(delta);
String st1 = new String(aber);
String st2 = new String(beta);
s.add(st);
s.add(st1);
s.add(st2);
GenericsCollectionList g = new GenericsCollectionList();
g.auslesen(s);
}
public void auslesen(List<? extends Object> l){
for (Object r:l){
System.out.println(r);
}
}
}
582
14
583
}
}
Was passiert, wenn Sie bereits bei der Instanziierung, wie unten, fr den Typ
auf der linken Seite LinkedList<? extends Object> s oder LinkedList<?> s definieren? Zuerst geschieht nichts. Sie erhalten erst einen Kompilierfehler,
wenn Sie mit der Methode add() ein Element hinzufgen wollen. Der Grund
hierfr ist: Der Typ von LinkedList<? extends Object> s wurde nicht genau
bestimmt, die Methode add() braucht aber einen genau festgelegten Typ des
Parameters der LinkedList, um den Forderungen der Typsicherheit entsprechen zu knnen. Typsicherheit soll gewhrleisten, dass nur bestimmte Objekte eingelesen werden drfen.
584
14
Wenn die Elemente der List li ausgelesen werden, erhalten Sie Objekte der
Klasse java.lang.Object zurck. Dies mssen Sie auch in der for-Schleife bedenken: ndern Sie den Typ der Variable r vom Typ Object in den Typ String,
kommt es zu einem Kompilierfehler.
585
den Nachteil: Objekte, wie z. B. ein Buch, wurden automatisch in ein Objekt
der Klasse java.lang.Object berfhrt und mussten somit wieder in ein Objekt
der Klasse Buch gecastet werden.
import java.util.Comparator;
public class BuchVergleich implements Comparator{
public int compare(Object o1, Object o2) {
/*Das bergebene Objekt wird in ein Objekt der Klasse java.lang.Object
umgewandelt und muss somit wieder in ein Buch gecastet werden */
return (((Buch)o1).getAutor().compareTo(((Buch) o2).getAutor()));
}
}
ndern wir unsere ursprngliche Klasse Buchvergleich, die das ComparatorInterface implementiert hatte, entsprechend ab, sieht sie nun wie unten stehend aus. Wie Sie sehen knnen, erspart die so erlangte Typsicherheit jegliches Casten.
import java.util.Comparator;
public class BuchVergleich implements Comparator<Buch>{
public int compare(Buch b1, Buch b2) {
return (b1.getAutor().compareTo(b2.getAutor()));
}
}
Einige wichtige Bemerkungen zum Schluss: Das <T>, mit dem die Typsicherheit bei Objekten garantiert wird, wird bei Klassen des Collections Frameworks durch ein <E> ersetzt. Auerdem knnen statische Bestandteile einer
Klasse den Typ der Klasse nicht bernehmen, da es statische Bestandteile
pro Klasse nur einmal gibt. So wrden sich zwei Objekte mit unterschiedlichen Typen (Zahl<Integer> und Zahl<Float>) den gleichen statischen Bestandteil teilen, dies widersprche der Typsicherheit. Eine statische Methode
kann allerdings einen eigenen Typ haben.
586
14
587
588
14
589
Spitze der Queue kein Element findet, wohingegen die Methode element()
beim gleichen Ergebnis eine Exception wirft.
b) Priority Queue
Die Klasse Priority Queue implementiert das Interface Queue, die allerdings
wie die Klassen TreeSet und TreeMap ihre Elemente alphabetisch und nach
Zahlen aufsteigend sortiert. Und die Elemente mssen ebenfalls entweder
das Comparator- oder das Comparable korrekt umsetzen (vgl. Kapitel 12.5
Comparator- und Comparable Interface).
Welches Ergebnis erhlt man, wenn man folgendes Programm kompiliert und
startet?
import java.util.List;
import java.util.LinkedList;
public class Generics {
public static void main(String[ ] args) {
LinkedList<String> ll = new LinkedList<String>();
String s = new String(eins);ll.add(s);
Generics g = new Generics(); g.auslesen(ll);
}
public void auslesen(List<? extends Object> l){
for (Object r:l){
System.out.println(r);
}
}
}
a) eins
b) Kompilierfehler in Zeile 1
c) Kompilierfehler in Zeile 2
d) Kompilierfehler in Zeile 3
e) Kompilierfehler in Zeile 4
f) Kompilierfehler in Zeile 5
Zeile 1
Zeile 2
Zeile 3
Zeile 4
Zeile 5
590
14
(2) Frage
Welches Ergebnis erhlt man, wenn man folgendes Programm kompiliert und
startet?
import java.util.List;
import java.util.LinkedList;
public class Generics {
public static void main(String[ ] args) {
LinkedList<Object> ll = new LinkedList<String>();
String s = new String(eins);
ll.add(s);
Generics g = new Generics();
g.auslesen(ll);
}
public void auslesen(List<? extends Object> l){
for (Object r:l){
System.out.println(r);
}
}
Zeile 1
Zeile 2
Zeile 3
Zeile 4
Zeile 5
a) eins
b) Kompilierfehler in Zeile 1
c) Kompilierfehler in Zeile 2
d) Kompilierfehler in Zeile 3
e) Kompilierfehler in Zeile 4
f) Kompilierfehler in Zeile 5
(3) Frage
Welches Ergebnis erhlt man, wenn man folgendes Programm kompiliert und
startet?
import java.util.List;
import java.util.LinkedList;
public class Generics {
public static void main(String[ ] args) {
LinkedList<String> ll = new LinkedList<String>();
String s = new String(eins);
ll.add(s);
Generics g = new Generics();
g.auslesen(ll);
}
Zeile 1
Zeile 2
Zeile 3
591
Zeile 4
Zeile 5
}
}
a) eins
b) Kompilierfehler in Zeile 1
c) Kompilierfehler in Zeile 2
d) Kompilierfehler in Zeile 3
e) Kompilierfehler in Zeile 4
f) Kompilierfehler in Zeile 5
(4) Frage
Welches Ergebnis erhlt man, wenn man folgendes Programm kompiliert und
startet?
import java.util.List;
import java.util.LinkedList;
public class Generics {
public static void main(String[ ] args) {
LinkedList<String> ll = new LinkedList<String>();
String s = new String(eins);
ll.add(s);
Generics g = new Generics();
g.auslesen(ll);
}
public void auslesen(List<? extends Object> l){
for (String r:l){
System.out.println(r);
}
}
}
a) eins
b) Kompilierfehler in Zeile 1
c) Kompilierfehler in Zeile 2
d) Kompilierfehler in Zeile 3
e) Kompilierfehler in Zeile 4
f) Kompilierfehler in Zeile 5
Zeile 1
Zeile 2
Zeile 3
Zeile 4
Zeile 5
592
14
(5) Frage
Welches Ergebnis erhlt man, wenn man folgendes Programm kompiliert und
startet?
import java.util.List;
import java.util.LinkedList;
public class Generics {
public static void main(String[ ] args) {
LinkedList<? extends Object> ll = new
LinkedList<String>();
String s = new String(eins);
ll.add(s);
Generics g = new Generics();
g.auslesen(ll);
}
public void auslesen(List<? extends Object> l){
for (Object r:l){
System.out.println(r);
}
}
}
Zeile 1
Zeile 2
Zeile 3
Zeile 4
Zeile 5
a) eins
b) Kompilierfehler in Zeile 1
c) Kompilierfehler in Zeile 2
d) Kompilierfehler in Zeile 3
e) Kompilierfehler in Zeile 4
f) Kompilierfehler in Zeile 5
(6) Frage
Welches Ergebnis erhlt man, wenn man folgendes Programm kompiliert und
startet?
import java.util.List;
import java.util.LinkedList;
public class Generics {
public static void main(String[ ] args) {
LinkedList<Object> ll = new LinkedList<Object>();
String s = new String(eins);
ll.add(s);
Generics g = new Generics();
g.auslesen(ll);
}
public void auslesen(List<? extends Object> l){
Zeile 1
Zeile 2
Zeile 3
Zeile 4
593
Zeile 5
}
}
a) eins
b) Kompilierfehler in Zeile 1
c) Kompilierfehler in Zeile 2
d) Kompilierfehler in Zeile 3
e) Kompilierfehler in Zeile 4
f) Kompilierfehler in Zeile 5
(7) Frage
Welches Ergebnis erhlt man, wenn man folgendes Programm kompiliert und
startet?
import java.util.List;
import java.util.LinkedList;
public class Generics {
public static void main(String[ ] args) {
LinkedList<Object> ll = new LinkedList<Object>();
String s = new String(eins);
ll.add(s);
Generics g = new Generics();
g.auslesen(ll);
}
public void auslesen(List<Object> l){
for (Object r:l){
System.out.println(r);
}
}
}
a) eins
b) Kompilierfehler in Zeile 1
c) Kompilierfehler in Zeile 2
d) Kompilierfehler in Zeile 3
e) Kompilierfehler in Zeile 4
f) Kompilierfehler in Zeile 5
Zeile 1
Zeile 2
Zeile 3
Zeile 4
Zeile 5
594
14
(8) Frage
Welches Ergebnis erhlt man, wenn man folgendes Programm kompiliert und
startet?
import java.util.List;
import java.util.LinkedList;
public class Generics {
public static void main(String[ ] args) {
LinkedList<Object> ll = new LinkedList<Object>();
String s = new String(eins);
ll.add(s);
Generics g = new Generics();
g.auslesen(ll);
}
public void auslesen(List<Object> l){
for (String r:l){
System.out.println(r);
}
}
}
Zeile 1
Zeile 2
Zeile 3
Zeile 4
Zeile 5
a) eins
b) Kompilierfehler in Zeile 1
c) Kompilierfehler in Zeile 2
d) Kompilierfehler in Zeile 3
e) Kompilierfehler in Zeile 4
f) Kompilierfehler in Zeile 5
(9) Frage
Welches Ergebnis erhlt man, wenn man folgendes Programm kompiliert und
startet?
import java.util.LinkedList;
public class Generics2 {
public static void main(String[ ] args) {
LinkedList<Object> ll = new LinkedList<Object>();
String s = new String(eins);
String s1 = new String(zwei);
ll.add(s);
ll.add(s1);
for (Object r:ll){
System.out.println(r);
}
}
}
Zeile 1
Zeile 2
Zeile 3
Zeile 4
595
a) eins zwei
b) Kompilierfehler in Zeile 1
c) Kompilierfehler in Zeile 2
d) Kompilierfehler in Zeile 3
e) Kompilierfehler in Zeile 4
(10) Frage
Welches Ergebnis erhlt man, wenn man folgendes Programm kompiliert und
startet?
import java.util.LinkedList;
public class Generics2 {
public static void main(String[ ] args) {
LinkedList<Object> ll = new LinkedList<Object>();
String s = new String(eins);
String s1 = new String(zwei);
ll.add(s);
ll.add(s1);
for (String r:ll){
System.out.println(r);
}
}
}
Zeile 1
Zeile 2
Zeile 3
Zeile 4
a) eins zwei
b) Kompilierfehler in Zeile 1
c) Kompilierfehler in Zeile 2
d) Kompilierfehler in Zeile 3
e) Kompilierfehler in Zeile 4
(11) Frage
Welches Ergebnis erhlt man, wenn man folgendes Programm kompiliert und
startet?
import java.util.LinkedList;
public class Generics2 {
public static void main(String[ ] args) {
LinkedList<String> ll = new LinkedList();
String s = new String(eins);
String s1 = new String(zwei);
ll.add(s);
ll.add(s1);
for (String r:ll){
Zeile 1
Zeile 2
Zeile 3
Zeile 4
596
14
}
}
a) eins zwei
b) Kompilierfehler in Zeile 1
c) Kompilierfehler in Zeile 2
d) Kompilierfehler in Zeile 3
e) Kompilierfehler in Zeile 4
(12) Frage
Welches Ergebnis erhlt man, wenn man folgendes Programm kompiliert und
startet?
import java.util.List;
import java.util.LinkedList;
public class Generics2 {
public static void main(String[ ] args) {
LinkedList<String> ll = new LinkedList<String>();
String s = new String(eins);
String s1 = new String(zwei);
ll.add(s);
ll.add(s1);
List<? extends Object> l = ll;
for (Object r:l){
System.out.println(r);
}
}
}
a) eins zwei
b) Kompilierfehler in Zeile 1
c) Kompilierfehler in Zeile 2
d) Kompilierfehler in Zeile 3
e) Kompilierfehler in Zeile 4
f) Kompilierfehler in Zeile 5
Zeile 1
Zeile 2
Zeile 3
Zeile 4
Zeile 5
597
(13) Frage
Welches Ergebnis erhlt man, wenn man folgendes Programm kompiliert und
startet?
import java.util.List;
import java.util.LinkedList;
public class Generics2 {
public static void main(String[ ] args) {
LinkedList<String> ll = new LinkedList<String>();
String s = new String(eins);
String s1 = new String(zwei);
ll.add(s);
ll.add(s1);
List<? extends Object> l = ll;
for (String r:l){
System.out.println(r);
}
}
}
Zeile 1
Zeile 2
Zeile 3
Zeile 4
Zeile 5
a) eins zwei
b) Kompilierfehler in Zeile 1
c) Kompilierfehler in Zeile 2
d) Kompilierfehler in Zeile 3
e) Kompilierfehler in Zeile 4
f) Kompilierfehler in Zeile 5
(14) Frage
Welches Ergebnis erhlt man, wenn man folgendes Programm kompiliert und
startet?
import java.util.List;
import java.util.LinkedList;
import java.util.Collections;
public class Generics2 {
public static void main(String[ ] args) {
LinkedList<String> ll = new LinkedList();
String s = new String(omega);
String s1 = new String(alpha);
ll.add(s);
ll.add(s1);
Collections.sort(ll);
for (String r:ll){
598
14
}
}
a) omega alpha
b) alpha omega
c) Kompilierfehler, da in der Klasse Collections keine Methode sort() existiert.
d) Kompilierfehler, da Sie die Methode sort() der Klasse LinkedList htten
nehmen mssen.
(15) Frage
Welches Ergebnis erhlt man, wenn man folgendes Programm kompiliert und
startet?
import java.util.List;
import java.util.LinkedList;
public class Generics2 {
public static void main(String[ ] args) {
LinkedList<String> ll = new LinkedList();
String s = new String(omega);
String s1 = new String(alpha);
ll.add(s);
ll.add(s1);
ll.sort( );
for (String r:ll){
System.out.println(r);
}
}
}
a) omega alpha
b) alpha omega
c) Kompilierfehler, da in der Klasse LinkedList keine Methode sort() existiert.
(16) Frage
Welches Ergebnis erhlt man, wenn man folgendes Programm kompiliert und
startet?
import java.util.Hashtable;
import java.util.Map;
public class GenericsHash {
public static void main(String[ ] args) {
599
String s1 = 1;
String s2 = 1;
String w1 = yes;
String w2 = no;
Hashtable<String, String> h = new Hashtable<String, String>();
h.put(s1, w1);
h.put(s2, w2);
for(String key : h.keySet()){
System.out.println(key );
System.out.println(h.get(key) );
}
}
}
a) 1 no
b) 1 yes
c) 1 no 1 yes
d) Kompilierfehler
(17) Frage
Welches Ergebnis erhlt man, wenn man folgendes Programm kompiliert und
startet?
import java.util.Hashtable;
import java.util.Map;
public class GenericsHash {
public static void main(String[ ] args) {
String s1 = 1;
String s2 = 2;
String w1 = yes;
String w2 = no;
Hashtable<String, String> h = new Hashtable<String, String>();
h.put(s1, w1);
h.put(s2, w2);
for(Map.Entry<String,String> entry : h.entrySet()){
System.out.println(entry.getKey() );
System.out.println(entry.getValue() );
}
}
}
a) 1 yes
600
14
b) 2 no
c) Die Reihenfolge der Eingabe der Elemente ist nicht identisch mit der Reihenfolge der Ausgabe.
d) Kompilierfehler.
(18) Frage
Welches Ergebnis erhlt man, wenn man folgendes Programm kompiliert und
startet?
import java.util.Hashtable;
import java.util.Map;
public class GenericsHash {
public static void main(String[ ] args) {
String s1 = 1;
String s2 = 1;
String w1 = yes;
String w2 = no;
Hashtable<String, String> h = new Hashtable<String, String>();
h.put(s1, w1);
h.put(s2, w2);
for(StringBuffer key : h.keySet()){
System.out.println(key );
System.out.println(h.get(key) );
}
}
}
a) 1 no
b) 1 yes
c) 1 no 1 yes
d) Kompilierfehler
(19) Frage
Welches Ergebnis erhlt man, wenn man folgendes Programm kompiliert und
startet?
import java.util.Arrays;
public class ArraysB {
public static void main(String[ ] args) {
String[ ] s = {alpha, omega, emil};
int i = Arrays.binarySearch(s, emil);
601
System.out.println(i);
}
}
a) 0
b) 1
c) 2
d) Ergebnis kann nicht exakt vorausgesagt werden.
(20) Frage
Welches Ergebnis erhlt man, wenn man folgendes Programm kompiliert und
startet?
import java.util.Arrays;
public class ArraysB {
public static void main(String[ ] args) {
String[ ] s = {alpha, omega, emil};
Arrays.sort(s);
int i = Arrays.binarySearch(s, emil);
System.out.println(i);
}
}
a) 0
b) 1
c) 2
d) Ergebnis kann nicht exakt vorausgesagt werden.
(21) Frage
Welches Ergebnis erhlt man, wenn man folgendes Programm kompiliert und
startet?
import java.util.ArrayList;
import java.util.Collections;
public class ArrayListB {
public static void main(String[ ] args) {
ArrayList<String> s = new ArrayList<String>();
String st = new String(computer);
String st1 = new String(haus);
String st2 = new String(baum);
s.add(st);
s.add(st1);
s.add(st2);
Collections.sort(s);
602
14
a) 0
b) 1
c) 2
d) Ergebnis kann nicht exakt vorausgesagt werden.
(22) Frage
a) toArray(s)
b) asList(s)
c) offer(s)
d) binarSearch(s)
e) sort(s)
(23) Frage
Was gibt die Methode poll() zurck, wenn die Queue leer ist?
a) Es wird eine Exception geworfen
b) false
c) null
d) true
603
Lsungen
(1) Frage
(2) Frage
Die Klasse String ist zwar eine Kindklasse von Klasse Object, aber die
Klasse LinkedList<String> ist keine Kindklasse von LinkedList<Object>
(vgl. auch Kapitel 3.7 Subtyping und Casting von Objekten ab Seite
114).
(3) Frage
(4) Frage
Achtung! Es kommt in Zeile 5 zu einem Kompilierfehler, da die LinkedList<String> durch bergabe an die Methode keine Stringobjekte mehr
zurckgibt, sondern Objekte der Klasse Object.
(5) Frage
Es kommt zu einem Kompilierfehler, da der Typ von LinkedList<? extends Object> nicht genau festgelegt wurde, die Methode add() allerdings einen genau festgelegten Typ braucht, um den Forderungen der
Typsicherheit Genge zu tun.
(6) Frage
(7) Frage
Es kommt zu keinem Fehler, es ist mglich, eine LinkedList<Object> einer Methode zu bergeben, die als Parameter eine List<Object> hat, da
die LinkedList<Object> ein Subtyp der List<Object> ist.
(8) Frage
Es ist zwar mglich, eine LinkedList<Object> einer Methode zu bergeben, die als Parameter eine List<Object> hat, da die LinkedList<Object> ein Subtyp der List<Object> ist, aber beim Auslesen der Elemente
erhalten Sie dann wieder Objekte der Klasse Object zurck. So msste
604
14
auch r wieder vom Typ Object sein, sie ist aber vom Typ String, so
kommt es in Zeile 5 zu einem Kompilierfehler.
(9) Frage
(10) Frage
Achtung, es kommt in Zeile 4 zu einem Fehler, da eine LinkedList<Object> Objekte ausliest, auch wenn ihr Objekte der Klasse String bergeben werden.
(11) Frage
(12) Frage
Es kommt zu keinerlei Fehlern, da eine Zuweisung List<? extends Object>l = ll ohne weiteres mglich ist.
(13) Frage
Es wird in der Zeile 4 die LinkedList<String> einer List<? extends Objects> zugewiesen, dies ist zwar ohne Schwierigkeiten machbar, aber
achten Sie darauf, dass die Liste jetzt keine Stringobjekte mehr zurckgibt, sondern Objekte der Klasse Object, so kommt es in Zeile 5 zu
einem Fehler.
(14) Frage
(15) Frage
605
(16) Frage
(17) Frage
Die Elemente einer Hashtable werden nicht sortiert, somit ist die Reihenfolge der Ausgabe der Elemente nicht identisch mit der Reihenfolge
der Eingabe (vgl. Kapitel Collections Framework).
(18) Frage
(19) Frage
(20) Frage
Der Inhalt des Arrays wird sortiert und nach dem Sortieren befindet sich
das Wort alpha an der Stelle 0, das Wort emil an der Stelle 1 und das
Wort omega an der Stelle 2. Somit ist das Ergebnis 1, da nun das Wort
emil an der Indexposition 1 ist.
(21) Frage
(22) Frage
(23) Frage
Die Methoden poll() und remove() lschen Elemente an der Spitze der
Queue. Die Methode poll() wirft im Gegensatz zur Methode remove()
keine Exception, wenn die Queue leer ist, sondern gibt null zurck.
606
14
14.5 Enums
14.5.1 Begriffsbestimmung
Nehmen wir einmal an, Sie brauchen immer wieder die gleichen drei Anredeformen fr Ihr Online-Formular, in das Sie Adressen eingeben. Seit Java 5.0
geht dies mit den so genannten Enums. Hier ein Beispiel einer Aufzhlung
von mglichen Anreden in einem Men.
Enums werden wie unten stehend formuliert. Mit Enums haben Sie Gelegenheit, eine Enumeration, zu deutsch Aufzhlung, festzulegen. Bitte beachten
Sie, dass bei einem Enum nicht class steht, sondern enum. Wichtig: Die Aufzhlung wird durch ein Semikolon abgeschlossen und die Werte eines
Enums sind implizit public static final.
public enum Anrede {
Herr, Frau, Familie;
}
In Java 1.4 muss eine Aufzhlung noch viel aufwendiger und weniger komfortabel bestimmt werden:
public class AnredeAlt {
public static final int Herr = 1;
public static final int Frau = 2;
public static final int Familie = 3;
}
Wenn Sie ein Enum definieren, erstellen Sie eine neue Klasse, die implizit
eine extends-Beziehung zu der Klasse java.lang.Enum erzeugt. Und da jede
Klasse nur eine extends-Beziehung haben kann, kann ein Enum per Definition keine zustzliche extends-Beziehung besitzen. Auerdem implementiert
die Klasse Enum sowohl das Serializable als auch das Comparable Interface. Ein Enum kann nicht instanziiert, sondern nur einer Referenzvariablen
vom Typ Anrede zugewiesen werden.
public enum Anrede {
Herr, Frau, Familie;
public static void main(String[ ] args){
// Zuweisung eines Enumwertes zu einer Referenzvariablen
14.5
Enums
607
Wollen Sie fr Ihr Enum keine separate Klasse erstellen, ist es ebenfalls
denkbar, das Enum innerhalb einer Klasse zu definieren. Das Ergebnis ist
dann eine statische innere Klasse.
Sie knnen aber auch nur einen bestimmten Teil aller Enum-Werte auslesen:
Dies ist mit der statischen Methode EnumSet.range() der Klasse
java.util.EnumSet mglich, die Sie dazu importieren mssen. Da eine teilweise Wiedergabe bei drei Elementen keinen Sinn macht, lassen Sie uns das
Enum Anrede um eine weitere Anrede ergnzen, nmlich um die Anrede
Firma. Nun wollen wir nur alle privaten Anredeformen ausgeben. Dies tun wir
in unten stehendem Beispiel.
import java.util.EnumSet;
public enum Anrede {
Herr, Frau, Familie, Firma;
public static void main(String[ ] args){
608
14
Was ist nun, wenn Sie einer Person einen Brief schreiben wollen, und automatisch die richtige Anrede (z. B. Sehr geehrte Frau, ) zu Beginn des Textes
erscheinen soll? Sie knnen einem Enum eine Methode hinzufgen. In unserem Beispiel ist dies die Methode public String anschreiben(){return Sehr
geehrte Damen und Herren, ;}. Diese kann fr jeden Enum-Wert berschrieben werden: Sie knnen hinter den einzelnen Elementen in einer geschweiften Klammer eine gleichnamige Methode, mit anderem Inhalt, einfgen (vgl. Kapitel 3.5 berladen und berschreiben von Methoden ab Seite
88).
public enum Anrede {
Herr {
public String anschreiben(){
return Sehr geehrter Herr, ;
}
},
Frau {
public String anschreiben(){
return Sehr geehrte Frau, ;
}
},
Familie {
public String anschreiben(){
return Sehr geehrte Familie, ;}
},
Firma;
public static void main(String[ ] args){
for(Anrede a: Anrede.values()){
System.out.println(a +
+ a.anschreiben());
14.5
Enums
609
}
}
public String anschreiben(){
return Sehr geehrte Damen und Herren, ;
}
}
Zustzlich gibt es noch die Mglichkeit, den Inhalt der Variablen Anrede.Herr, der bis zu diesem Augenblick Herr ist, zu ndern. Wie geschieht
dies? Sie berschreiben die bereits existierende toString()-Methode der
Klasse java.lang.Enum in der geschweiften Klammer nach dem Enumerationswert. Was ist der Unterschied zu der Lsung, eigene Methoden einem
Enum hinzuzufgen? Der Inhalt von Anrede.Herr wird von Herr in Sehr geehrter Herr, gendert. Diese Lsung wrde dann wie folgt aussehen:
public enum Anrede {
Herr {
public String toString(){
return Sehr geehrter Herr,;
}
},
Frau {
public String toString(){
return Sehr geehrte Frau,;
}
},
Familie {
public String toString(){
return Sehr geehrte Familie,;
}
},
Firma{
public String toString(){
return Sehr geehrte Damen und Herren,;
}
};
public static void main(String[ ] args){
for(Anrede a: Anrede.values()){
System.out.println(a + + a.toString());
}
610
14
14.5
Enums
611
System.out.println(m + + m.getTage());
}
}
}
612
14
Nach case darf in der switch-Struktur statt Januar nicht Monate.Januar stehen, da es in diesem Fall, wie Sie unten sehen knnen, zu einem Kompilierfehler kommt. Auerdem darf in der Klammer nach switch auch nicht Monate
stehen.
Steht die switch-Struktur in einer nicht-statischen Methode, kann der Ausdruck in der Klammer nach switch auch this sein (vgl. Kapitel 3.6 Objektreferenz und Konstruktoraufruf mit this und super ab Seite 101), wobei sich
this auf das Enum Monate bezieht.
public enum Monate {
Januar(31), Februar(28), Mrz(31);
private String tage;
Monate(String tage){
this.tage = tage;
}
public String getTage(){
return tage;
}
public void waehlen(){
switch (this){
case Januar:
System.out.println(Es ist kalt);
break;
case Februar:
System.out.println(Es ist immer noch kalt);
break;
14.5
Enums
613
case Mrz:
System.out.println(Frhling);
}
}
public static void main(String[ ] args){
Monate m = Monate.Februar;
m.waehlen();
}
}
Was passiert nun, wenn Sie den konstanten Enumwert, den die valueOf()Methode zurckgibt, mit dem Enumwert Wochentage.Montag vergleichen?
Das Ergebnis ist sowohl beim Vergleich mit == als auch mit equals() true.
public enum Wochentage {
Montag, Dienstag, Mittwoch, Donnerstag, Freitag;
public static void main(String[ ] args){
Wochentage w = Wochentage.valueOf(Montag);
System.out.println(w == Wochentage.Montag);
System.out.println(w.equals(Wochentage.Montag));
}
}
614
14
Dies ist u. a. durch einen so genannten statischen Import mglich. Ich habe
Ihnen die verschiedenen Kombinationen der Arten des statischen und nichtstatischen Imports des Enums Anrede und der zugehrigen Zugriffsarten innerhalb der Klasse in unten stehender Tabelle zusammengestellt:
Import der Klasse
Zugriffsarten
import scjp.Anrede;
import scjp.*;
import static scjp.Anrede.*; oder
import static scjp.Anrede.Frau;
Anrede.Frau
Anrede.Frau
Frau
Der statische Import funktioniert nicht nur bei Enums, sondern auch bei statischen Bestandteilen anderer Klassen, die allerdings public sein mssen.
Wir erinnern uns, dass die Werte eines Enums implizit public static final sind.
Hier nun ein Beispiel der statischen Methode tan() der Klasse java.lang.Math
und wie bisher darauf zugegriffen wurde:
import java.lang.Math;
public class StatischerImport {
public static void main(String[ ] args){
System.out.println(Math.tan(60));
}
}
Die Einfhrung des statischen Imports vereinfacht den Zugriff auf die statische tan()-Methode:
import static java.lang.Math.*;
14.5
Enums
615
Der Ausdruck import static java.lang.Math.*; kann auch durch import static
java.lang.Math.tan; ersetzt werden.
Welches Ergebnis erhlt man, wenn man folgendes Programm kompiliert und
startet?
public enum Ampel {
rot {public String toString(){
return Stehenbleiben!;}
},
orange {public String toString(){
return Warten!;}
},
grn {public String toString(){
return Loslaufen!;}
};
public static void main(String[ ] args){
for(Ampel a: Ampel.values()){
System.out.println(a);
}
}
}
Welches Ergebnis erhlt man, wenn man folgendes Programm kompiliert und
startet?
public enum Ampel {
rot {public String umschalten(){
return Stehenbleiben!;}
},
orange {public String umschalten(){
return Warten!;}
616
14
},
grn {public String umschalten(){
return Loslaufen!;}
},
aus;
public static void main(String[ ] args){
for(Ampel a: Ampel.values()){
System.out.println(a);
}
}
public String umschalten(){
return Ampel ist kaputt! ;
}
}
Welches Ergebnis erhlt man, wenn man folgendes Programm kompiliert und
startet?
public enum Ampel {
rot {public String umschalten(){
return Stehenbleiben!;}
},
orange {public String umschalten(){
return Warten!;}
},
grn {public String umschalten(){
return Loslaufen!;}
},
aus;
public static void main(String[ ] args){
for(Ampel a: Ampel.values()){
System.out.println(a.umschalten());
}
}
public String umschalten(){
return Ampel ist kaputt! ;
}
}
14.5
Enums
617
Welches Ergebnis erhlt man, wenn man folgendes Programm kompiliert und
startet?
public enum Ampel {
rot {public String umschalten(){
return Stehenbleiben!;}
},
orange {public String umschalten(){
return Warten!;}
},
grn {public String umschalten(){
return Loslaufen!;}
},
aus
public static void main(String[ ] args){
for(Ampel a: Ampel.values()){
System.out.println(a.umschalten());
}
}
public String umschalten(){
return Ampel ist kaputt! ;
}}
Welches Ergebnis erhlt man, wenn man folgendes Programm kompiliert und
startet?
import java.util.EnumSet;
public enum Ampel {
rot , orange , grn , aus;
public static void main(String[ ] args){
618
14
Welches Ergebnis erhlt man, wenn man folgendes Programm kompiliert und
startet?
public enum Ampel {
rot , orange , grn , aus;
public static void main(String[ ] args){
Ampel rot = Ampel.rot;
System.out.println(rot);
}
}
Welches Ergebnis erhlt man, wenn man folgendes Programm kompiliert und
startet?
public enum Monate {
Mrz(31), April(30), Mai(31);
private String tage;
Monate(String tage){
this.tage = tage;
}
public String getTage(){
return tage;
}
public void waehlen(){
switch (this){
case Mrz: System.out.println(Frhling); break;
case April: System.out.println(Aprilwetter); break;
case Mai: System.out.println(Sonnenschein);
}
14.5
Enums
619
}
public static void main(String[ ] args){
Monate m = Monate.Mrz;
m.waehlen();
}
}
Welches Ergebnis erhlt man, wenn man folgendes Programm kompiliert und
startet?
public enum Monate {
Mrz(31), April(30), Mai(31);
private String tage;
Monate(String tage){
this.tage = tage;
}
public String getTage(){
return tage;
}
public void waehlen(){
switch (this){
case Monate.Mrz: System.out.println(Frhling); break;
case Monate.April: System.out.println(Aprilwetter);
break;
case Monate.Mai: System.out.println(Sonnenschein);
}
}
public static void main(String[ ] args){
Monate m = Monate.Mrz;
m.waehlen();
}
}
620
14
(9) Frage
Welches Ergebnis erhlt man, wenn man folgendes Programm kompiliert und
startet?
public enum Monate {
Mrz(31), April(30), Mai(31);
private String tage;
Monate(String tage){
this.tage = tage;
}
public String getTage(){
return tage;
}
public static void main(String[ ] args){
Monate m = Monate.Mrz;
switch (m){
case Mrz: System.out.println(Frhling); break;
case April: System.out.println(Aprilwetter); break;
case Mai: System.out.println(Sonnenschein);
}
}
}
Welches Ergebnis erhlt man, wenn man folgendes Programm kompiliert und
startet?
public enum Monate {
Mrz(31), April(30), Mai(31);
private String tage;
Monate(String tage){
this.tage = tage;
}
public String getTage(){
return tage;
}
public static void main(String[ ] args){
for(Monate m: Monate.values()){
System.out.println(m.getTage());
14.5
Enums
621
}}
}
Welches Ergebnis erhlt man, wenn man folgendes Programm kompiliert und
startet?
public enum Monate {
Mrz(31), April(30), Mai(31);
private String tage;
Monate(String tage){
this.tage = tage;
}
public String getTage(){
return tage;
}
public static void main(String[ ] args){
for(Monate m: Monate.values()){
System.out.println(m);
}}}
Welches Ergebnis erhlt man, wenn man folgendes Programm kompiliert und
startet?
public enum Monate {
Mrz, April, Mai;
public static void main(String[ ] args){
Monate m = Monate.valueOf(April);
System.out.println(m == Monate.April);
System.out.println(m.equals(Monate.April));
}
}
a) true true
622
14
b) true false
c) false true
d) Kompilierfehler
Lsungen
(1) Frage
Durch die berschriebene Methode toString() wird der Inhalt des Enumerationswertes gendert.
(2) Frage
(3) Frage
Es wird zu jedem Enumerationswert die Methode umschalten() ausgefhrt, und es kommt zur Ausgabe von Stehenbleiben! Warten! Loslaufen! Ampel ist kaputt!
(4) Frage
Ein versteckter Kompilierfehler, aber man sollte immer auch auf die
Syntax achten: Nach dem letzten Enumerationswert, sprich nach aus,
fehlt das Semikolon.
(5) Frage
(6) Frage
(7) Frage
Seit dem Tiger-Release darf der Ausdruck in der Klammer der switchStruktur auch ein Enum sein. So wird das Wort Frhling ausgegeben.
(8) Frage
Nach dem Wort case in der switch-Struktur darf nicht Monate.Mrz statt
Mrz stehen, da dies zu einem Kompilierfehler fhrt.
623
(9) Frage
(10) Frage
(11) Frage
(12) Frage
Die Methode valueOf() der Klasse Enum gibt den konstanten Enumwert
zurck und wird dieser mit dem Enumwert Monate.April mit dem
Vergleichsoperator und equals() verglichen, erhalten Sie in beiden Fllen true.
624
14
625
Es gibt so genannte regulre Ausdrcke, die es Ihnen erleichtern sollen, Zeichen oder Zeichenketten zu suchen. Bleiben wir bei oben stehendem Beispiel: Wir stellen uns nun vor, die einzelnen Daten wren nicht durch ein &
getrennt, sondern durch ein Leerzeichen, dann wre ein regulrer Ausdruck,
der Leerzeichen aufsprt, sehr hilfreich. Der regulre Ausdruck, der dies tut,
ist folgender: \s. Bitte beachten Sie, dass in dem String d= \\s; zweimal der
Backslash steht. Dies ist kein Tippfehler, vielmehr Absicht, da der Compiler
anderenfalls den regulren Ausdruck nicht als solchen erkennt und es zu einem Kompilierfehler kommen wrde. Wie Sie sehen knnen, ist es in diesem
Fall nicht sinnvoll, diesen regulren Ausdruck zu nehmen: Er spaltet nicht nur
die Adresse in Einzelteile auf, sondern er trennt zustzlich auch die Hausnummer von der Strae.
import java.util.Scanner;
public class StringScanner {
public static void main(String[ ] args) {
String s = Michael Bauer Sonnenweg 2 10000 Berlin;
String d = \\s;
Scanner scanner = new Scanner(s);
scanner.useDelimiter(d);
while (scanner.hasNext()){
System.out.println(scanner.next());
}
}
}
Nehmen wir an, die einzelnen Adressdaten wren durch xx von einander
getrennt, dann knnte man die Zeichenkette mit x+ zerlegen. Der regulre
Ausdruck + nach einem x sucht nach einer Zeichenkette, in der ein x min-
626
14
destens einmal vorkommt. Sie knnten an dieser Stelle auch den regulren
Ausdruck x{2} verwenden, der nach genau zwei x hintereinander sucht. Beachten Sie, dass x+ nach mindestens einem x sucht, somit knnten es auch
2 und mehr sein. Im Unterschied hierzu durchkmmt x{2} den String nach genau zwei x, die hintereinander vorkommen mssen.
import java.util.Scanner;
public class StringScanner {
public static void main(String[ ] args) {
String s = MichaelxxBauerxxSonnenweg 2xx10000xxBerlin;
String d = x+;
Scanner scanner = new Scanner(s);
scanner.useDelimiter(d);
while (scanner.hasNext()){
System.out.println(scanner.next());
}
}
}
Was passiert, wenn Sie statt x+, x* schreiben? Das Ergebnis wird in einzelne
Zeichen zerlegt und nicht in einzelne Zeichenketten.
import java.util.Scanner;
public class StringScanner {
public static void main(String[ ] args) {
String s = MichaelxxBauerxxSonnenweg 2xx10000xxBerlin;
String d = x*;
Scanner scanner = new Scanner(s);
scanner.useDelimiter(d);
while (scanner.hasNext()){
System.out.println(scanner.next());
}
}
}
627
h
a
e
l
B
a
u
Kann man auch eine bestimmte Abfolge von Zeichen als Delimiter einsetzen? Ja! So ist es mglich, z. B. nach zwei aufeinanderfolgenden Ziffern und
einem anschlieenden Leerzeichen mit folgendem regulrem Ausdruck suchen: String d = \\d\\d\\s;.
import java.util.Scanner;
public class StringScanner {
public static void main(String[ ] args) {
String s = 11 elf 12 zwlf 13 dreizehn;
String d = \\d\\d\\s;
Scanner scanner = new Scanner(s);
scanner.useDelimiter(d);
while (scanner.hasNext()){
System.out.println(scanner.next());
}
}
}
Lassen Sie uns mit der Methode findInLine() fortfahren: Sie durchsucht einen
String nach einer bestimmten Zeichenfolge. So findet in unserem Beispiel
der regulre Ausdruck (\\w+) 2 eine Zeichenkette, die aus Buchstaben oder
Zahlen besteht, und von einem Leerzeichen und der Zahl 2 gefolgt wird: das
Wort Sonnenweg. Und (\\d+) Berlin findet mehrere Ziffern, die einem Leerzeichen und dem Wort Berlin vorausgehen: die Zahl 10000.
import java.util.Scanner;
import java.util.regex.MatchResult;
public class StringScannerFindInLine {
public static void main(String[ ] args) {
String s = Michael Bauer Sonnenweg 2 10000 Berlin;
Scanner scanner = new Scanner(s);
//findInLine() findet eine bestimmte Zeichenfolge
628
14
Hier eine zusammenfassende Aufstellung aller fr die Zertifizierung wichtigen regulren Ausdrcke:
Regulrer Ausdruck
Beschreibung
\s
\d
\w
.
*
+
?
[a-e]
(ef)
In Ergnzung hierzu mchte ich Sie noch auf den regulren Ausdruck {?i}
aufmerksam machen, der dafr sorgt, dass Gro- und Kleinschreibung einer
Zeichenkette ignoriert wird. Somit wird beispielsweise eine Zeichenkette ich
und ICH gleichermaen gefunden.
629
wird nach einer Zeichenreihenfolge von Buchstaben oder Ziffern mit einem
nachfolgenden Leerzeichen und der Ziffer 1 gesucht. Die Methode compile()
der Klasse Pattern erstellt daraus ein Muster, das als Parameter der Methode
matcher() bergeben wird und ein Objekt der Klasse Matcher zurckgibt. Mit
diesem Muster sucht die Methode find() der Klasse Matcher in einem String
nach einer Entsprechung, die mit Hilfe der Methode group() auf dem Bildschirm ausgegeben wird.
import java.util.regex.Matcher;
import java.util.regex.Pattern;
public class PattMatch {
public static void main(String[ ] args) {
//compile() erstellt ein Muster
Pattern pa = Pattern.compile((\\w+) 1);
//Muster wird der Methode matcher() bergeben
Matcher ma = pa.matcher(zwei 1 drei 1 vier);
//find() findet die Ergebnisse
while(ma.find()){
//group() gibt jedes einzelne Ergebnis aus
System.out.println(ma.group());
}
}
}
630
14
631
Welches Ergebnis erhlt man, wenn man folgendes Programm kompiliert und
startet?
import java.util.regex.Matcher;
import java.util.regex.Pattern;
public class PattMatch {
public static void main(String[ ] args) {
Pattern pa = Pattern.compile((\\w+)@);
Matcher ma = pa.matcher(mein@dein.de);
System.out.println(ma.replaceAll(hallo));
}}
a) hallodein.de
b) meinhallodein.de
c) mein@dein.de
d) Keine dieser Mglichkeiten.
632
14
(2) Frage
Welches Ergebnis erhlt man, wenn man folgendes Programm kompiliert und
startet?
import java.util.regex.Matcher;
import java.util.regex.Pattern;
public class PattMatch {
public static void main(String[ ] args) {
Pattern pa = Pattern.compile((\\w+)@);
Matcher ma = pa.matcher(mein@dein.de);
while (ma.find()){
System.out.println(ma.group());
}
}
}
a) @
b) mein@
c) @dein.de
d) Keine dieser Mglichkeiten.
(3) Frage
Welches Ergebnis erhlt man, wenn man folgendes Programm kompiliert und
startet?
import java.util.regex.Matcher;
import java.util.regex.Pattern;
public class PattMatch {
public static void main(String[ ] args) {
Pattern pa = Pattern.compile((\\w+)@);
Matcher ma = pa.matcher(mein@dein.de);
boolean bo = ma.matches();
System.out.println(bo);
}
}
a) mein@
b) @
c) true
d) false
e) Keine dieser Mglichkeiten.
633
(4) Frage
Welches Ergebnis erhlt man, wenn man folgendes Programm kompiliert und
startet?
import java.util.regex.Matcher;
import java.util.regex.Pattern;
public class PattMatch {
public static void main(String[ ] args) {
Pattern pa = Pattern.compile(@);
String[ ] s = pa.split(mein@dein.de);
for(String st: s){
System.out.println(st);
}
}
}
a) mein dein.de
b) mein@dein.de
c) mein
d) dein.de
(5) Frage
Welches Ergebnis erhlt man, wenn man folgendes Programm kompiliert und
startet?
public class StringSplit {
public static void main(String[ ] args) {
String s = hallo22neu33mein;
String d = \\d+;
String[ ] st = s.split(d);
for (String i:st){
System.out.println(i);
}
}
}
634
14
(6) Frage
Welches Ergebnis erhlt man, wenn man folgendes Programm kompiliert und
startet?
public class StringSplit {
public static void main(String[ ] args) {
String s = hallo22neu33mein;
String d = \\d*;
String[ ] st = s.split(d);
for (String i:st){
System.out.println(i);
}}}
Welches Ergebnis erhlt man, wenn man folgendes Programm kompiliert und
startet?
import java.util.Scanner;
public class StringScanner {
public static void main(String[ ] args) {
String s = 11 elf 12 zwlf;
String d = \\s;
Scanner scanner = new Scanner(s);
scanner.useDelimiter(d);
while (scanner.hasNext()){
System.out.println(scanner.next());
}
}
}
a) 11 elf 12 zwlf
b) elf zwlf
c) 11 12
635
(8) Frage
Welches Ergebnis erhlt man, wenn man folgendes Programm kompiliert und
startet?
import java.util.Scanner;
public class StringScanner {
public static void main(String[ ] args) {
String s = 11elf12zwlf;
String d = \\d+;
Scanner scanner = new Scanner(s);
scanner.useDelimiter(d);
while (scanner.hasNext()){
System.out.println(scanner.next());
}
}
}
a) 11 elf 12 zwlf
b) elf zwlf
c) 11 12
(9) Frage
Welches Ergebnis erhlt man, wenn man folgendes Programm kompiliert und
startet?
import java.util.Scanner;
import java.util.regex.MatchResult;
public class StringScannerFindInLine {
public static void main(String[ ] args) {
String s = Michael Bauer Sonnenweg 2 10000 Berlin;
Scanner scanner = new Scanner(s);
scanner.findInLine((\\w+) Bauer);
MatchResult ms = scanner.match();
for(int i = 1; i<=ms.groupCount();i++){
System.out.println(ms.group(i));
}
}}
a) Michael Bauer
b) Michael
c) Bauer
d) Michael Bauer Sonnenweg 2 10000 Berlin
636
14
(10) Frage
Welches Ergebnis erhlt man, wenn man folgendes Programm kompiliert und
startet?
import java.util.Scanner;
import java.util.regex.MatchResult;
public class StringScannerFindInLine {
public static void main(String[ ] args) {
String s = Michael Bauer Sonnenweg 2 10000 Berlin;
Scanner scanner = new Scanner(s);
scanner.findInLine((\\w+) 2);
MatchResult ms = scanner.match();
for(int i = 1; i<=ms.groupCount();i++){
System.out.println(ms.group(i));
}
}
}
a) Sonnenweg
b) 10000
c) Sonnenweg 2
Lsungen
(1) Frage
(2) Frage
(3) Frage
637
Ausgabe von false. Vergleichen Sie hierzu auch die Lsung von Frage
2.
(4) Frage
Die Methode split() der Klasse String sucht nach dem regulren Ausdruck und teilt die Zeichenkette mit Hilfe dieses regulren Ausdruck in
mehrere Teile.
(5) Frage
Der regulre Ausdruck \\d+ sucht nach einer oder mehreren Ziffern.
(6) Frage
Der regulre Ausdruck \\d* findet null oder mehrere Ziffern, das Ergebnis wird in einzelne Zeichen zerlegt und nicht in einzelne Zeichenketten.
(7) Frage
(8) Frage
Mit dem regulren Ausdruck \\d+ wird nach einer oder mehreren Ziffern
gesucht und das Ergebnis wird mit Hilfe der useDelimiter()-Methode aufgesplittet.
(9) Frage
Die Methode findInLine() findet den regulren Ausdruck, der von dem
Wort Bauer gefolgt wird, und gibt das Wort, das dem regulren Ausdruck entspricht, zurck. In unserem Fall ist dies das Wort Michael.
(10) Frage
638
14
aus dem Begriff Locale + . + dem englischen Namen des Landes. Hier eine
Auswahl:
Land
Locale
Frankreich
Deutschland
USA
Grobritannien
Italien
Japan
Locale.FRANCE
Locale.GERMANY
Locale.US
Locale.UK
Locale.ITALY
Locale.JAPAN
Es gibt leider keine Mglichkeit, diese auf der Konsole auszugeben, da die
Methode getDisplayCountry() zwar dafr vorgesehen ist, aber der Fehler gemacht wurde, auch die Namen der Lnder zu bersetzen. Dies ist an dieser
Stelle nicht sinnvoll, da fr die Locale der englische Name des entsprechenden Landes notwendig ist. Hier einige der wichtigsten Methoden der Klasse
Locale:
import java.util.Locale;
public class Laenderkennzahlen {
public static void main(String[ ] args) {
//Abrufen aller zur Verfgung stehenden Locale-Konstanten
for (Locale l: Locale.getAvailableLocales()){
//Abrufen der Lnder, Lnderabkrzungen und der entsprechenden Sprache
System.out.println(l.getDisplayCountry() + +
l.getCountry()+ + + l.getLanguage());
}
}
}
Des Weiteren knnen Sie mit getDefault() die jeweilige Lnderkennung feststellen und mit setDefault() knnen Sie sie verndern.
639
Sie knnen aber im Falle von USA auf die bereits existierende Locale zugreifen und wie folgt ein neues Objekt erstellen: Locale l = Locale.US;
640
14
Wollen Sie jedoch tatschlich eine Integer-Zahl in amerikanischem Zahlenformat formatieren, brauchen Sie die berladene format()-Methode, die es
Ihnen ermglicht, Zahlen mit einer Locale lnderspezifisch anzupassen.
import java.util.Locale;
public class Formatieren {
public static void main(String[ ] args) {
Integer i = new Integer(100000000);
String st = String.format(
So wird i formatiert mit Locale.GERMANY: %,d, i);
String st1 = String.format(Locale.US,
So wird i formatiert mit Locale.US: %,d, i);
System.out.println(st);
System.out.println(st1);
}
}
100.000.000
100,000,000
Zustzliche Probleme gibt es auch beim Formatieren von Fliekommazahlen: Der Konstruktor des Wrappers Double erwartet eine Nachkommazahl im
amerikanischen Zahlenformat, wohingegen die format()-Methode eine Zahl
im deutschen Zahlenformat wiedergibt. Wollen Sie, dass eine Zahl im amerikanischen Zahlenformat formatiert wird, mssen Sie dies separat festlegen.
Sie mssen in diesem Fall die berladene format()-Methode nehmen, die Sie
zustzlich die Locale festlegen lsst.
import java.util.Locale;
public class Formatieren {
public static void main(String[ ] args) {
Double d = new Double(3400.667);
String str = String.format(
So wird d formatiert mit Locale.GERMANY: %.2f, d);
String str1 = String.format(Locale.US,
So wird d formatiert mit Locale.US: %.2f, d);
System.out.println(str);
System.out.println(str1);
}
}
3400,67
3400.67
641
Wie Sie in oben stehenden Beispiel sehen, knnen Sie mit %.2f DoubleZahlen formatieren, wobei %.2f zwei Nachkommastellen festlegt und die
Nachkommastellen aufgerundet werden. Der Formatierungs-Parameter enthlt einen Punkt und kein Komma, da er sich am amerikanischen Zahlenformat orientiert.
Jetzt kommt die nchste Frage: Kann man mit Formatierungs-Parametern
auch Text formatieren? Ja, mit %s. Hierbei wird ein Objekt mit der toString()-Methode in ein String-Objekt umgewandelt. Wollen Sie als Ergebnis
ein Wort haben, das nur aus Grobuchstaben besteht, mssen Sie %S nehmen.
public class FormatierenString {
public static void main(String[ ] args) {
String st = String.format(
Es wird alles in Kleinbuchstaben formatiert: %s,ich);
String st1 = String.format(
Es wird alles in Grobuchstaben formatiert: %S,ich);
System.out.println(st);
System.out.println(st1);
}
}
Beschreibung
%b
%c
%d
642
14
Format-Spezifizierer
Beschreibung
%f
%s
Wie knnen Sie nun Zahlen mit der Klasse Formatter lnderspezifisch formatieren, wenn Sie ein StringBuilder- oder StringBuffer-Objekt haben? Mit dem
643
Konstruktor der Klasse Formatter, dem Sie ein Objekt der StringBuilderKlasse und die entsprechend Locale bergeben knnen.
import java.util.Formatter;
import java.util.Locale;
public class FormatterKlasseLocale {
public static void main(String[ ] args) {
StringBuilder sb = new StringBuilder();
Formatter fo = new Formatter(sb, Locale.US);
Double d = new Double(564.5667);
fo.format(%.2f, d);
System.out.println(fo);
}
}
644
14
645
Eine andere Zeitzone, z. B. die von Los Angeles, knnen Sie festlegen, indem Sie sie mit den Methoden getTimeZone() und setTimeZone() verndern
und mit getTime() wieder abrufen.
import java.text.DateFormat;
import java.util.Date;
import java.util.TimeZone;
public class DatumAendern {
public static void main(String[ ] args) {
Date d = new Date();
//statischer Zugriff auf Methoden einer abstrakten Klasse
DateFormat form = DateFormat.getDateTimeInstance();
System.out.println(Uhrzeit Deutschland: + form.format(d));
form.setTimeZone(TimeZone.getTimeZone(America/Los_Angeles));
646
14
647
648
14
MANY als Ergebnis fr den String 23,545 die Zahl 23,545 und bei der Locale.US die Zahl 23545. Was fr ein Unterschied! Achten Sie darauf, dass
die Methode parse() immer in einem try/catch-Block stehen muss und der geparste String immer eine Zahl im amerikanischen Zahlenformat, basierend
auf der entsprechenden Locale, wiedergibt.
import java.text.NumberFormat;
import java.text.ParseException;
import java.util.Locale;
public class ZahlenFormat {
public static void main(String[ ] args) {
//statischer Zugriff auf Methoden der Klasse NumberFormat
NumberFormat nf = NumberFormat.getInstance (Locale.GERMANY);
NumberFormat nf1 = NumberFormat.getInstance(Locale.US);
try {
Number n = nf.parse(23,545);
/*ein String wird in eine Zahl vom Typ Number
umgewandelt, basierend auf Locale.GERMANY*/
System.out.println(Locale.Germany mit dem String 23,545:);
System.out.println(parse(): + n);
/*die Zahl vom Typ Number wird im deutschen
Zahlenformat ausgegeben*/
System.out.println(format(): + nf.format(n));
/*n wird in eine int-Zahl umgewandelt und die
Nachkommazahlen werden abgeschnitten*/
System.out.println(intValue(): + n.intValue());
Number n1 = nf1.parse(23,545);
System.out.println(Locale.US mit dem String 23,545:);
System.out.println(parse(): +n1);
System.out.println(format(): + nf1.format(n));
System.out.println(intValue(): + n1.intValue());
} catch (ParseException e) {
e.printStackTrace();
}
}
}
649
intValue(): 23545
14.7.4.2 Whrungsformat
Sie wollen Ihren String mit der entsprechenden Landeswhrung formatieren?
So brauchen Sie die statische getCurrencyInstance()-Methode und die Methode format() der abstrakten Klasse NumberFormat. Wollen Sie allerdings
den umgekehrten Vorgang durchfhren, so bentigen Sie die Methode
parse(), die den formatierten String wieder in eine Zahl umwandelt. Die Methode parse() muss immer in einem try/catch-Block stehen.
import java.text.NumberFormat;
import java.text.ParseException;
import java.util.Locale;
public class Waehrungsformat {
public static void main(String[ ] args) {
//statischer Zugriff auf Methoden einer abstrakten Klasse
NumberFormat nf = NumberFormat.getCurrencyInstance
(Locale.GERMANY);
NumberFormat nf1 = NumberFormat.getCurrencyInstance
(Locale.US);
try {
Number n = nf.parse(23,50 );
String s = nf.format(23.5);
System.out.println(23,50 geparst(Locale.GERMANY): + n);
System.out.println(23.5 formatiert(Locale.GERMANY): + s);
Number n1 = nf1.parse($23.50);
String s1 = nf1.format(23.5);
System.out.println($23.50 geparst(Locale.US): + n1);
System.out.println(23.5 formatiert(Locale.US): + s1);
} catch (ParseException e) {
e.printStackTrace();
}
}
}
650
14
Welches Ergebnis erhlt man, wenn man folgendes Programm kompiliert und
startet?
public class F {
public static void main(String[ ] args) {
Integer i = new Integer(1000);
String st = String.format(%d, i);
System.out.println(st);
}
}
a) 1000
b) 1.000
c) 1,000
(2) Frage
Welches Ergebnis erhlt man, wenn man folgendes Programm kompiliert und
startet?
public class F {
public static void main(String[ ] args) {
Integer i = new Integer(1000);
String st = String.format(%,d, i);
System.out.println(st);
}
}
a) 1000
b) 1.000
c) 1,000
(3) Frage
Welches Ergebnis erhlt man, wenn man folgendes Programm kompiliert und
startet?
import java.util.Locale;
public class F {
public static void main(String[ ] args) {
Integer i = new Integer(1000);
String st = String.format(Locale.US, %,d,i);
System.out.println(st);
651
}
}
a) 1000
b) 1.000
c) 1,000
(4) Frage
Welches Ergebnis erhlt man, wenn man folgendes Programm kompiliert und
startet?
public class F {
public static void main(String[ ] args) {
Double d = new Double(10.789);
String st = String.format(%.2f, d);
System.out.println(st);
}
}
a) 10,79
b) 10.79
c) 10,789
d) 10.789
(5) Frage
Welches Ergebnis erhlt man, wenn man folgendes Programm kompiliert und
startet?
import java.util.Locale;
public class F {
public static void main(String[ ] args) {
Double d = new Double(10.789);
String st = String.format(Locale.US, %.2f, d);
System.out.println(st);
}
}
a) 10,79
b) 10.79
c) 10,789
d) 10.789
652
14
(6) Frage
Welches Ergebnis erhlt man, wenn man folgendes Programm kompiliert und
startet?
import java.util.Formatter;
public class FormKlasse {
public static void main(String[ ] args) {
StringBuffer s = new StringBuffer();
Formatter f = new Formatter(s);
System.out.println(f.format(%2$s, %1$s, Hallo, Tschss) );
}
}
a) Hallo Tschss
b) HALLO TSCHSS
c) Tschss Hallo
d) TSCHSS HALLO
(7) Frage
Welches Ergebnis erhlt man, wenn man folgendes Programm kompiliert und
startet?
import java.util.Formatter;
public class FormKlasse {
public static void main(String[ ] args) {
StringBuffer s = new StringBuffer();
Formatter f = new Formatter(s);
System.out.println(f.format(%s, %s, Hallo, Tschss) );
}
}
a) Hallo Tschss
b) Tschss Hallo
c) Kompilierfehler
(8) Frage
Welches Ergebnis erhlt man, wenn man folgendes Programm kompiliert und
startet?
import java.util.Locale;
public class F {
public static void main(String[ ] args) {
653
a) 3.567
b) 3,567
c) 3.57
d) 3,57
(9) Frage
Welches Ergebnis erhlt man, wenn man folgendes Programm kompiliert und
startet?
import java.util.Locale;
public class F {
public static void main(String[ ] args) {
Integer i = new Integer(3097);
System.out.format(%,d, i);
}
}
a) 3097
b) 3.097
c) 3,097
(10) Frage
Welches Ergebnis erhlt man, wenn man folgendes Programm kompiliert und
startet?
import java.util.Formatter;
import java.util.Locale;
public class FormatterKlasseLocale {
public static void main(String[ ] args) {
StringBuilder sb = new StringBuilder();
Formatter fo = new Formatter(sb, Locale.US);
Double d = new Double(4.754);
fo.format( %.2f, d);
System.out.println(fo);
}
}
a) 4.75
654
14
b) 4,75
c) 4.754
d) 4,754
(11) Frage
Welches Ergebnis erhlt man, wenn man folgendes Programm kompiliert und
startet?
import java.util.Formatter;
public class FormKlasse {
public static void main(String[ ] args) {
StringBuffer s = new StringBuffer();
Formatter f = new Formatter(s);
System.out.println(f.format(%2$S, %1$S, Hallo, Tschss) );
}
}
a) Hallo Tschss
b) HALLO TSCHSS
c) Tschss Hallo
d) TSCHSS HALLO
(12) Frage
Welches Ergebnis erhlt man, wenn man folgendes Programm kompiliert und
startet?
import java.text.NumberFormat;
import java.text.ParseException;
import java.util.Locale;
public class ZahlForm {
public static void main(String[ ] args) {
NumberFormat nf = NumberFormat.getInstance(Locale.GERMANY);
try {
Number n = nf.parse(6,798);
System.out.println(nf.format(n));
System.out.println(n.intValue());
} catch (ParseException e) {
e.printStackTrace();
}
}
}
a) 6,798 6798
655
b) 6,798 6
c) 6.798 6798
d) 6.798 6
(13) Frage
Welches Ergebnis erhlt man, wenn man folgendes Programm kompiliert und
startet?
import java.text.NumberFormat;
import java.text.ParseException;
import java.util.Locale;
public class ZahlForm {
public static void main(String[ ] args) {
NumberFormat nf = NumberFormat.getInstance(Locale.GERMANY);
try {
Number n = nf.parse(6,798);
System.out.println(n);
} catch (ParseException e) {
e.printStackTrace();
}
}
}
a) 6,798
b) 6.789
c) 6
(14) Frage
Welches Ergebnis erhlt man, wenn man folgendes Programm kompiliert und
startet?
import java.text.NumberFormat;
import java.text.ParseException;
import java.util.Locale;
public class Wformat {
public static void main(String[ ] args) {
NumberFormat n = NumberFormat.getCurrencyInstance(Locale.US);
try {
Number n1 = n.parse($2.60);
String s1 = n.format(1.5);
System.out.println(n1);
System.out.println(s1);
} catch (ParseException e) {
e.printStackTrace();
656
14
}
}
}
a) 2.60 1.5
b) $2.60 $1.50
c) $2.60 1.50
d) 2.6 $1.50
(15) Frage
Welche der unten stehenden Konstanten gibt alle zur Verfgung stehenden
Locale-Konstanten wieder?
a) getDisplayCountry()
b) getCountry()
c) getLanguage()
d) getAvailableLocales()
e) getInstance()
f) getCurrencyInstance()
(16) Frage
Welches Ergebnis erhlt man, wenn man folgendes Programm kompiliert und
startet?
public class FormBoolean {
public static void main(String[ ] args) {
Boolean bool = new Boolean(false);
String st = String.format(%b, bool);
System.out.println(st);
}
}
a) true
b) false
c) Kompilierfehler
(17) Frage
Mit welcher der unten stehenden Methoden kann die Zeitzone verndert werden?
657
a) getDateInstance()
b) getInstance()
c) getDateTimeInstance()
d) setTimeZone()
e) getTime()
f) getTimeInstance()
g) Keine dieser Mglichkeiten.
(18) Frage
Welches Ergebnis erhlt man, wenn man folgendes Programm kompiliert und
startet?
import java.text.DateFormat;
import java.util.Date;
import java.util.Locale;
public class DatumFormat {
public static void main(String[ ] args) {
Date d = new Date();
DateFormat df = DateFormat.getDateInstance
(DateFormat.LONG, Locale.US);
System.out.println(df.format(d));
}
}
a) December 6, 2005
b) 12/6/05
c) Tuesday, December 6, 2005
d) Dec 6, 2005
e) Keine dieser Mglichkeiten.
(19) Frage
Welches Ergebnis erhlt man, wenn man folgendes Programm kompiliert und
startet?
import java.text.DateFormat;
import java.util.Date;
import java.util.Locale;
public class DatumFormat {
public static void main(String[ ] args) {
658
14
a) December 6, 2005
b) 12/6/05
c) Tuesday, December 6, 2005
d) Dec 6, 2005
e) Keine dieser Mglichkeiten.
(20) Frage
Welches Ergebnis erhlt man, wenn man folgendes Programm kompiliert und
startet?
import java.text.DateFormat;
import java.util.Date;
import java.util.TimeZone;
public class Dat {
public static void main(String[ ] args) {
Date d = new Date();
DateFormat df = DateFormat.getDateInstance();
System.out.println(df.format(d));
}
}
a) 06.12.2005
b) 06.12.2005 9:15
c) 9:15:27
d) Keine dieser Mglichkeiten.
(21) Frage
Welches Ergebnis erhlt man, wenn man folgendes Programm kompiliert und
startet?
import java.text.DateFormat;
import java.util.Date;
import java.util.TimeZone;
public class Dat {
public static void main(String[ ] args) {
659
a) 06.12.2005
b) 06.12.2005 9:15
c) 9:15:27
d) Keine dieser Mglichkeiten.
Lsungen
(1) Frage
(2) Frage
Der Format-Spezifizierer %,d formatiert Integer-Zahlen mit Tausenderpunkten, obwohl dort ein Komma steht, da der Formatspezifizierer
nach dem amerikanischen Zahlenformat verlangt, aber ein deutsches
ausgeben wird.
(3)
Frage
(4) Frage
(5) Frage
660
14
(6) Frage
Da es in den Klassen StringBuilder und StringBuffer keine Methode format() gibt, mssen Sie das entsprechende Objekt, wenn es formatiert
werden soll, einem Konstruktor der Klasse Formattter bergeben. Mit
%s werden Objekte mit der toString()-Methode in ein String-Objekt
umgewandelt, und mit 2$ und 1$ wird die Reihenfolge der Ausgabe
verndert, so erhalten Sie folgende Ausgabe auf der Konsole: Tschss
Hallo.
(7) Frage
Da es in den Klassen StringBuilder und StringBuffer keine Methode format() gibt, mssen Sie das entsprechende Objekt, wenn es formatiert
werden soll, einem Konstruktor der Klasse Formattter bergeben.
(8) Frage
(9) Frage
(10) Frage
Da es in den Klassen StringBuilder und StringBuffer keine Methode format() gibt, mssen Sie das entsprechende Objekt, wenn es im amerikanischen Zahlenformat formatiert werden soll, einem Konstruktor der
Klasse Formattter bergeben, dem Sie zustzlich die Locale.US als
Parameter bergeben knnen.
(11) Frage
(12) Frage
Die Methode parse() der Klasse Number wandelt einen String in eine
Zahl vom Typ Number um und muss immer in einem try-catch-Block
stehen. Die geparste Zahl wird im amerikanischen Zahlenformat, basierend auf der Locale.GERMANY, wiedergegeben. Diese Zahl wird mit
der Methode format(), ebenfalls basierend auf der Locale.GERMANY,
der Klasse FormatNumber formatiert und mit Hilfe der Methode intValue() in eine int-Zahl umgewandelt, wobei die Nachkommastellen abgeschnitten werden. Da der getInstance()-Methode die Locale.GERMANY
661
bergeben wird, wird das Komma als Trennungszeichen fr die Kommazahl angesehen und nicht als Tausendertrennzeichen.
(13) Frage
Die Methode parse() gibt immer eine Zahl im amerikanischen Zahlenformat wieder. Das Ergebnis hngt allerdings von der jeweiligen Locale
ab, so wird die Zahl 6,798 als im deutschen Zahlenformat interpretierte
Zahl formatiert, und es wird das geparste Ergebnis 6.789 ausgegeben.
(14) Frage
Die Methoden getCurrenyInstance() und parse(), basierend auf der Locale.US, ermglichen es Ihnen, die mit dem Whrungsformat versehenen String, in eine Zahl vom Typ Number zu berfhren. Die Methode
format() und getCurrencyInstance(), ebenfalls basierend auf der Locale.US, formatieren die Zahl als Whrung. Bei der Locale.US wird der
Punkt als Trennzeichen von der Nachkommazahl interpretiert. Eine
Zahl, die im Whrungsformat formatiert wird, hat immer 2 Nachkommstellen.
(15) Frage
(16) Frage
(17) Frage
(18) Frage
(19) Frage
(20) Frage
662
14
(21) Frage
14.8.2 Zeichenstrme
Zeichenstrme ermglichen es Ihnen, Text in lesbarer Form in einem Dokument zu speichern. Zeichenstrme versenden Folgen von 16-Bit-Daten, so
ist es mglich die Daten characterweise (zeichenweise) zu bertragen (Kapitel 2.5.3 Literale ab Seite 39). Ein char-Literal (ein Zeichen) entspricht einem Unicode-Zeichen. Der Begriff Character-Streams wird in der Fachliteratur hufig als Synonym fr Zeichenstrme verwendet. Die entsprechenden
Klassen des Packages java.io sind die abstrakten Klassen Reader und Writer.
663
14.8.3 Bytestrme
Betrachten wir nun die Bytestrme: Sie ermglichen es Ihnen zwar auch,
Text in einer Datei zu speichern, der Text wird aber in Bytecode umgewandelt, so ist der Inhalt dieser Datei fr Sie nicht mehr lesbar. Bytestrme knnen nur 8-Bit Bytes-Datenpakete befrdern. Die Daten werden byteweise
durch den Strom weitergeleitet. Die abstrakten Klassen InputStream und
OutputStream stellen die erforderlichen Methoden zur Verfgung.
Funktion
664
14
665
Bitte beachten Sie, dass die Klasse BufferedWriter keinen Konstruktor besitzt, dem man ein File-Objekt als Parameter bergeben kann. In folgender
Abbildung sehen Sie das Ergebnis des oben stehenden Codes, die Daten
wurden in die Datei Character.txt bertragen.
666
14
Unten stehend lesen wir das soeben erstellte Dokument wieder aus.
import java.io.BufferedReader;
import java.io.File;
import java.io.FileReader;
import java.io.IOException;
public class LesenPrintWriter {
public static void main(String[ ] args) {
File f = new File(PrintWriter.txt);
try {
FileReader fw = new FileReader(f);
BufferedReader bw = new BufferedReader(fw);
667
Als Zweites wird ein FileOutputStream-Objekt instanziiert, das eine Datei erstellt, Dieses Objekt wird einem ObjectOutputStream-Objekt als Parameter
668
14
bergeben, das dann die Objekte in Bytes umwandelt und in diesem Dokument speichert. Wollen Sie mehrere Objekte ein- und wieder ausgeben, geschieht dies unter Zuhilfenahme eines int-Wertes, den Sie mit der Methode
writeInt(int i) erst setzen mssen. Dies ist eine relativ komplizierte Methode,
da Sie jedes Mal zhlen mssen, wieviele Objekte es gibt. Die Klasse ObjectOutputStream besitzt aber leider keine Methode, die es Ihnen ermglicht,
problemlos mehrere Objekte aus Ihrem Dokument auszulesen. Sollten Sie
mit diesem Trick nicht zufrieden sein, lernen Sie weiter unten eine andere
Vorgehensweise kennen.
import java.io.File;
import java.io.FileOutputStream;
import java.io.IOException;
import java.io.ObjectOutputStream;
public class SchreibenObjekte {
public static void main(String[ ] args) {
//Gibt Pfad zu Dokument an
File f = new File(Objekte.txt);
//Erstellen von 2 Objekten
Auto a = new Auto();
a.setFarbe(rot);
Auto b = new Auto();
b.setFarbe(rosa);
try {
//erstellt oder berschreibt Datei mit Namen Objekte.txt
FileOutputStream fw = new FileOutputStream(f);
//wandelt Objekte und primitive Werte in Bytes um
ObjectOutputStream oos = new ObjectOutputStream(fw);
//schreibt einen primitiven int-Wert in Datei
oos.writeInt(2);
//schreibt Objekte in die Datei
oos.writeObject(a);
oos.writeObject(b);
oos.close();
//fngt Fehler auf, der beim Schreiben in die Datei auftreten kann
} catch (IOException e) {
e.printStackTrace();
}
}
}
Versuchen Sie allerdings Objekte zu serialisieren, die das Interface Serializable nicht implementieren, wird eine NotSerializableException geworfen (vgl.
Kapitel 8 Exceptions).
Unten stehende Darstellung zeigt Ihnen, in welcher fr den Menschen nicht
lesbaren Form die Objekte gespeichert werden.
669
670
14
Hier die entsprechende Klasse, die die Daten aus der Datei wieder ausliest:
import java.io.File;
import java.io.FileInputStream;
import java.io.IOException;
import java.io.ObjectInputStream;
import java.util.LinkedList;
public class LesenObjekteList {
public static void main(String[ ] args){
File f = new File(ObjekteList.txt);
671
try {
FileInputStream fi = new FileInputStream(f);
ObjectInputStream ois = new ObjectInputStream(fi);
for (Auto a: (LinkedList<Auto>)ois.readObject()){
System.out.println(a.getFarbe());
}
fi.close();
} catch (IOException e) {
e.printStackTrace();
} catch (ClassNotFoundException e) {
e.printStackTrace();
}
}
}
Was passiert, wenn jetzt Objekte der Klasse Auto serialisiert und deserialisiert werden? Es wird nur der entsprechende Standardwert eines Objektes
ausgegeben: null.
import java.io.File;
import java.io.FileInputStream;
import java.io.IOException;
import java.io.ObjectInputStream;
import java.util.LinkedList;
672
14
a) print
b) println
c) write
d) read
e) readObject
f) writeObject
g) Keine dieser Mglichkeiten.
(2) Frage
a) FileReader
b) PrintWriter
c) BufferedReader
d) ObjectOutputStream
e) Serializable
673
674
14
Welches Ergebnis erhlt man, wenn man folgendes Programm kompiliert und
startet?
import java.io.Serializable;
public class Auto implements Serializable {
private String farbe;
public String getFarbe() {
return farbe;
}
public void setFarbe(String farbe) {
this.farbe = farbe;
}
}
import java.io.File;
import java.io.FileOutputStream;
import java.io.IOException;
import java.io.ObjectOutputStream;
public class SchreibObjekt {
public static void main(String[ ] args) {
File f = new File(Objekt.txt);
Auto a = new Auto();
a.setFarbe(blau);
try {
FileOutputStream fw = new FileOutputStream(f);
ObjectOutputStream oos = new ObjectOutputStream(fw);
oos.writeObject(a);
oos.close();
} catch (IOException e) {
e.printStackTrace();
}
}
}
import java.io.File;
import java.io.FileInputStream;
import java.io.IOException;
import java.io.ObjectInputStream;
public class LiesObjekt {
public static void main(String[ ] args) {
File f = new File(Objekt.txt);
try {
FileInputStream fis = new FileInputStream(f);
ObjectInputStream ois = new ObjectInputStream(fis);
Auto auto = (Auto) ois.readObject();
675
System.out.println (auto.getFarbe());
fis.close();
} catch (IOException e) {
e.printStackTrace();
} catch (ClassNotFoundException e) {
e.printStackTrace();
}
}
}
a) blau
b) null
c) Es wird eine Exception geworfen.
d) Kompilierfehler
e) Keine dieser Mglichkeiten.
(4) Frage
Welches Ergebnis erhlt man, wenn man folgendes Programm kompiliert und
startet?
import java.io.Serializable;
public class Auto {
private String farbe;
public String getFarbe() {
return farbe;
}
public void setFarbe(String farbe) {
this.farbe = farbe;
}
}
import java.io.File;
import java.io.FileOutputStream;
import java.io.IOException;
import java.io.ObjectOutputStream;
public class SchreibObjekt {
public static void main(String[ ] args) {
File f = new File(Objekt.txt);
Auto a = new Auto();
a.setFarbe(blau);
try {
FileOutputStream fw = new FileOutputStream(f);
ObjectOutputStream oos = new ObjectOutputStream(fw);
oos.writeObject(a);
676
14
oos.close();
} catch (IOException e) {
e.printStackTrace();
}
}
}
import java.io.File;
import java.io.FileInputStream;
import java.io.IOException;
import java.io.ObjectInputStream;
public class LiesObjekt {
public static void main(String[ ] args) {
File f = new File(Objekt.txt);
try {
FileInputStream fis = new FileInputStream(f);
ObjectInputStream ois = new ObjectInputStream(fis);
Auto auto = (Auto) ois.readObject();
System.out.println(auto.getFarbe());
fis.close();
} catch (IOException e) {
e.printStackTrace();
} catch (ClassNotFoundException e) {
e.printStackTrace();
}
}
}
a) blau
b) null
c) Es wird eine Exception geworfen.
d) Kompilierfehler
e) Keine dieser Mglichkeiten.
(5) Frage
Welches Ergebnis erhlt man, wenn man folgendes Programm kompiliert und
startet?
import java.io.Serializable;
public class Auto implements Serializable {
transient private String farbe;
public String getFarbe() {
return farbe;
a) blau
677
678
14
b) null
c) Es wird eine Exception geworfen.
d) Kompilierfehler
e) Keine dieser Mglichkeiten.
(6) Frage
679
(9) Frage
Vakatseite
b) Die abstrakten Klassen Reader und Writer stellen die erforderlichen Methoden
fr Bytestrme bereit.
c) Die Begriffe Character-Streams und Bytestrme sind Synonyme.
d) Die Klasse File besitzt keine Methode createNewFile().
e) Will man ein Objekt speichern (serialisieren), muss es das Runnable-Interface
implementieren.
f) Keine dieser Mglichkeiten.
(13) Frage
a) print
b) println
c) write
d) writeObject
(15) Frage
a) ObjectOutputStream
b) PrintWriter
c) BufferedReader
d) BufferedWriter
e) OutputStream
681
682
14
(16) Frage
a) print()
b) println()
c) write()
d) writeObject()
Lsungen
(1) Frage
Die Methode writeObject() ist eine Methode der Klasse ObjectOutputStream, die Objekte in eine Datei schreibt.
(2) Frage
Es ist die Klasse ObjectInputStream, folglich ist keine der Lsungen zutreffend.
(3) Frage
Die Farbe des Objektes Auto wird in blau gendert und in einer Textdatei
gespeichert. Die Textdatei wird mit Hilfe der Klasse ObjectInputStream
683
wieder ausgelesen. So erhlt man als Ergebnis wieder die Farbe blau
als Farbe fr das Auto.
(4) Frage
Die Klasse Auto implementiert nicht das Serializable Interface, dies wre aber die Voraussetzung dafr, dass ein Objekt serialisiert, sprich gespeichert, werden kann. Dies bemerkt der Kompiler aber erst zur Laufzeit und es wird eine NotSerializableException geworfen.
(5) Frage
Die Variable der Klasse Auto ist transient, dies hat zur Folge, dass der
Wert der Variablen nicht serialisiert wird, somit erhalten Sie als Ausgabe null.
(6) Frage
(7) Frage
(8) Frage
(9) Frage
(10) Frage
a, c Die Klasse File besitzt Methoden, wie canWrite() und delete(), aber
keine Methode die readObject heit. Die Begriffe Zeichenstrme und
Bytestrme knnen nicht synonym verwendet werden. Es spricht nichts
gegen die Benutzung der Klasse PrintWriter.
684
14
(12) Frage
Die abstrakten Klassen InputStream und OutputStream stellen die entsprechenden Methoden fr Bytestrme und die abstrakten Klassen
Reader und Writer stellen sie fr Zeichenstrme zur Verfgung. Die Begriffe Character-Streams und Bytestrme sind keine Synonyme. Die
Klasse File besitzt eine Methode createNewFile(). Will man ein Objekt
serialisieren, muss es das Serializable Interface implementieren.
(13) Frage
(15) Frage
Das FileReader-Objekt sollte einem Konstruktor der Klasse BufferedReader bergeben werden.
(16) Frage
685
15
Anhang
Welches Ergebnis erhlt man, wenn man folgendes Programm kompiliert und
startet?
public class A1 {
String s1 = ja;
String s2 = ja;
public static void main(String[ ] args){
new A1().ausgabe();
}
void ausgabe(){
s2.toUpperCase();
System.out.println(s1 == s2);
System.out.println(s1.equals(s2));
}
}
a) true true
b) false false
c) true false
d) false true
e) Kompilierfehler
(2) Frage
Welches Ergebnis erhlt man, wenn man folgendes Programm kompiliert und
startet?
public class A2 {
public static void main(String[ ] args){
Runnable r = new Runnable(){
System.out.println(ja);
686
15
Anhang
};
Thread t = new Thread(r);
t.start();
}
}
a) ja
b) Der Thread muss mit der Methode run( ) gestartet werden, deswegen
kommt es zu keiner Ausgabe.
c) Kompilierfehler
(3) Frage
Welches Ergebnis erhlt man, wenn man folgendes Programm kompiliert und
startet?
public class A3 {
public static void main(String args) {
A3 a3 = new A3();
Object object = new Object();
System.out.println(a3 instanceof Object);
System.out.println(object instanceof A3);
}
}
a) true false
b) false true
c) true true
d) false false
e) Kompilierfehler
f) Der Versuch, das Programm auf der Kommandozeile zu starten, wird fehlschlagen.
(4) Frage
15.1
687
e) instanceof
f) while
(5) Frage
Welches Ergebnis erhlt man, wenn man folgendes Programm kompiliert und
startet?
public class A5 {
public static void main(String[ ] args) {
for (int i=1; i<3; i++){
switch(i){
case 1: System.out.println(eins);break;
default: System.out.println(default);break;
case 2: System.out.println(zwei);break;
case 3: System.out.println(drei);break;
}
}
}
}
a) eins zwei
b) default eins zwei
c) eins zwei drei
d) Kompilierfehler
(6) Frage
Welches Ergebnis erhlt man, wenn man folgendes Programm kompiliert und
startet?
public class A6 extends Thread {
public static void main(String[ ] args){
A6 faden = new A6();
faden.start();
A6 faden1 = new A6();
faden1.start();
}
public void run(){
for(int i = 0; i < 300; i+=2){
System.out.println(i);
}
}
}
a) Es werden alle geraden Zahlen zwischen 0 und 300 zweimal hintereinander auf der Konsole ausgegeben.
688
15
Anhang
b) Es werden alle ungeraden Zahlen zwischen 0 und 300 zweimal hintereinander auf der Konsole ausgegeben.
c) Es werden alle geraden Zahlen zwischen 0 und 300 zweimal durcheinander auf der Konsole ausgegeben.
d) Es werden alle ungeraden Zahlen zwischen 0 und 300 zweimal durcheinander auf der Konsole ausgegeben.
(7) Frage
Welches Ergebnis erhlt man, wenn man folgendes Programm kompiliert und
startet?
public class A7 {
public static void main(String[ ] args){
System.out.println(8^3);
}
}
a) 8
b) 9
c) 10
d) 11
e) 12
f) 13
(8) Frage
Zeile 1
Zeile 2
15.1
689
Zeile 3
Zeile 4
Zeile 5
a) Zeile 1
b) Zeile 2
c) Zeile 3
d) Zeile 4
e) Zeile 5
f) Keine dieser Mglichkeiten.
(10) Frage
Welches Ergebnis erhlt man, wenn man folgendes Programm kompiliert und
startet?
public class A10 {
public static void main(String[ ] args){
short s = 6;
s = s + 7;
System.out.println(s);
}
}
a) 6
b) 7
c) 13
d) Kompilierfehler
(11) Frage
690
15
Anhang
Welches Ergebnis erhlt man, wenn man folgendes Programm kompiliert und
startet?
public class A12 {
public static void main(String[ ] args) {
try{
A12 a12 = new A12();
a12.fehler();
}catch(Exception fehler){
System.out.println(Ich fange!);
}
System.out.println(Ende);
}
public void fehler() throw FileNotFoundException{
throw new FileNotFoundException();
}
}
a) Ich fange!
b) Ich fange! Ende
c) Es wird eine Exception geworfen.
d) Kompilierfehler
(13) Frage
Welches Ergebnis erhlt man, wenn man folgendes Programm kompiliert und
startet?
public class A13 {
public static void main(String[ ] args) {
int a = 0xffffffff;
int b = a << 4;
int c = a >>> 5;
System.out.println(Integer.toHexString(b));
System.out.println(Integer.toHexString(c));
}
}
a) fffffff0 7ffffff
15.1
691
b) fffffff0 ffffffff
c) fffffff9 7ffffff
d) fffffff9 8ffffff
(14) Frage
Welches Ergebnis erhlt man, wenn man folgendes Programm kompiliert und
startet?
public class A14 {
void sagen(){
System.out.println(Vater);
}
}
public class A14Kind extends A14{
public static void main(String[ ] args) {
A14Kind kind = new A14Kind();
kind.sagen();
}
void sagen(){
System.out.println(Kind);
}
}
a) Vater Kind
b) Vater
c) Kind
d) Kompilierfehler
e) Es wird eine Exception geworfen.
(15) Frage
Welche der unten stehenden Modifier drfen vor einer Variablen stehen?
a) synchronized
b) native
c) strictfp
d) abstract
e) transient
f) Keine dieser Mglichkeiten.
692
15
Anhang
(16) Frage
Welches Ergebnis erhlt man, wenn man folgendes Programm kompiliert und
startet?
public class A16 {
private String a = outer a;
public class Inner{
private String a = inner a;
Inner(){
System.out.println(a);
};
}
public static void main(String[ ] args) {
A16.Inner inner = new A16().new Inner();
}
}
a) outer a inner a
b) outer a
c) inner a
d) Kompilierfehler
e) Es wird eine Exception geworfen.
(17) Frage
Welches Ergebnis erhlt man, wenn man folgendes Programm kompiliert und
startet?
public class A17 {
public static void main(String[ ] args) {
String[ ][ ][ ] s ={
{{3}, {5}},
{{2}, {6}},
{{4}},
{{1, null}}
};
System.out.println(s[1][1][0]);
}
}
a) 1
b) 2
c) 3
d) 4
15.1
693
e) 5
f) 6
g) null
h) ArrayIndexOutOfBoundsException
(18) Frage
a) Vier Objekte sind nach Beendigung der for-Schleife zur Garbage Collection freigegeben und es ist sicher, dass fr jedes Objekt die Garbage Collection durchgefhrt wird.
b) Fnf Objekte sind nach Beendigung der for-Schleife zur Garbage Collection freigegeben und es ist sicher, dass fr jedes Objekt die Garbage Collection durchgefhrt wird.
c) Vier Objekte sind nach Beendigung der for-Schleife zur Garbage Collection freigegeben und es ist nicht sicher, dass fr jedes Objekt die Garbage
Collection durchgefhrt wird.
d) Fnf Objekte sind nach Beendigung der for-Schleife zur Garbage Collection freigegeben und es ist nicht sicher, dass fr jedes Objekt die Garbage
Collection durchgefhrt wird.
(19) Frage
694
15
Anhang
(20) Frage
Welches Ergebnis erhlt man, wenn man folgendes Programm kompiliert und
startet?
public class A20 {
public static void main(String[ ] args) {
double d = -3.5d;
long e = Math.round(d);
double i = Math.ceil(d);
System.out.println(e+i);
}
}
a) 6
b) 6.0
c) 6
d) 6.0
e) Kompilierfehler
(21) Frage
15.1
695
Welches Ergebnis erhlt man, wenn man folgendes Programm kompiliert und
startet?
public class A25Vater {
A25Vater(String s){
System.out.println(s);
}
}
public class A25Sohn extends A25Vater{
A25Sohn(String s){
System.out.println(s);
}
public static void main(String[ ] args) {
A25Sohn sohn = new A25Sohn(Sohn);
}
}
a) Sohn
b) Sohn Vater
c) Sohn Sohn
696
15
Anhang
d) Kompilierfehler
e) Keine dieser Mglichkeiten.
(26) Frage
Welches Ergebnis erhlt man, wenn man folgendes Programm kompiliert und
startet?
public class A26 {
public static void main(String[ ] args) {
StringBuffer sb = new StringBuffer(ich);
sb.concat(werde angehngt!);
System.out.println(sb);
}
}
Welche der unten stehenden Aussagen trifft auf die Klasse A27 zu, wenn Assertions aktiviert sind ?
public class A27 {
public static void main(String[ ] args) {
A27 a27 = new A27();
a27.ausgabe();
}
private void ausgabe(){
A27 a27 = new A27();
boolean b = a27 instanceof Object;
System.out.println(b);
try{
assert b;
}catch(AssertionError e){
System.out.println(Ich bin kein Object!);
}
}
}
15.1
697
Welches Ergebnis erhlt man, wenn man folgendes Programm kompiliert und
startet?
public class A30 {
public static void main(String[ ] args) {
System.out.println(10 * 20 + 4 % 10);
System.out.println(4 % 2 + 4 * 4);
}
}
a) 50 8
b) 204 8
c) 50 16
d) 204 16
698
15
Anhang
(31) Frage
Welches Ergebnis erhlt man, wenn man folgendes Programm kompiliert und
startet?
public class A31 {
public static void main(String[ ] args) {
int i = 5;
int k = 6;
int l = 7;
int ergebnis = i++ + ++k + ++l;
System.out.println(ergebnis);
}
}
a) 17
b) 18
c) 19
d) 20
e) 21
(32) Frage
Welches Ergebnis erhlt man, wenn man folgendes Programm kompiliert und
startet?
public class A32 {
public static void main(String[ ] args) {
int i = 0;
sprung:
while (i<6){
if (i>2) break sprung;
System.out.println(i);
i++;
}
}
}
a) 1 2
b) 0 1 2
c) 1 2 3 4 5 6
d) 0 1 2 3 4 5 6
e) Kompilierfehler
15.1
699
(33) Frage
Welches Ergebnis erhlt man, wenn man folgendes Programm kompiliert und
startet?
public class A33Sohn extends A33{
}
public class A33Tochter extends A33{
}
public class A33 {
public static void main(String[ ] args) {
A33 a33 = new A33();
A33Tochter tochter = new A33Tochter();
A33Sohn sohn = new A33Sohn();
tochter = (A33Tochter)a33;
}
}
Wieviele Objekte kommen nach Ablauf dieses Codes fr die Garbage Collection in Frage?
public class A34 {
public static void main(String[ ] args) {
String a = new String(a);
String b = new String(b);
String c = new String(c);
c = b;
b = new String(neu);
c = null;
}
}
a) 0
b) 1
c) 2
d) 3
e) 4
700
15
Anhang
(35) Frage
Zeile 1
Zeile 2
Zeile 3
Zeile 4
Zeile 5
a) Zeile 1
b) Zeile 2
c) Zeile 3
d) Zeile 4
e) Zeile 5
f) Keine dieser Mglichkeiten.
(36) Frage
Welche der unten stehenden Aussagen trifft auf folgenden Code zu?
public class A36 {
public static void main(String[ ] args) {
A36 a = new A36();
a.ausgabe(7);
}
public void ausgabe(double d){
System.out.println(d);
assert d < 6: break;
}
}
a) Bei der Ausfhrung tritt kein Fehler auf, weder mit aktivierten noch mit
deaktivierten Assertions.
b) Kompilierfehler
c) Zur Laufzeit wird ein Error geworfen.
d) Sind die Assertions mit java ea A36 aktiviert, kommt es zur Laufzeit zu
einem AssertionError.
15.1
701
(37) Frage
Welches Ergebnis erhlt man, wenn man folgendes Programm kompiliert und
startet?
public class A38 {
public static void main(String[ ] args) {
String s = Monat;
String s1 = Monat;
System.out.println(s == s1);
System.out.println(s.equals(s1));
}
}
a) true true
b) true false
c) false true
d) Kompilierfehler
(39) Frage
702
15
Anhang
(40) Frage
Welche der unten stehenden Aussagen trifft zu, wenn unten stehende Klasse
gestartet wird?
public class A41 {
public static void main(String[ ] args) {
A41 a41 = new A41();
}
private void f(double d){
assert d = 45;
}
}
a) Die Variable d darf nicht den Wert 45 annehmen, wenn die Assertions mit
java ea A41 beim Starten aktiviert sind.
b) Assertions drfen beim Starten nicht aktiviert sein.
c) Es kommt zu einem AssertionError, wenn die Assertions aktiviert sind.
d) Es kommt zu einem Kompilierfehler und zur Laufzeit wird ein Error geworfen.
(42) Frage
Welche Arten der Deklaration und Initialisierung von Arrays fhrt zu einem
Kompilierfehler?
a) int [ ][ ] a = new int [3][ ];
b) int [ ][ ] a = new int [3][3];
c) int [ ] a [ ]= new int [3][ ];
d) int a [ ] [ ] = new int [3][ ];
e) int a [ ] [ ] = new int [3][3];
15.1
703
Welche der unten stehenden Ergebnisse sind mglich, wenn man folgendes
Programm kompiliert und startet?
public class A43 {
public static void main(String[ ] args) {
System.out.println(Math.random());
}
}
a) 0.0
b) 0.565656567576
c) 0.676786876879
d) 1
e) 6
f) 100
(44) Frage
Welches Ergebnis erhlt man, wenn man folgendes Programm kompiliert und
startet?
public class A44 {
public A44(){
System.out.println(a);
}
public A44(String s){
System.out.println(b);
}
}
public class A44Sohn extends A44{
public A44Sohn(){
super(ich);
}
public static void main(String[ ] args) {
A44Sohn sohn = new A44Sohn();
}
}
a) a b
b) a b ich
c) a
d) b
704
15
Anhang
e) ich
f) Kompilierfehler
(45) Frage
Welches Ergebnis erhlt man, wenn man folgendes Programm mit aktivierten Assertions startet?
public class A45 {
public static void main(String[ ] args) {
String s = new String(hallo);
String st = new String(hallo);
boolean b = s.hashCode()==st.hashCode();
System.out.println(b);
assert b;
}
}
a) true
b) false
c) Es wird zur Laufzeit ein Error geworfen.
d) Kompilierfehler.
e) Es wird zur Laufzeit ein AssertionError geworfen.
(46) Frage
Welche der unten stehenden Variablen drfen dort stehen, wo hier steht?
public class A46 {
static String s = ich;
String st = hallo;
public static void main(String[ ] args) {
A46.methodeA();
}
static void methodeA(){
final String s1 = neu;
String s2 = heute;
class Innere{
Innere(){
System.out.println(hier);
}
}
Innere innere = new Innere();
}
}
a) s
b) st
15.1
705
c) s1
d) s2
e) Keine dieser Mglichkeiten.
(47) Frage
Welches Ergebnis erhlt man, wenn man folgendes Programm kompiliert und
startet?
public class A49 extends Thread{
public static void main(String[ ] args) {
A49 faden = new A49();
faden.start();
faden.start();
}
public void run(){
System.out.println(Faden);
}
}
a) Faden
706
15
Anhang
b) Faden Faden
c) Kompilierfehler
d) Zur Laufzeit wird eine IllegalThreadStateException geworfen.
(50) Frage
Welches Ergebnis erhlt man, wenn man folgendes Programm kompiliert und
startet?
public class A51 {
public static void main(String[ ] args) {
try{
int i = 0;
System.out.println(6/i);
}
catch(ArithmeticException fehler){
System.out.println(aufgefangen);
}
finally{
System.out.println(finally);
}
System.out.println(Ende);
}
}
15.1
707
(52) Frage
Welches Ergebnis erhlt man, wenn man folgendes Programm kompiliert und
startet?
public class A52 {
public static void main(String[ ] args) {
boolean a = true;
boolean b = false;
int i = 6;
int in = 3;
System.out.println(a&b);
System.out.println(i&in);
}
}
a) false 2
b) true 2
c) false true
d) true false
e) false false
f) true true
(53) Frage
Wieviele Objekte kommen nach Ablauf dieses Codes fr die Garbage Collection in Frage?
public class A53 {
public static void main(String[ ] args) {
String a = hallo;
String b = tschss;
A53 a53 = new A53();
a53.n(a);
a = heute;
}
public void n(String s){
//hier steht viel Code
}
}
a) 0
b) 1
c) 2
708
15
Anhang
d) 3
e) Es ist nicht genau vorhersehbar.
(54) Frage
Welches Ergebnis erhlt man, wenn man folgendes Programm kompiliert und
startet?
public class A54 {
public static void main(String[ ] args) {
Integer i = new Integer(1);
System.out.println(i.byteValue() + i.shortValue() + i.doubleValue());
}
}
a) 1
b) 1.0
c) 3
d) 3.0
e) Kompilierfehler
(55) Frage
Welche Methode weckt einen Thread auf, der mit der Methode wait() zum
Warten aufgefordert wurde?
a) run()
b) sleep()
15.1
709
c) yield()
d) start()
e) join()
f) notify()
(57) Frage
Welches Ergebnis erhlt man, wenn man folgendes Programm kompiliert und
startet?
public class A57 {
public static void main(String[ ] args) {
String a = heute;
if (a == heute){
System.out.println(eins);
}
else if (a = morgen){
System.out.println(zwei);
}
else if(a == bermorgen){
System.out.println(drei);
}
}
}
a) eins
b) zwei
c) drei
d) Keine Ausgabe.
e) Kompilierfehler
(58) Frage
Nehmen wir an, Sie haben das Array int [ ][ ] i = new int [2][2]: Mit welcher der
unten stehenden Mglichkeiten knnen Sie die Elemente einer Ebene des
Arrays zhlen?
a) i.length()
b) i.getLength()
710
15
Anhang
c) i.length
d) length
e) i().length
(59) Frage
15.1
711
Lsungen
(1) Frage
siehe Kapitel 7.4 Die Klasse String: Objekte der Stringklasse sind im
Gegensatz zu Objekten der Klasse StringBuffer unvernderbar.
(2) Frage
(3) Frage
siehe Kapitel 2.2 Die main( )-Methode und Kapitel 3.7 Subtyping
und Casting von Objekten: Es fehlt in der main()-Methode die eckige
Klammer nach String.
(4) Frage
(5) Frage
siehe Kapitel 5 Kontrollstrukturen: Es kommt zu keinem Kompilierfehler, da der default-Fall nicht am Schluss stehen muss.
(6) Frage
vgl. Kapitel 10 Threads und 10.4 Synchronisation: Die Zahlen erscheinen durcheinander auf dem Bildschirm, da keine Synchronisation
durch ein LOCK sichergestellt wurde.
(7) Frage
(8) Frage
(9) Frage
712
15
Anhang
zahl, den Datentyp und die Reihenfolge der Parameter, aber nicht auf
die Namen der Parameter oder auf den Rckgabetyp der Methode.
(10) Frage
(11) Frage
vgl. Kapitel 9 Assertions: Eine Java-Klasse wird mit dem Befehl java
ea A11 gestartet! In unserem Fall drfen Sie nicht aktiviert werden.
(12) Frage
(13) Frage
(14) Frage
vgl. Kapitel berschreiben von Methoden: Die berschreibende Methode muss den gleichen Namen, die gleichen Parameter und den gleichen Rckgabetyp wie die Originalmethode haben und sie darf ihre Zugriffsrechte nicht einschrnken.
(15) Frage
(16) Frage
vgl. Kapitel 13 Innere Klassen und 13.1 Statische und nicht-statische innere Klassen und Interfaces: Die Variable private String a der
Inneren berdeckt die gleichnamige Variable der ueren Klasse.
(17) Frage
(18) Frage
15.1
713
anfngt zu zhlen und nicht bei 0, deswegen sind es vier Objekte, die
fr die Garbage Collection in Frage kommen, und nicht 5.
(19) Frage
vgl. Kapitel 7.3 Die Klasse Math und 4.1 Arithmetische Operatoren: Der Rckgabetyp der Methode round() fr den Parameter double
ist long und der Rckgabetyp der Methode ceil() fr den Parameter
double ist double, somit kommt es zu keinem Kompilierfehler. Werden
bei der Addition unterschiedliche Datentypen verwendet, findet eine automatische Typanpassung statt: Es wird der kleinere Datentyp in den
greren umgewandelt. So ist das Ergebnis eine Zahl vom Typ double.
(21) Frage
siehe Kapitel 3.3 Interfaces und abstrakte Klassen und 12 Das Collections-Framework: Beachten Sie, dass dort steht nicht zutrifft. Die
Klasse HashSet implementiert das Interface Set.
(22) Frage
vgl. Kapitel 2.5 Primitive Datentypen und Variablendeklaration: Primitive Datentypen und Variablendeklaration.
(23) Frage
vgl. Kapitel 7.2 Die Wrapper-Klassen (Hllklassen): Die Klasse Boolean hat zwei Konstruktoren, einen mit einem primitiven Boolean-Wert
und einen mit einem String-Objekt, wobei bei dem String-Objekt nicht
auf Klein- oder Groschreibung geachtet werden muss. Als Parameter
kann auch der Defaultwert der Stringobjekte, nmlich null oder irgendein Text verwendet werden, in diesem Fall erhalten false als Ergebnis. Zu Kompilierfehlern kommt es allerdings in den Fllen, in denen
true oder false gro geschrieben und nicht als String eingegeben werden.
714
15
Anhang
(25) Frage
vgl. Kapitel 3.6 Objektreferenz und Konstruktoraufruf mit this und super: Der Standardkonstruktor in der Vaterklasse wurde gelscht, als
der Konstruktor mit dem String-Parameter erstellt wurde. Der Konstruktor der Kindklasse enthlt aber nach wie vor den impliziten Aufruf super(), deswegen kommt es zu einem Kompilierfehler.
(26) Frage
vgl. Kapitel 7.4 Die Klasse String und 7.5 Die Klasse StringBuffer:
Es gibt keine Methode concat() in der Klasse StringBuffer, sondern nur
in der Klasse String. In der Klasse StringBuffer gibt es nur die Methode
append():
(27) Frage
(28) Frage
(29) Frage
(30) Frage
(31) Frage
vgl. Kapitel 4.3 Die Operatoren Inkrement ++ und Dekrement --: Die
Variable i wird nach der Berechnung um 1 erhht und k und l werden
vor der Berechnung um 1 erhht. So wird 5 + 7 +8 = 20 berechnet.
15.1
715
(32) Frage
vgl. Kapitel 5.2.4 Die Sprungbefehle break und continue und markierte
Anweisungen: Der Befehl break sprung hat zur Folge, dass zu der
Sprungmarke sprung gesprungen und anschlieend die Schleife abgebrochen wird.
(33) Frage
vgl. Kapitel 3.7.2 Casten von Objekten: Es wird eine ClassCastException und keine ClassNotFoundException geworfen, da ein Objekt
der Vaterklasse nicht in ein Objekt der Kindklasse umgewandelt werden
kann, auch mit einem Cast nicht. Dies wird erst zur Laufzeit bemerkt.
(34) Frage
siehe Kapitel 11 Garbage Collection: Der Ausdruck c = b gibt das Objekt mit dem Inhalt c zur Garbage Collection frei, der Ausdruck b = new
String(neu) weist b ein neues Objekt zu und der Ausdruck c = null
weist c dem Objekt mit dem Inhalt null zu. Ab diesem Zeitpunkt ist das
Objekt mit dem Inhalt b isoliert, somit sind am Ende zwei Objekte zur
Garbage Collection freigegeben.
(35) Frage
(36) Frage
vgl. Kapitel 3.1.3 Bestandteile von Klassen: Mit Hilfe des Zugriffsbezeichners private werden Methoden gekapselt und mit Getter- und Setter-Methoden wieder zugnglich gemacht.
716
15
Anhang
(38) Frage
(39) Frage
a, e vgl. Kapitel 10 Threads: Die Methoden sleep(), join() und wait() mssen in einem try-catch-Block stehen.
(40) Frage
(41) Frage
vgl. Kapitel 9 Assertions: Nach dem assert-Ausdruck darf keine Zuweisung stehen, da dies ein Syntaxfehler ist, der bereits zur Kompilierzeit bemerkt wird und zur Laufzeit einen Error wirft.
(42) Frage
(43) Frage
a, b, vgl. Kapitel 7.3 Die Klasse Math: Die Methode random() gibt eine Zufallszahl
c
vom Typ double zurck, die grer oder gleich 0.0 oder kleiner 1.0 ist.
(44) Frage
(45) Frage
siehe Kapitel 9 Assertions, 7.7 Vergleich von Objekten und primitiven Datentypen und 12.7 Die hashCode( )-Methode: Objekte, die
im Vergleich mit der equals()-Methode gleich sind, haben auch einen
15.1
717
(48) Frage
(49) Frage
(50) Frage
vgl. Kapitel 12.7 Die hashCode( )-Methode: Nur die Klassen StringBuffer und Number berschreiben die hashCode()-Methode der Klasse
Object nicht.
(51) Frage
siehe Kapitel 8.3 Exception Handling: Da eine Zahl nicht durch 0 teilbar ist, wird eine ArithmeticException geworfen, die aufgefangen wird.
Der finally-Block wird auf jeden Fall ausgefhrt und da die geworfene
Exception aufgefangen wird, wird das Programm nicht abgebrochen
und es wird auch die Methode System.out.println(Ende) ausgefhrt.
(52) Frage
vgl. Kapitel 4.2 Die Boolean logischen Operatoren und Kapitel 4.5
Integer Bitweise Operatoren: Erstere vergleichen zwei Boolean-Ausdrcke miteinander, wobei true & false das Ergebnis false hat. Zweitere
wandeln Dezimalzahlen in binre Zahlen um und als Ergebnis erhalten
Sie wieder eine Dezimalzahl. Diese lautet in unserem Fall 2.
718
15
Anhang
(53) Frage
(54) Frage
siehe Kapitel 7.2.4 Umwandeln eines Wrappers in einen primitiven Datentyp: xxxValue( ) und Kapitel 4.1 Arithmetische Operatoren: Es
gibt in der Wrapper-Klasse Integer die Methoden byteValue(), doubleValue(), floatValue(), intValue(), longValue() und shortValue(), aber
keine Methoden charValue() und booleanValue(). Eine Verwendung
von charValue() und booleanValue() bei einem Wrapper-Objekt wrde
zu einem Kompilierfehler fhren. Werden bei der Addition unterschiedliche Datentypen verwendet, findet eine automatische Typanpassung
statt: Es wird der kleinere Datentyp in den greren umgewandelt. So
ist das Ergebnis eine Zahl vom Typ double. Somit wird die Zahl 3.0 auf
der Konsole ausgegeben.
(55) Frage
(57) Frage
(58) Frage
15.2
719
(59) Frage
(60) Frage
siehe Kapitel 10 Threads: Ein Thread wird mit der Methode start() gestartet, die Methode run() startet keinen Thread.
(61) Frage
b, d, Kapitel 3.3 Interfaces und abstrakte Klassen: Methoden in Interfaces sind imf
plizit abstract und public, sie knnen also folglich keine nicht abstrakte Methoden enthalten. Dies steht im Gegensatz zu abstrakten Klassen, die sowohl abstrakte als auch nicht abstrakte Methoden enthalten knnen. Enthlt allerdings
eine Klasse eine abstrakte Methode, muss die Klasse wiederum abstract deklariert werden.
Welches Ergebnis erhlt man, wenn man folgendes Programm kompiliert und
startet?
public class A2 {
public static void main(String[ ] args) {
720
15
Anhang
int i = 1;
long l = 3;
int in = i++ + ++l + l++;
System.out.println(in);
}
}
a) 7
b) 8
c) 9
d) 10
e) Kompilierfehler
(3) Frage
Welches Ergebnis erhlt man, wenn man folgendes Programm kompiliert und
startet?
import static java.lang.Math.*;
public class A4 {
public static void main(String[ ] args) {
int i = round(2.5);
float d = floor(2.5);
}
}
a) 2.0 2.0
b) 3.0 2.0
c) 3.0 3.0
d) 2.0 3.0
15.2
721
e) Kompilierfehler
(5) Frage
Welches Ergebnis erhlt man, wenn man folgendes Programm kompiliert und
startet?
public enum A6 {
eins, zwei, drei;
public static void main(String[ ] args){
A6 a = A6.drei;
switch(a){
case eins: System.out.println(Hallo eins!);
case zwei: System.out.println(Hallo zwei!);
case drei: System.out.println(Hallo drei!);
default: System.out.println(Hallo!);
}
}
}
Welches Ergebnis erhlt man, wenn man folgendes Programm kompiliert und
startet?
public class A7 extends Thread{
private static Object Lock = new Object();
722
15
Anhang
a) Es werden alle geraden Zahlen zwischen 0 und 300 zweimal hintereinander auf der Konsole ausgegeben.
b) Es werden alle ungeraden Zahlen zwischen 0 und 300 zweimal hintereinander auf der Konsole ausgegeben.
c) Es werden alle geraden Zahlen zwischen 0 und 300 zweimal durcheinander auf der Konsole ausgegeben.
d) Es werden alle ungeraden Zahlen zwischen 0 und 300 zweimal durcheinander auf der Konsole ausgegeben.
(8) Frage
Welches Ergebnis erhlt man, wenn man folgendes Programm kompiliert und
startet?
public class A8 {
public static void main(String[ ] args) {
int [ ] i = {4, 5};
for (short ergebnis: i ){
System.out.println(ergebnis);
}
}
}
a) 4
b) 5
c) 4 5
d) Kompilierfehler
15.2
723
(9) Frage
Welches Ergebnis erhlt man, wenn man folgendes Programm kompiliert und
startet?
public class A10 {
public static void main(String[ ] args) {
String s = baaabaaabaaab;
String [ ] st = s.split(a+);
for (String str: st){
System.out.println(str);
}
}
}
a) b b b b
b) aaa aaa aaa
c) baaabaaabaaab
d) Kompilierfehler
(11) Frage
724
15
Anhang
(12) Frage
Wie knnen Sie die innere Klasse dort instanziieren wo hier steht?
public class A13 {
public class Inner{
}
public static void main(String[ ] args) {
hier
}
}
Welches Ergebnis erhlt man, wenn man die Klasse A14Objekte kompiliert
und startet?
public class A14{
private String farbe;
public String getFarbe() {
return farbe;
}
public void setFarbe(String farbe) {
this.farbe = farbe;
}
}
import java.io.File;
15.2
725
import java.io.FileOutputStream;
import java.io.IOException;
import java.io.ObjectOutputStream;
public class A14Objekte {
public static void main(String[ ] args) {
File f = new File(Speichern.txt);
A14 a = new A14();
a.setFarbe(rot);
try {
FileOutputStream fw = new FileOutputStream(f);
ObjectOutputStream oos = new ObjectOutputStream(fw);
oos.writeObject(a);
oos.close();
} catch (IOException e) {
e.printStackTrace();
}
}
}
Welches Ergebnis erhlt man, wenn man folgendes Programm kompiliert und
startet?
import java.util.regex.Matcher;
import java.util.regex.Pattern;
public class A15 {
public static void main(String[ ] args) {
Pattern pa = Pattern.compile((\\d));
Matcher ma = pa.matcher(zwei 1 drei 2 vier);
while(ma.find()){
System.out.println(ma.group());
}
}
}
a) 1 2
b) zwei drei vier
726
15
Anhang
Welches Ergebnis erhlt man, wenn man folgendes Programm kompiliert und
startet?
public class A16 {
public static void main(String[ ] args) {
String s = new String(aus);
String st = new String(aus);
System.out.println(s == st);
System.out.println(s.equals(st));
}
}
a) true true
b) false false
c) false true
d) true false
(17) Frage
Welche der unten stehenden Modifier drfen vor einer Klasse stehen?
a) native
b) transient
c) protected
d) synchronized
e) private
f) Keine dieser Mglichkeiten.
(18) Frage
Welches Ergebnis erhlt man, wenn man folgendes Programm kompiliert und
startet?
public class A18 {
public static void main(String[ ] args) {
String[ ][ ] s ={
{1, 2},
{3, 4}};
System.out.println(s[1][1]);
15.2
727
}
}
a) 1
b) 2
c) 3
d) 4
e) ArrayIndexOutOfBoundsException
(19) Frage
Welches Ergebnis erhlt man, wenn man folgendes Programm kompiliert und
startet?
public class A19 {
public static void main(String[ ] args) {
Integer in = 1;
int i = 5;
Integer addition = in + i;
int addition1 = in + i;
System.out.println(addition);
System.out.println(addition1);
}
}
a) 6 6
b) Kompilierfehler
c) Es wird eine Exception geworfen.
(20) Frage
Welches Ergebnis erhlt man, wenn man folgendes Programm kompiliert und
startet?
public class A20 {
public static void main(String[ ] args) {
Integer i = 2;
Integer i2 = 2;
Integer i3 = 150;
Integer i4 = 150;
System.out.println(i == i2);
System.out.println(i.equals(i2));
System.out.println(i3 == i4);
System.out.println(i3.equals(i4));
}
}
728
15
Anhang
Welches Ergebnis erhlt man, wenn man folgendes Programm kompiliert und
startet?
public class A21 {
public static void main(String[ ] args) {
String s = new String(a);
StringBuffer sb = new StringBuffer(a);
System.out.println(s == sb);
}
}
a) true
b) false
c) Kompilierfehler
d) Es wird zur Laufzeit eine Exception geworfen.
(22) Frage
Welches Ergebnis erhlt man, wenn man folgendes Programm kompiliert und
startet?
public class A22 {
public static void main(String args[ ]) {
System.out.println(Hallo);
}
}
a) Hallo
b) Kompilierfehler
c) Der Versuch, das Programm auf der Kommandozeile zu starten, wird fehlschlagen.
d) Die eckige Klammer darf nicht nach args stehen, sondern muss nach
String stehen.
15.2
729
(23) Frage
Welches Ergebnis erhlt man, wenn man folgendes Programm kompiliert und
startet?
public class A23 {
public static void main(String[ ] args) {
try{
throw new ClassCastException();
}
catch (ClassCastException fehler){
System.out.println(Class);
throw new ArithmeticException();
}
catch(ArithmeticException rechenfehler){
System.out.println(Arithmetic);
}
finally{
System.out.println(Ende);
}
}
}
Welches Ergebnis erhlt man, wenn man folgendes Programm kompiliert und
startet?
import java.util.Locale;
public class A24 {
public static void main(String[ ] args) {
Double d = new Double(20.668);
String str1 = String.format(Locale.US, %.2f, d);
System.out.println(str1);
}
}
a) 20.67
b) 20.668
c) 20.66
730
15
Anhang
d) Kompilierfehler
e) Zur Laufzeit wird eine Exception geworfen.
(25) Frage
Zeile 1
Zeile 2
Zeile 3
Zeile 4
Zeile 5
a) Zeile 1
b) Zeile 2
c) Zeile 3
d) Zeile 4
e) Zeile 5
(26) Frage
Welches Ergebnis erhlt man, wenn man folgendes Programm kompiliert und
startet?
public class A26 {
public static void main(String[ ] args) {
A26 a = new A26();
a.ausgabe(3.0);
}
public void ausgabe (Float f){
System.out.println(Float);
}
public void ausgabe (Double d){
System.out.println(Double);
}
}
a) Float
b) Double
c) Kompilierfehler
d) Keine dieser Mglichkeiten.
15.2
731
(27) Frage
Welches Ergebnis erhlt man, wenn man folgendes Programm kompiliert und
startet?
public class A28Vater {
}
public class A28 extends A28Vater{
public static void main(String[ ] args) {
A28 sohn = new A28();
A28Vater vater = new A28Vater();
vater = (A28Vater)sohn;
}
}
Welches Ergebnis erhlt man, wenn man folgendes Programm kompiliert und
startet?
public class A29 {
public static void main(String[ ] args) {
LinkedList<String> s = new LinkedList<String>();
String st = new String(tisch);
String st1 = new String(stuhl);
String st2 = new String(teppich);
s.add(st);
s.add(st1);
s.add(st2);
for (String r:s){
System.out.println(r);
}
}
}
732
15
Anhang
Welches Ergebnis erhlt man, wenn man folgendes Programm kompiliert und
startet?
public class A30 {
public static void main(String[ ] args) {
A30 a = new A30();
a.laufe();
}
void laufe() {
Runnable r = new Runnable() {
public void run() {
System.out.println(Ich laufe!);
}
};
Thread t = new Thread(r);
t.start();
}
}
a) Ich laufe!
b) Der Thread muss mit der Methode run() gestartet werden, deswegen
kommt es zu keiner Ausgabe.
c) Kompilierfehler
(31) Frage
Welche der unten stehenden Klassen macht es mglich, Artikel mit dem entsprechenden Preis zu speichern? Es soll aber nicht mglich sein, null als
Wert einzugeben?
a) Hashtable
b) HashMap
c) HashSet
d) LinkedList
e) HashSet
15.2
733
f) LinkedHashSet
(32) Frage
Welches Ergebnis erhlt man, wenn man folgendes Programm kompiliert und
startet?
public class A32 {
void aufrufen(String... st){
for(String s: st){
System.out.println(s);
}
}
public static void main(String[ ] args) {
A32 va = new A32();
va.aufrufen(new String[ ]{null, eins});
}
}
a) null eins
b) null
c) eins
d) Kompilierfehler
(33) Frage
Welches Ergebnis erhlt man, wenn man folgendes Programm kompiliert und
startet?
public class A33 {
public static void main(String[ ] args) {
try{
System.out.println(Versuch);
}finally{
System.out.println(Ende);
}
}
}
a) Versuch Ende
b) Versuch
c) Ende
d) Kompilierfehler
e) Es wird zur Laufzeit eine Exception geworfen.
734
15
Anhang
(34) Frage
Welches Ergebnis erhlt man, wenn man folgendes Programm kompiliert und
startet?
import java.io.FileNotFoundException;
public class A35 {
public static void main(String[ ] args) {
try{
throw new FileNotFoundException();
}catch(ArithmeticException rechenFehler){
System.out.println(fehler);
}finally {
System.out.println(Ende);
}
}
}
a) fehler
b) Ende
c) fehler Ende
d) Kompilierfehler
(36) Frage
Welches Ergebnis erhlt man, wenn man folgendes Programm kompiliert und
startet?
public class A36 {
public static void main(String[ ] args) {
int a = 0x1f;
int b = a << 2;
int c = a >> 2;
System.out.println(Integer.toHexString(b));
System.out.println(Integer.toHexString(c));
}
}
15.2
735
a) 0x1f 0x1f
b) 0xf 0xf
c) 0x6c 0x6
d) 0x7d 0x7
e) 0x7c 0x7
(37) Frage
Wieviele Objekte stehen nach Ablauf des unten stehenden Codes fr die
Garbage Collection zur Verfgung?
public class A37 {
A37 a;
public static void main(String[ ] args) {
A37 a1 = new A37();
A37 a2 = new A37();
a1.a = a2;
a2.a = a1;
a2 = new A37();
a1 = new A37();
}
}
a) 0
b) 1
c) 2
d) 3
e) 4
(38) Frage
Welche Zugriffsbezeichner darf eine Methode haben, wenn Sie auf diese
Methode in einer Klasse, die sich auerhalb des Packages befindet, zugreifen mchten?
a) private
b) protected
c) package local
d) public
e) Keine dieser Mglichkeiten.
736
15
Anhang
(39) Frage
Welche Arten der Deklaration und Initialisierung von Arrays fhrt nicht zu einem Kompilierfehler?
a) int [ ][ ][ ] a = new int [3][ ][ ];
b) int [ ][ ][ ] a = new int [3][ ][3];
c) int [ ] a [ ] [ ]= new int [3][ ][ ];
d) int a [ ] [ ] [ ] = new int [3][ ][ ];
e) int a [ ] [ ] [ ]= new int [ ][3][3];
f) Keine dieser Mglichkeiten.
(40) Frage
Welches Ergebnis erhlt man, wenn man folgendes Programm kompiliert und
startet?
public class A40 {
public static void main(String[ ] args) {
String[ ] a = {1, 2};
for(int i = 0; i < a.length; i++){
System.out.println(a[i]);
}
for(String i:a){
System.out.println(i);
}
}
}
a) Keine Ausgabe.
b) 1 2
c) 1 2 1 2
d) Kompilierfehler
(41) Frage
Welches Ergebnis erhlt man, wenn man folgende Klassen kompiliert und
startet?
public class A41 {
}
public class A41Tochter extends A41 {
public static void main(String[ ] args) {
A41 mutter = new A41();
A41Tochter tochter = new A41Tochter();
15.2
737
tochter = (A41Tochter)mutter;
}
}
Welches Ergebnis erhlt man, wenn man folgendes Programm kompiliert und
startet?
public class A43 {
public static void main(String[ ] args) {
String s = new String(heute);
int i = 6;
int in = i + i + s;
System.out.println(in);
}
}
a) 6 6 heute
b) 12 heute
c) Kompilierfehler
738
15
Anhang
(44) Frage
Welches Ergebnis erhlt man, wenn man folgendes Programm kompiliert und
startet?
import java.util.Collection;
import java.util.HashSet;
import java.util.Map;
public class A44 {
public static void main(String[ ] args) {
HashSet l = new HashSet();
System.out.println(l instanceof Collection);
System.out.println(l instanceof Map);
System.out.println(l instanceof Object);
}
}
Welches Ergebnis erhlt man, wenn man folgendes Programm kompiliert und
startet?
public class A45 {
public void laufen(){
System.out.println(Mutter);
}
}
public class A45Kind extends A45 {
private void laufen(){
System.out.println(Kind);
}
public static void main(String[ ] args) {
A45Kind kind = new A45Kind();
kind.laufen();
}
}
a) Mutter Kind
15.2
739
b) Mutter
c) Kind
d) Kompilierfehler
(46) Frage
Welches Ergebnis erhlt man, wenn man folgendes Programm kompiliert und
startet?
public class A46 {
public static void main(String[ ] args) {
TreeSet<Object> s = new TreeSet<Object>();
String st = new String(delta);
String st1 = new String(aber);
String st2 = new String(delta);
s.add(st);
s.add(st1);
s.add(st2);
for(Object r:s){
System.out.println(r);
}
}
}
Welches Ergebnis erhlt man, wenn man folgendes Programm kompiliert und
startet?
public class A47 {
public static void main(String[ ] args) {
for (int i = 1; i<3; i++){
for (int j = 1; j<3; j++){
System.out.println(i+ +j);
}
}
}
}
a) 11 12 21 22
740
15
Anhang
b) 11 22
c) 2 3 3 4
d) 2 4
e) Kompilierfehler
(48) Frage
Welches Ergebnis erhlt man, wenn man folgendes Programm kompiliert und
startet?
public enum A48 {
Herr {public String toString(){
return Sehr geehrter Herr,;}
},
Frau {public String toString(){
return Sehr geehrte Frau,;}
};
public static void main(String[ ] args){
System.out.println(A48.Herr);
}
}
a) Herr
b) Sehr geehrter Herr,
c) Kompilierfehler
(49) Frage
Welches Ergebnis erhlt man, wenn man folgendes Programm kompiliert und
startet?
public class A49 {
public static void main(String[ ] args) {
StringBuilder sb = new StringBuilder();
StringBuffer s = new StringBuffer();
Formatter f = new Formatter(sb);
Formatter fo = new Formatter(s);
boolean bol = true;
System.out.println(f.format(%2$s, %1$s ,tschss, hallo) );
System.out.printf(%b, bol);
}
}
15.2
741
d) Kompilierfehler
(50) Frage
Welches Ergebnis erhlt man, wenn man folgendes Programm kompiliert und
startet?
public class A50 {
void methodA(float... f){
System.out.println(float);
}
void methodA(double... d){
System.out.println(double);
}
public static void main(String[ ] args) {
A50 a = new A50();
Float[ ] fl = {2.4f, 2.5f};
a.methodA(fl);
}
}
a) float
b) double
c) Kompilierfehler
(51) Frage
Wie knnen Sie an der Stelle, an der hier steht, auf die Methode getInstance() der Klasse DateFormat zugreifen?
import java.text.DateFormat;
public class A52 {
public static void main(String[ ] args) {
742
15
Anhang
hier
}
}
a) DateFormat f = DateFormat.getInstance();
b) DateFormat f = new DateFormat();
f.getInstance();
c) DateFormat.getInstance();
d) getInstance();
(53) Frage
Welches Ergebnis erhlt man, wenn man folgendes Programm kompiliert und
startet?
public class A53Vater {
A53Vater(){
System.out.println(Vater);
}
A53Vater(String s){
System.out.println(s);
}
}
public class A53 extends A53Vater{
A53(){
super (Papa);
System.out.println(Sohn);
}
public static void main(String[ ] args) {
A53 a = new A53();
}
}
15.2
743
(54) Frage
Welches Ergebnis erhlt man, wenn man folgendes Programm kompiliert und
startet?
import java.util.LinkedList;
public class A54 {
public static void main(String[ ] args) {
LinkedList<String> s = new LinkedList<String>();
String st = new String(delta);
String st1 = new String(aber);
String st2 = new String(beta);
s.add(st);
s.add(st1);
s.add(st2);
String o = s.get(1);
System.out.println( o );
}
}
a) delta
b) beta
c) aber
d) Kompilierfehler
e) Es wird zur Laufzeit eine Exception geworfen.
(55) Frage
Welches Ergebnis erhlt man, wenn man folgendes Programm kompiliert und
startet?
public class A55Notify extends Thread{
int last;
public void run() {
synchronized (this) {
for (int i = 0; i < 23; i++) {
last = i;
}
notify();
}
}
}
public class A55Wait {
public static void main(String[ ] args) {
A55Notify n = new A55Notify();
n.start();
synchronized (n) {
744
15
Anhang
try {
n.wait();
} catch (InterruptedException e){}
}
System.out.println(n.last);
}
}
a) 0
b) 22
c) 23
d) Kompilierfehler
e) Es wird zur Laufzeit eine IllegalMonitorStateException geworfen.
(56) Frage
Welches Ergebnis erhlt man, wenn man folgendes Programm kompiliert und
startet?
public class A56 {
public static void main(String[ ] args) {
char c = 3; String s = zwei;
Integer i = new Integer(s);
Integer in = new Integer(c);
System.out.println(i);
System.out.println(in);
}
}
a) zwei 3
b) 3 zwei
c) Kompilierfehler
d) Es wird zur Laufzeit eine NumberFormatException geworfen.
(57) Frage
15.2
745
(58) Frage
Welches Ergebnis erhlt man, wenn man folgendes Programm kompiliert und
startet?
public class A59 {
public static void main(String[ ] args) {
int i = 12;
System.out.println(~i);
}
}
a) 12
b) 13
c) 12
d) 13
e) 14
(60) Frage
746
15
Anhang
try {
FileWriter fw = new FileWriter(f);
BufferedWriter bw = new BufferedWriter(fw);
hier pw = new hier(bw);
pw.print(Hallo);
pw.close();
} catch (IOException e) {
e.printStackTrace();
}
}
}
a) PrintWriter
b) FileReader
c) FileWriter
d) OutputStream
e) ObjectOutputStream
f) Keine dieser Mglichkeiten.
(61) Frage
a) Calendar
b) Number
c) NumberFormat
d) DateFormat
15.2
747
e) Formatter
f) Keine dieser Mglichkeiten.
(62) Frage
Welches Ergebnis erhlt man, wenn man folgendes Programm kompiliert und
startet?
import java.util.ArrayList;
import java.util.List;
public class A63 {
public static void main(String[ ] args) {
ArrayList<String> s = new ArrayList<String>();
String st = new String(zwei);
String st1 = new String(drei);
s.add(st);
s.add(st1);
A63 a = new A63();
a.auslesen(s);
}
public void auslesen(List<? extends Object> l) {
for (Object r : l) {
System.out.println(r);
}
}
}
a) zwei drei
b) drei zwei
c) Kompilierfehler
748
15
Anhang
In welcher Zeile tritt ein Kompilierfehler auf, wenn man folgendes Programm
kompiliert und startet?
public class A64 {
void guten(){
class Lokale {
String s1 = eins;
final static String s2 = zwei;
String s = drei;
}
}
}
a) Zeile 1
b) Zeile 2
c) Zeile 3
d) Keine dieser Mglichkeiten.
(65) Frage
a) values()
b) find()
c) EnumSet.range()
d) valueOf()
e) value()
Zeile 1
Zeile 2
Zeile 3
15.2
749
(66) Frage
Welches Ergebnis erhlt man, wenn man folgendes Programm kompiliert und
startet?
public class A66 {
public static void main(String[ ] args) {
String s = 11-12+13*14;
String d = [-+];
Scanner scanner = new Scanner(s);
scanner.useDelimiter(d);
while (scanner.hasNext( )){
System.out.println(scanner.next( ));
}
}
}
a) 11-12+13*14
b) 11 12 13*14
c) 11 12 13 14
d) Keine Ausgabe.
(67) Aufgabe
Welches Ergebnis erhlt man, wenn man folgendes Programm kompiliert und
startet?
public class A67 {
public static void main(String[ ] args) {
Float f = new Float(2.0f);
Double d = new Double(2.0);
System.out.println(d.equals(f));
System.out.println(d == f);
}
}
a) true false
b) false true
c) false false
d) true true
e) Kompilierfehler
750
15
Anhang
(68) Frage
Welches Ergebnis erhlt man, wenn man folgendes Programm kompiliert und
startet?
public class A68 {
public static void main(String[ ] args) {
String s = A;
if (s == a){
System.out.println(a);
}
else if (s == b){
System.out.println(b);
}
}
}
a) a
b) b
c) a b
d) Keine Ausgabe
e) Kompilierfehler
(69) Frage
Welches Ergebnis erhlt man, wenn man folgendes Programm kompiliert und
startet?
public class A69 {
public static void main(String[ ] args) {
long x = 1;
switch (x){
case 1: System.out.println(1); break;
case 2: System.out.println(2); break;
default: System.out.println(3);
}
}
}
a) 1
b) 2
c) 3
d) 1 2 3
e) Kompilierfehler
15.2
751
(70) Frage
Welches Ergebnis erhlt man, wenn man folgendes Programm kompiliert und
startet?
public class A70 {
public static void main(String[ ] args) {
boolean a = true;
boolean b = true;
boolean c = false;
boolean d = false;
System.out.println(a & b);
System.out.println(b ^ c);
System.out.println(c & d);
}
}
Welche der unten stehenden Methoden bringt einen Thread in jedem Fall
vom laufenden in den ausfhrbaren Zustand?
a) yield( )
b) sleep( )
c) wait( )
d) notify( )
e) run( )
f) Keine dieser Mglichkeiten.
(72) Frage
752
15
Anhang
d) delete( )
e) write( )
f) Keine dieser Mglichkeiten.
Lsungen
(1) Frage
(2) Frage
(3) Frage
vgl. Kapitel 7.3 Die Klasse Math, Kapitel 2.5.3 Literale, Abschnitt
Fliekommazahlen, Kapitel 14 Neuerungen in Java 2 Plattform 5.0
und Unterkaptitel Kapitel 14.5.6 Der statische Import : Kommazahlen
sind grundstzlich vom primitiven Datentyp double, wollen Sie allerdings
einen Wert vom Typ float haben, muss f explizit dastehen. Die Methode
round( ) hat fr den Parameter double den Rckgabetyp long und nicht
int, und die Methode floor( ) hat fr den Parameter double den Rckgabetyp double und nicht float, so kommt es zu einem Kompilierfehler.
(5) Frage
vgl. Kapitel 2.4 Schlsselwrter: Merke: Alle Schlsselwrter enthalten nur Kleinbuchstaben!
15.2
753
(6) Frage
(7) Frage
(8) Frage
vgl. Kapitel 14 Neuerungen in Java 2 Plattform 5.0 und das Unterkapitel 14.1.1 Die erweiterte for-Schleife: Der Rckgabetyp der forSchleife (short) entspricht nicht dem Typ des Arrays (int), deswegen
kommt es zu einem Kompilierfehler.
(9) Frage
(11) Frage
a, f siehe Kapitel 12.2 Das Interface Collection: Es sind alle Objekte, die
das Interface List implementieren, wie LinkedList, ArrayList und Vector.
(12) Frage
vgl. Kapitel 11 Garbage Collection: Kommt ein Objekt fr die Garbage Collection in Frage, kann nicht genau vorhergesagt werden, wann
und ob das Objekt tatschlich beseitigt wird. Die Methode System.gc( )
stellt nur ein Versuch dar die Garbage Collection zu beschleunigen, sicherstellen kann man dies nicht.
754
15
Anhang
(13) Frage
(14) Frage
siehe Kapitel 8 Exceptions und Kapitel Neuerungen in Java 2 Platform 5.0 und Unterkapitel Ein- und Ausgabe ber Bytestrme: Objekte
knnen nur serialisiert werden, wenn Sie das Interface Serializable implementieren, anderenfalls wird eine NotSerializableException geworfen.
(15) Frage
(16) Frage
(17) Frage
(18) Frage
(19) Frage
(20) Frage
15.2
755
(22) Frage
vgl. Kapitel 2.2 Die main( )-Methode: Die eckige Klammer darf auch
nach args stehen, sie muss nicht nach String stehen.
(23) Frage
(24) Frage
(25) Frage
(26) Frage
siehe Kapitel 2.5 Primitive Datentypen und Variablendeklaration, Kapitel 14 Neuerungen in Java 2 Plattform 5.0 und Unterkapitel 14.2
Autoboxing: Literale, die Fliekommazahlen sind, sind grundstzlich
vom primitiven Datentyp double: Steht z. B. float a = 0.0; so ist a trotzdem vom primitiven Datentyp double und nicht float. Wollen Sie einen
Wert von Typ float haben, muss f explizit dastehen: float a = 0.0F;. Der
primitive Datentyp double wird anschlieend automatisch in ein Wrap-
756
15
Anhang
a, e siehe Kapitel 12 Das Collections-Framework und Kapitel 3.2 Vererbung: Eine Vater-Kind-Beziehungen ist eine is-a-Relationship, wohingegen has-a-Relationship eine Aggregation, einen Zusammenbau, darstellt.
(28) Frage
vgl. Kapitel 3.7 Subtyping und Casting von Objekten: Folgender Cast
vater = (A28Vater)sohn; ist berflssig ist, aber legal. Diese Vorgehensweise ist identisch mit vater = sohn;. Man kann einem Vater einen Sohn
zuweisen, da ein Vaterobjekt auch ein Kindobjekt sein kann.
(29) Frage
vgl. Kapitel 12 Das Collections-Framework und Kapitel 14 Neuerungen in Java 2 Plattform 5.0 und Unterkapitel 14.4 Generics im Collections-Framework: Die Reihenfolge der Ausgabe ist bei einer LinkedList identisch mit der Reihenfolge der Eingabe.
(30) Frage
(31) Frage
(32) Frage
(33) Frage
vgl. Kapitel 8 Exceptions: Steht ein try- mit einem finally-Block alleine
da, wird das Programm nicht abgebrochen, wenn, wie in unten stehen-
15.2
757
dem Beispiel, im try-Block keine Exception geworfen wird. Es wird sowohl der try-Block als auch der finally-Block problemlos abgearbeitet.
(34) Frage
vgl. Kapitel 9 Assertions: Der Befehl der Kommandozeile -ea oder die
Langform -enableassertions aktiviert die Assertions fr alle Nicht-Systemdateien.
(35) Frage
(36) Frage
(37) Frage
(38) Frage
siehe Kapitel 3.1 Klassen und Objekte, Abschnitt Zugriffsbezeichner: Auf Methoden, die private sind, knnen Sie nur von innerhalb der
gleiche Klasse darauf zugreifen. Protected bedeutet, dass Sie nur auf
Methoden von Klassen im gleichen Package oder von Subklassen der
Klasse in anderen Packages zugreifen knnen. Sie knnen also nicht
auf eine Methode, die protected ist, von einer anderen Klasse eines anderen Packages zugreifen.
(39) Frage
758
15
Anhang
(40) Frage
(41) Frage
vgl. Kapitel 3.7 Subtyping und Casting von Objekten: Will man ein
Objekt vom Typ A41 in einen A41Tochter umwandeln, schlgt dieser
Versuch fehl, da die Klasse A41 mehrere Kindklassen besitzen knnte
und somit sowohl das eine Kind als auch das andere Kind beinhalten
kann und nicht nur das eine oder das andere. Dies bemerkt der Kompiler allerdings nicht zur Kompilierzeit, NetBeans zeigt keinen Fehler an,
es kommt erst zur Laufzeit zu einer ClassCastException.
(42) Frage
vgl. Kapitel 12 Das Collections-Framework: Keine dieser Klassen implementiert das Interface Set und hat bei der Ausgabe der Elemente
dieselbe Reihenfolge wie bei der Eingabe.
(43) Frage
(44) Frage
(45) Frage
15.2
759
(46) Frage
vgl. Kapitel 12 Das Collections-Framework und Kapitel 14 Neuerungen in Java 2 Plattform 5.0 und Kapitel 14.4 Generics im CollectionsFramework: Man kann einm TreeSet<Object> Stringobjekte hinzufgen. Dies ist mglich, da ein Objekt der Klasse String ein Subtyp der
Klasse Object ist. Sie erhalten jedoch Objekte der Klasse Object zurck, obwohl Sie Stringobjekte hinzufgen. Deshalb wrde es zu einem
Kompilierfehler fhren, wenn Sie fr r den Rckgabetyp String festlegen
wrden. Elemente werden im TreeSet nach der natrlichen Ordnung
(ASCII-Code) alphabetisch sortiert und doppelte Werte sind nicht erlaubt.
(47) Frage
(48) Frage
(49) Frage
(50) Frage
760
15
Anhang
(51) Frage
vgl. Kapitel 10 Threads: Den Methoden wait( ) und join( ) kann man
einen Zeitparameter bergeben, wohingegen man der Methode sleep( )
einen Zeitparameter bergeben muss.
(52) Frage
siehe Kapitel 3.6 Objektreferenz und Konstruktoraufruf mit this und super: Der Konstruktoraufruf mit super(Papa) hat zur Folge, dass er
den impliziten Konstruktoraufruf super( ) ersetzt, deswegen wird Papa
Sohn auf der Konsole ausgegeben.
(54) Frage
vgl. Kapitel 12 Das Collections-Framework und Kapitel 14 Neuerungen in Java 2 Plattform 5.0 und Unterkapitel 14.4 Generics im Collections-Framework: Bei der LinkedList ist die Reihenfolge der Eingabe
identisch mit der Reihenfolge der Ausgabe und an der Stelle 1 befindet
sich das Element aber.
(55) Frage
vgl. Kapitel 10 Threads: Die Methode notify( ) muss in einem synchronized-Block stehen, der den Schlssel zu dem Lock des Objektes
besitzen muss, das die wait( )-Methode aufgerufen hat. So muss dort in
unten stehendem Fall synchronized (this) stehen (vgl. Kapitel zum
Thema this). Ist dies nicht der Fall, wird eine java.lang.IllegalMonitorStateException geworfen.
(56) Frage
15.2
761
(57) Frage
siehe Kapitel 2.5 Primitive Datentypen und Variablendeklaration: Primitive Datentypen und Variablendeklaration.
(59) Frage
(60) Frage
(61) Frage
(62) Frage
liegt bei 5
bei
1
bei
10
(63) Frage
vgl. Kapitel 12 Das Collections-Framework und Kapitel 14 Neuerungen in Java 2 Plattform 5.0 und Unterkapitel 14.4 Generics im Collections-Framework: Sie knnen der Methode public void auslesen(List<? extends Object> l) alle Listen, die Objekte der Klasse Object
und alle dazugehrigen Subklassen enthalten, als Parameter bergeben. Die Elemente werden bei der Array-List in der gleichen Reihenfolge
ein- wie ausgegeben.
762
15
Anhang
(64) Frage
vgl. Kapitel 13.2 Lokale Klassen: Es sind nur nicht-statische, aber final static Deklarationen innerhalb von Lokalen Klassen mglich.
(65) Frage
(66) Frage
(67) Frage
Kapitel 7.7 Vergleich von Objekten und primitiven Datentypen, Kapitel 14 Neuerungen in Java 2 Plattform 5.0 und Unterkapitel 14.2 Autoboxing: Unterschiedliche Wrapper-Objekte lassen sich auch im Tiger-Release nur mit der equals( )-Methode vergleichen, was false als
Ergebnis zurckgibt. Der Vergleich mit == fhrt nach wie vor zu einem
Kompilierfehler. Zwei unterschiedliche primitive Datentypen kann man,
wie seither auch, nur mit == vergleichen und nicht mit equals( ). Hierbei
ist das Ergebnis allerdings true. Fr die primitiven Datentypen long, float
und double gibt es keine Immutable Objects im Cache.
(68) Frage
vgl. Kapitel 5 Kontrollstrukturen: Achtung: Es kommt zu keiner Ausgabe, da zwischen Gro- und Kleinschreibung unterschieden wird.
(69) Frage
vgl. Kapitel 5 Kontrollstrukturen: In der Klammer nach der switch-Anweisung drfen nur folgende Datentypen stehen: char, byte, short, int
und seit dem Tiger-Release auch ein Enum. Steht dort ein long, kommt
es zu einem Kompilierfehler.
(70) Frage
15.2
763
(71) Frage
(72) Frage
764
15
Anhang
A
abstract 73, 76
Abstrakte Klassen 75
Akzessor 59
Anonyme Klassen 530
Api Documentation 64
ArithmeticException 357
Arithmetischer Operator 135
ArrayIndexOutOfBoundsException 357
ArrayList 459
Arrays 241
asList()-Methode 587
Assertions 383
assert-Statement 384
ausfhrbaren Zustand 414
Autoboxing 549
B
Bedingungsoperatoren ?
204
Bezeichner 29
Binres Zahlensystem 169
binarySearch()-Methode 587
Boolean logische Operatoren 148
Boolean-Literale 41
break 216
BufferedReader 665
BufferedWriter 664
Bytestrme 663, 667
C
Calendar 76, 644
Case 216
Casting von Objekten 114
Char-Literale 39
Checked Exceptions 354
ClassCastException 118, 356
ClassNotFoundException 354
Collections-Framework 453
Comparable-Interface 462
Comparator-Interface 462
compile()-Methode 628
D
Daemon-Threads 409
Date 644
DateFormat 644
Datenstrme 662
Debugging 383
default 60
default constructor 61
Default-Fall 216
Defaultwert 39
Dekrement 161
Deserealisierung von Objekten 669
do-while-Schleife 224
E
Eigenschaft 58
eindimensionales Array 241
else-if-Struktur 204
Enums 606
equals()-Methode 487
erweiterte for-Schleife 545
Exceptions 353
extends 93
extends-Beziehung 69
F
false 38, 41
File 663
FileNotFoundException 354
FileReader 665
FileWriter 664
final 61, 83
finalize()-Methode 440
finally-Block 360
findInLine()-Methode 627
Fliekommazahlen 41