Literaturverzeichnis

Literaturverzeichnis
[1]
JavaTM Language Specification (Originaldokumentation in englisch)
http://www.javasoft.com/docs,
http://www.javasoft.com/
books/series/Tutorial und http://www.sun.com
[2]
Java – Einführung, Hubert Partl, Universität für Bodenkultur, Wien, 1998
http://www.boku.ac.at/javaeinf
sehr empfehlenswert
[3]
Einführung in die Programmiersprache Java, Veiko Sinivee, Technische Universität
Ilmenau, 19??
http://remus.prakinf.tu-ilmenau.de/wetter/java/vortrag.
htm
[4]
Einführung in Java, Dr. Norman Hendrich, Universität Hamburg, 1998
http://tech-www.informatik.uni-hamburg.de/javakurs
Folien
1
Java-Schulung
[5]
Java 1.1 lernen, Guido Krüger, Auszüge aus einem Buch erschienen bei AddisonWesley, 1997
http://www.gkrueger.com/books/k97b.html
http://www.addison-wesley.de/Service/book_onl.html
[6]
Programmierpraktikum III: Java, Gerald Ehmayer, Siegfried Reich, 1996
http://cobra.ifs.uni-linz.ac.at/java/scriptum/Script_
dpunkt.fmk.html
knapp, aber mit vielen Beispielen
[7]
Thinking in Java, Bruce Eckel, Prentice Hall, 2nd Ed. 1999
http://www.BruceEckel.com
sehr umfangreich, setzt etliches an Grundkenntnissen voraus
[8]
Das Einsteigerseminar: Java, Frank Knobloch, Michael Seeboerger-Weichselbaum,
bhv Verlag, 1998
ISBN: 3-89360-925-3
[9]
Java 1.1 in 21 Tagen, Laura Lemay, Charles L. Perkins, SAMS, 1997
ISBN: 3-8272-2009-2
c MM
Joachim Lammarsch, Rothenberg
()
2
Java-Schulung
[10] Professionelle Java-Programmierung: Leitfaden für Entwickler, Svend Back et al., Internat. Thomson Publ., 1996
ISBN: 3-8266-0249-8
[11] Die Java Bibel, Aaron Walsh, John Fronckowiak, MITP Verlag, 1998
ISBN: 3-8266-0460-1
sehr umfangreich, für Anfänger nur bedingt geeignet
[12] Java professionell, Gerhard Wilhelms, Markus Kopp, MITP Verlag, 1999
ISBN: 3-8266-0395-8
sehr umfangreich, nur für Fortgeschrittene, Beispiele laufen z. T. nicht
[13] Java Referenz: Komplette Beschreibung aller Klassen inklusive aller Parameter und
Typen, Brian Stark, Franzis-Verlag, 1996
ISBN: 3-7723-4422-4
[14] Java pur: Hintergründe und Entwicklung, Peter van der Linden, Verlag Heinz Heise,
1996
ISBN: 3-88229-086-2
[15] Java an Beispielen: Sprach- und Applet-Struktur, Jerry R. Jackson, Alan L. McClellan,
Verlag Heinz Heise, 1996
ISBN: 3-88229-085-4
c MM
Joachim Lammarsch, Rothenberg
()
3
Java-Schulung
Sonstige Informationsquellen
News-Gruppen (news groups)
• alt.www.hotjava
• comp.compiler.tools.javac
• comp.lang.java.... bspw. comp.lang.java.tools
• de.comp.lang.java deutschsprachig
• microsoft.beta.nashville.sdk.java
• microsoft.public.java.visualj++
• alt.comp.lang.java-games
c MM
Joachim Lammarsch, Rothenberg
()
4
Java-Schulung
WWW-Server
• http://java.cs.uni-magdeburg.de/
• http://www.informatik.uni-freiburg.de/Java/
• http://java.seite.net
• http://www.gamelan.com
• http://www.jars.com
• http://www.acc.de/java
• http://www.nikos.com/javatoys
• http://www.inside-java.com
c MM
Joachim Lammarsch, Rothenberg
()
5
Kapitel 1
Einleitung
1.1
Geschichte
• 1991 – Die Firma SUN formiert ein Team unter dem Codenamen Green Project.
• Die Aufgabe waren Entwicklungsarbeiten für die Zukunftsmärkte Consumer Electronics
und Set-Top-Boxen.
• Ziel war es, kleine Programme über TV-Kanäle zu laden, um Fernsehen interaktiv zu
gestalten.
• Es wurde ein kleines und objektorientiertes System geschaffen, das auf keine HardwarePlattform festgelegt war.
6
Java-Schulung
• Während der Entwicklung stellte sich heraus, daß der geplante Markt nicht schnell genug
wachsen würde.
• Der entwickelte Prototyp fiel in den Bereich der Grundlagenforschung zurück.
• Parallel kam es zur Entwicklung von HTML.
• SUN erkannte, daß nicht nur einzelne TV-Kanäle, sondern auch das Internet ein optimales Transportmedium für kleine Programme bietet.
• Dadurch betrieb das Projekt Green Project keine reine Grundlagenforschung mehr.
• Es wurde ein Konzept für eine Sprache entwickelt, die dem aktuellen Stand des heutigen
Network-Computing entspricht.
• Nach Ankündigung durch SUN Microsystems im Mai 1995 löste Java eine Stimmung
wie beim Goldrausch aus.
• Heute ist Java nicht nur im klassischen EDV-Sektor und im Internet etabliert, es findet
auch immer mehr Anwendung bei den sogenannten kleinen Geräten wie Mobiltelefonen,
Pagern, Set-Top-Boxen für Fernsehgeräte und Handheld-Computern.
c MM
Joachim Lammarsch, Rothenberg
(j000010.tex)
7
Java-Schulung
1.2
Was ist Java?
• Java bietet als Sprache nichts Neues.
• Es verbindet die Vorteile unterschiedlicher Sprachen, wie beispielsweise
– C,
– C++,
– Objective-C und
– Smalltalk
zu einer einzigen Sprache.
• Es verzichtet auf Funktionalität, die nicht benötigt wird.
• Java ist plattformunabhängig.
• Eine virtuelle Maschine ist die Grundlage für die Plattformunabhängigkeit von JavaApplikationen und Java-Applets.
• Die (neue) virtuelle Maschine (VM) HotSpot ist verfügbar und braucht keinen Vergleich
zur Performance anderer Programmiersprachen zu scheuen.
• Java weist Ausdrücken Speicherplatz explizit zu und nimmt ihn zurück, wenn er nicht
mehr benötigt wird (Garbage Collection).
c MM
Joachim Lammarsch, Rothenberg
(j000020.tex)
8
Java-Schulung
1.3
Wie arbeitet Java?
• Java ist eine vollständige und objektorientierte Programmiersprache.
• Es bietet zwei unterschiedliche Arten, Anwendungen zu erstellen:
– Einerseits herkömmliche Applikationen, die über einen Interpreter oder einen Justin-time-Compiler ausgeführt werden.
– Andererseits die Entwicklung von Java-Applets, die durch javafähige Webbrowser
oder spezielle Applet-Viewer gestartet werden.
• Zwei Programme werden im Wesentlichen für Java benötigt:
– Ein Compiler für die Übersetzung der Java-Eingabe.
– Ein Interpreter, der den erzeugten Code interpretiert und in Maschinenanweisungen
umsetzt.
• Mit Java läuft ein Programm unter vielen Betriebssystemen, wie beispielsweise Windows 95, Windows NT, OS/2, Macintosh, Solaris, AIX, Linux etc.
c MM
Joachim Lammarsch, Rothenberg
(j000030.tex)
9
Java-Schulung
1.4
Einführungsbeispiel 1
public class beisp01
{
public static void main(String args[])
{
System.out.println("Viel Erfolg mit Java!");
System.exit(0);
}
}
ergibt als Ausgabe am Bildschirm:
Viel Erfolg mit Java!
c MM
Joachim Lammarsch, Rothenberg
(j000040.tex)
10
Java-Schulung
public class beisp01
{
public static void main(String args[])
{
System.out.println("Viel Erfolg mit Java!");
System.exit(0);
}
}
• Ein Java-Programm besteht aus einer Menge von Klassendefinitionen.
• Jede Klasse steht in einer separaten Datei.
• Der Namen der Datei muß identisch dem Namen der Klasse sein.
• Mindestens eine Klasse muss public sein.
• Alle zur Klasse gehörenden Attribute und Methoden werden in geschweiften Klammern
eingeschlossen.
c MM
Joachim Lammarsch, Rothenberg
(j000040.tex)
11
Java-Schulung
public class beisp01
{
public static void main(String args[])
{
System.out.println("Viel Erfolg mit Java!");
System.exit(0);
}
}
• Um die Klasse durch einen Interpreter ausführen zu können, muß innerhalb dieser Klasse
eine Methode der Form public static void main (String argv[]) deklariert werden.
• Die zur Methode gehörenden Befehle werden in geschweiften Klammern eingeschlossen.
c MM
Joachim Lammarsch, Rothenberg
(j000040.tex)
12
Java-Schulung
public class beisp01
{
public static void main(String args[])
{
System.out.println("Viel Erfolg mit Java!");
System.exit(0);
}
}
• System.out.println() gibt eine Zeichenkette auf der Standardausgabe aus.
• Eine Zeichenkette ist eine Folge von Zeichen, die in Anführungszeichen eingeschlossen
ist.
• System.exit() beendet das Programm und gibt einen Return code ans Betriebssystem zurück.
• Alle Befehle müssen mit einem Semikolon beendet werden.
c MM
Joachim Lammarsch, Rothenberg
(j000040.tex)
13
Java-Schulung
1.5
Einführungsbeispiel 1b
public class beisp01b
{
public static void main(String args[])
{
System.out.println("Hallo, \n" +
"Viel Erfolg mit Java!");
System.exit(0);
}
}
ergibt als Ausgabe am Bildschirm:
Hallo,
Viel Erfolg mit Java!
c MM
Joachim Lammarsch, Rothenberg
(j000041.tex)
14
Java-Schulung
public class beisp01b
{
public static void main(String args[])
{
System.out.println("Hallo, \n" +
"Viel Erfolg mit Java!");
System.exit(0);
}
}
• Die Ausgabe in zwei Zeilen wird durch \n erreicht.
• Durch den Befehl + werden zwei Zeichenketten verkettet.
c MM
Joachim Lammarsch, Rothenberg
(j000041.tex)
15
Java-Schulung
1.6
Einführungsbeispiel 1c
public class beisp01c
{
public static void main(String args[])
{
System.out.println("********************************\n"
"*
*\n"
"* Hallo, viel Erfolg mit Java! *\n"
"*
*\n"
"********************************");
System.exit(0);
}
}
c MM
Joachim Lammarsch, Rothenberg
(j000042.tex)
+
+
+
+
16
Java-Schulung
ergibt als Ausgabe am Bildschirm:
********************************
*
*
* Hallo, viel Erfolg mit Java! *
*
*
********************************
• Leerzeichen innerhalb von Zeichenketten sind signifikant und werden genauso in die
Ausgabe übernommen.
• Leerzeichen innerhalb des Programm-Codes werden nicht übernommen.
c MM
Joachim Lammarsch, Rothenberg
(j000042.tex)
17
Java-Schulung
1.7
Der Zeichensatz
Für ein Zeichen werden zwei Bytes im Speicher belegt.
Es gibt folgende Zeichen:
1. Klein- und Großbuchstaben:
a b c . . . z und A B C . . . Z
2. Alle Zeichen oberhalb hexadezimal 00C0 werden ebenfalls als Buchstaben akzeptiert
(Unicode-Zeichensatz).
3. Ziffern:
0 1 2 ... 9
4. Unterstreichungsstrich:
_ (für Variablennamen)
5. „Backslash“:
\ (Fluchtsymbol, Maskierungszeichen)
6. Sonderzeichen:
[]{}()<>!%ˆ&*+−=:;,."?|~
c MM
Joachim Lammarsch, Rothenberg
(j000050.tex)
18
Java-Schulung
1.8
Besondere Zeichen- und Zeichenkettenobjekte
Besondere Zeichen- und Zeichenkettenobjekte werden auch als „escape character“ bezeichnet.
Bedeutung
Neue Zeile
Tabulator
Löschtaste
Zeilenvorschub
Seitenvorschub
Maskierungszeichen
Hochkomma (einfach)
Anführungszeichen
Oktal
Hexadezimal
Unicode
c MM
Wert
NL
HT
BS
CR
FF
\
’
"
0ddd
0xdd
Darstellung
\n
\t
\b
\r
\f
\\
\’
\"
\[0-7][0-7][0-7]
\x[0-9,A-F][0-9,A-F]
\x[0-9,a-f][0-9,a-f]
0xdddd \u[0-9,A-F][0-9,A-F][0-9,A-F][0-9,A-F]
\u[0-9a-f][0-9a-f][0-9a-f][0-9a-f]
Joachim Lammarsch, Rothenberg
(j000051.tex)
19
Java-Schulung
1.9
Einführungsbeispiel 2
/* Länge des Marathonlaufs in Kilometer */
public class beisp02
{
public static void main(String args[])
{
int meilen,yards;
double kilometer;
meilen=26;
yards=385;
kilometer=1.609*(meilen+yards/1760.0);
System.out.print("Die Länge des Marathonlaufs beträgt ");
System.out.print(kilometer);
System.out.println(" km.");
System.exit(0);
}
}
c MM
Joachim Lammarsch, Rothenberg
(j000060.tex)
20
Java-Schulung
ergibt als Ausgabe am Bildschirm:
Die Länge des Marathonlaufs beträgt 42.18596875 km.
c MM
Joachim Lammarsch, Rothenberg
(j000060.tex)
21
Java-Schulung
/* Länge des Marathonlaufs in Kilometer */
public class beisp02
{
public static void main(String args[])
{
int meilen,yards;
double kilometer;
...
• Ein Blockkommentar wird durch die Zeichen /* und */ begrenzt.
• Durch den Befehl int werden die Variablen meilen und yards für ganze Zahlen
deklariert.
• Durch den Befehl double wird die Variable kilometer für eine Gleitkommazahl
(Gleitpunktzahl) deklariert.
c MM
Joachim Lammarsch, Rothenberg
(j000060.tex)
22
Java-Schulung
...
meilen=26;
yards=385;
kilometer=1.609*(meilen+yards/1760.0);
...
• Das Gleichheitszeichen ist der Zuweisungsoperator. Den Variablen auf der linken Seite
wird die Konstante auf der rechten Seite zugewiesen.
• Der arithmetische Ausdruck auf der rechten Seite des Zuweisungsoperators wird bestimmt und der Variablen auf der linken Seite zugewiesen.
• Die Operatoren *, +, / stehen für Multiplikation, Addition und Division.
• In runden Klammern eingeschlossene Operationen werden zuerst ausgeführt; es gelten
die üblichen Rechenregeln der Mathematik (Punkt vor Strich).
c MM
Joachim Lammarsch, Rothenberg
(j000060.tex)
23
Java-Schulung
...
System.out.print("Die Länge des Marathonlaufs beträgt ");
System.out.print(kilometer);
System.out.println(" km.");
System.exit(0);
}
}
...
• System.out.print("Die Länge...") gibt die Zeichenkette auf der Standardausgabe ohne Zeilenvorschub aus.
• System.out.print(kilometer) gibt ebenso die Gleitkommazahl auf der Standardausgabe ohne Zeilenvorschub aus.
• System.out.println(" km.") gibt wiederum die Zeichenkette auf der Standardausgabe dieses Mal mit Zeilenvorschub aus.
• Leerzeichen werden nicht automatisch eingefügt.
c MM
Joachim Lammarsch, Rothenberg
(j000060.tex)
24
Java-Schulung
1.10
Einführungsbeispiel 2b
/* Länge des Marathonlaufs in Kilometer */
public class beisp02b
{
public static void main(String args[])
{
int meilen,yards;
double kilometer;
meilen=26;
yards=385;
kilometer=1.609*(meilen+yards/1760.0);
System.out.println("Die Länge des Marathonlaufs " +
"beträgt " + kilometer + " km.");
System.exit(0);
}
}
c MM
Joachim Lammarsch, Rothenberg
(j000062.tex)
25
Java-Schulung
ergibt als Ausgabe am Bildschirm:
Die Länge des Marathonlaufs beträgt 42.18596875 km.
c MM
Joachim Lammarsch, Rothenberg
(j000062.tex)
26
Java-Schulung
...
System.out.println("Die Länge des Marathonlaufs " +
"beträgt " + kilometer + " km.");
System.exit(0);
}
}
...
• System.out.println() gibt eine einzige Zeichenkette auf der Standardausgabe
mit Zeilenvorschub aus.
• Mehrere Zeichenketten können mit + hintereinander gehängt werden – das Plus-Zeichen
hat hier eine andere Bedeutung als Addieren.
• Der Wert der Variablen kilometer wird von Java automatisch in eine Zeichenkette
umgewandelt.
c MM
Joachim Lammarsch, Rothenberg
(j000062.tex)
27
Java-Schulung
1.11
Bearbeitung eines Java-Programms
Editieren
edit/vi dateiname.java
Eingabe
?
JAVA -C OMPILER
Compilieren
javac dateiname.java
?
Klasse
dateiname.class
Klasse
?
JAVA -I NTERPRETER
Byte-Code ausführen
java dateiname
?
Ausgabe
c MM
Joachim Lammarsch, Rothenberg
(jcompile.tex)
28
Teil I
Prozedurale Programmierung mit Java
29
Kapitel 2
Bezeichner, Variablen, Kommentare
2.1
Bezeichner
Bezeichner (d. h. Namen) für Variablen, Methoden und Klassen sind in ihrem Aufbau an die
Programmiersprachen C und C++ angelehnt.
Erlaubt sind
• Groß- und Kleinbuchstaben,
• Ziffern (0, 1, 2, 3, 4, 5, 6, 7, 8, 9),
• Unterstreichungsstrich (_),
• Dollar-Zeichen ($) und
30
Java-Schulung
• alle Zeichen des Unicode-Zeichensatzes oberhalb 00C0
als Bestandteile von Bezeichnern. Das erste Zeichen darf keine Ziffer sein und das DollarZeichen ($) darf nur am Anfang stehen.
c MM
Joachim Lammarsch, Rothenberg
(jcompile.tex)
31
Java-Schulung
2.2
Variablen
Variablen werden deklariert, indem man ihren Datentyp und ihren Namen angibt:
Syntax:
datentyp variablenname
bzw.
datentyp variablenname_1, variablenname_2, ...
Beispiel:
int var_1;
int var_2, var_3;
double var_4;
• Die Deklaration ist an unterschiedlichen Stellen im Programm möglich. Sie wird jedoch
in der Regel zu Beginn eines Blocks vorgenommen.
• Die Reichweite einer Variablen beginnt bei ihrer Deklaration und endet am Ende des
Blocks, in dem sie deklariert wurde.
c MM
Joachim Lammarsch, Rothenberg
(jcompile.tex)
32
Java-Schulung
2.2.1 Initialisierung von Variablen
Eine Variable kann bei ihrer Deklaration direkt mit einem Wert initialisiert werden.
Beispiel:
int i=17;
double d=3.14159;
c MM
Joachim Lammarsch, Rothenberg
(j000082.tex)
33
Java-Schulung
2.2.2 Schlüsselworte
Java definiert eine Reihe von Schlüsselworten, die man nicht als eigene Variablennamen verwenden darf:
abstract
boolean
cast
catch
default
do
final
finally
goto
if
int
interface
operator
outer
rest
return
synchronized this
true
try
c MM
Joachim Lammarsch, Rothenberg
(j000082.tex)
break
char
double
float
implements
long
package
short
threadsafe
var
byte
byvalue
class
const
else
extends
for
future
import inner
native new
private protected
static
super
throw throws
void
volatile
case
continue
false
generic
instanceof
null
public
switch
transient
while
34
Java-Schulung
2.3
Kommentare
Kommentare dienen der besseren Übersichtlichkeit und bieten eine gewisse Sicherheit dafür,
daß der Programmquellcode auch nach längerer Zeit vom Programmierer verstanden werden
kann.
Java bietet drei Alternativen Kommentare zu erstellen:
• Zeilenkommentare,
• Blockkommentare,
• HTML-Kommentare, die in die Dokumentation, die mit dem Kommando javadoc generiert wird, übernommen werden sollen.
c MM
Joachim Lammarsch, Rothenberg
(j000084.tex)
35
Java-Schulung
2.3.1 Zeilenkommentare
Zeilenkommentare erlauben die Eingabe eines Kommentars bis an das Zeilenende.
Der Kommentar wird durch den Befehl // eingeleitet, das Ende ist das Zeilenende.
Zeilenkommentare sind hilfreich, wenn lediglich kurze Anmerkungen zum Programmcode
gemacht werden sollen.
Beispiel:
// Länge eines Marathonlaufs in Kilometer
...
c MM
Joachim Lammarsch, Rothenberg
(j000084.tex)
36
Java-Schulung
2.3.2 Blockkommentare
Diese Variante ist der Programmiersprache C entliehen. Die Kommentare können beliebig
lang sein.
Der Kommentar wird durch die Befehle /* und */ eingeschlossen.
Nach Beginn des Kommentars durch /* kann jedes beliebige Zeichen folgen. Nur das Zeichen * bildet eine Ausnahme (siehe dazu HTML-Kommentare). Der Kommentar endet erst
wieder mit der Zeichenfolge */.
Kommentare dieser Form dürfen keine Kommentare der gleichen Form enthalten, während
andere Kommentarzeichen nicht als solche behandelt werden.
Beispiel:
/* Ziel dieses Kommentars ist es, die Anwendung eines
Blockkommentars zu demonstrieren. */
...
c MM
Joachim Lammarsch, Rothenberg
(j000084.tex)
37
Java-Schulung
2.3.3 HTML-Kommentare
Das Verbot des Zeichens * nach dem Einleiten des Kommentars hat eine besondere Bedeutung. Hierdurch wird eine Art von Kommentar eingeleitet, der zur Generierung einer automatischen Dokumentation mittels javadoc verwendet wird. javadoc überprüft den Quellcode auf das Vorhandensein des Dokumentationskommentars (/**) und generiert daraus eine
Dokumentation im HTML-Format.
public class test6
{
/**
Dieser Kommentar ist für die HTML-Dokumentation.
Ziel ist die Darstellung eines HTML-Kommentars.
*/
public static void main(String args[])
{
}
}
c MM
Joachim Lammarsch, Rothenberg
(j000084.tex)
38
Java-Schulung
Class test6
java.lang.Object
|
+----test6
public class test6
extends Object
Constructor Index
o test6()
Method Index
o main(String[])
Dieser Kommentar ist fuer die HTML-Dokumention.
Constructors
o test6
public test6()
Methods
o main
public static void main(String args[])
Dieser Kommentar ist fuer die HTML-Dokumention. Ziel ist die Darstellung eines
HTML-Kommentars.
c MM
Joachim Lammarsch, Rothenberg
(j000084.tex)
39
Kapitel 3
Datentypen und Konstanten
3.1
Datentypen
In Java unterscheidet man einfache und zusammengesetzte Datentypen. Einfache Datentypen sind Zahlen, Zeichen, Wahrheitswerte – zusammengesetzte sind Zeichenketten, Felder,
Klassen. Die verschiedenen Datentypen benötigen unterschiedlichen Speicherplatz.
Die Datentypen sind denen von C und C++ sehr ähnlich, es gibt aber einige wichtige Unterschiede:
• alle Datentypen sind auf jedem Computer von konstanter Größe,
• alle numerischen Variablen sind vorzeichenbehaftet,
• beliebige automatische Typumwandlungen sind nicht möglich.
40
Java-Schulung
3.1.1 Ganze Zahlen
1. byte
Größe: 8 bit (1 Byte),
Bereich: −128 bis 127
2. short
Größe: 16 bit (2 Byte),
Bereich: −32 768 bis 32 767
3. int
Größe: 32 bit (4 Byte),
Bereich: −2 147 483 648 bis 2 147 483 647
4. long
Größe: 64 bit (8 Byte),
Bereich: −9 223 372 036 854 775 808 bis 9 223 372 036 854 775 807
c MM
Joachim Lammarsch, Rothenberg
(j000070.tex)
41
Java-Schulung
Den Zahlenbereich erhält man, wenn man die Werte der Konstanten ausgibt:
Byte.MIN_VALUE
Byte.MAX_VALUE
Short.MIN_VALUE
Short.MAX_VALUE
Integer.MIN_VALUE
Integer.MAX_VALUE
Long.MIN_VALUE
Long.MAX_VALUE
c MM
Joachim Lammarsch, Rothenberg
(j000070.tex)
42
Java-Schulung
Beispiel:
public class Lim_gz
{
public static void main(String args[])
{
System.out.println(Byte.MIN_VALUE + ", " +
Byte.MAX_VALUE);
System.out.println(Short.MIN_VALUE + ", " +
Short.MAX_VALUE);
System.out.println(Integer.MIN_VALUE + ", " +
Integer.MAX_VALUE);
System.out.println(Long.MIN_VALUE + ", " +
Long.MAX_VALUE);
System.exit(0);
}
}
c MM
Joachim Lammarsch, Rothenberg
(j000070.tex)
43
Java-Schulung
Als Ausgabe erhält man:
-128, 127
-32768, 32767
-2147483648, 2147483647
-9223372036854775808, 9223372036854775807
c MM
Joachim Lammarsch, Rothenberg
(j000070.tex)
44
Java-Schulung
Ganze Zahlen sind exakt und intern im binären Datenformat gespeichert.
Beispiel:
public class Conv001
{
public static void main(String args[])
{
int i = 1234;
System.out.println("Dezimal:
" + i);
System.out.println("Binär:
" +
Integer.toBinaryString(i));
System.out.println("Oktal:
" +
Integer.toOctalString(i));
System.out.println("Hexadezimal: " +
Integer.toHexString(i));
System.exit(0);
}
}
c MM
Joachim Lammarsch, Rothenberg
(j000070.tex)
45
Java-Schulung
Als Ausgabe erhält man:
Dezimal:
Binär:
Oktal:
Hexadezimal:
c MM
1234
10011010010
2322
4d2
Joachim Lammarsch, Rothenberg
(j000070.tex)
46
Java-Schulung
3.1.2 Gleitkomma-Zahlen (Gleitpunkt-Zahlen)
1. float
Größe: 32 bit (4 Byte)
Bereich: 1, 4 · 10−45 bis 3, 4 · 1038
Genauigkeit: 6 Dezimalstellen
2. double
Größe: 64 bit (8 Byte),
Bereich: 4, 9 · 10−324 bis 1.7 · 10308
Genauigkeit: 15 Dezimalstellen
• Gleitkommazahlen sind in der Regel mit Darstellungsfehlern behaftet.
• Beim Rechnen mit Gleitkommazahlen ergeben sich Rundungsfehler.
• Gleitkommazahlen werden im Standard IEEE 754-Format im Rechner gespeichert.
Den Zahlenbereich erhält man, wenn man die Werte der Konstanten ausgibt:
Float.MIN_VALUE
Float.MAX_VALUE
Double.MIN_VALUE
Double.MAX_VALUE
c MM
Joachim Lammarsch, Rothenberg
(j000070.tex)
47
Java-Schulung
Beispiel:
public class Lim_gl
{
public static void main(String args[])
{
System.out.println(Float.MIN_VALUE + ", " +
Float.MAX_VALUE);
System.out.println(Double.MIN_VALUE + ", " +
Double.MAX_VALUE);
System.exit(0);
}
}
Als Ausgabe erhält man:
1.4E-45, 3.4028235E38
4.9E-324, 1.7976931348623157E308
c MM
Joachim Lammarsch, Rothenberg
(j000070.tex)
48
Java-Schulung
3.1.3 Boolsche Zahlen
boolean
Größe: 8 bit (1 Byte),
Bereich: true und false
Es werden ihnen keine Zahlen zugeordnet, wie beispielsweise Null (0) für false oder
„jeder Wert ungleich Null“ für true. Sie können auch nicht in andere Datentypen umgewandelt werden.
3.1.4 Zeichen
char
Größe: 16 bit (2 Byte),
Java verwendet den Unicode zur Zeichendarstellung (http://unicode.com).
c MM
Joachim Lammarsch, Rothenberg
(j000070.tex)
49
Java-Schulung
3.2
Datentyp-Umwandlungen
Typ-Umwandlungen wandeln einen Datentyp in einen anderen um. Diesen Vorgang bezeichnet man als Casting.
Syntax:
(datentyp) ausdruck
Beispiel:
int a=1, b=2; float f;
f = (float) a / (float) b;
Außer dem expliziten Casting gibt es noch das implizite Casting, bei dem der Compiler selbst
den Datentyp konvertiert. Auch hierbei kann es zu unerwünschten Seiteneffekten kommen.
Java ist restriktiv in bezug auf die Konvertierung von Werten eines Datentyps in einen anderen.
c MM
Joachim Lammarsch, Rothenberg
(j000096.tex)
50
Java-Schulung
3.2.1 Aufwand für Konvertierungen
Datentyp
byte
short
von char
int
long
float
double
byte
0
A
B
C
D
G
H
short
1
0
A
B
C
F
G
nach
char
int
2
3
A
1
0
1
A
0
B
A
E
D
F
E
long
4
2
2
1
0
C
D
float
7
5
5
4
3
0
A
double
8
6
6
5
4
1
0
• Bei den Kombinationen, die durch Buchstaben gekennzeichnet sind, geht bei der Konvertierung Information verloren. Diese Konvertierungen müssen mit dem cast-Operator
erzwungen werden.
• Bei der Konvertierung wird immer die Kombination gewählt, die den geringsten Aufwand erfordert.
c MM
Joachim Lammarsch, Rothenberg
(j000096.tex)
51
Java-Schulung
Beispiel:
public class cast01
{
public static void main(String args[])
{
int i=1,j=2;
System.out.println(1/2 + "
" + 1./2.);
System.out.println(i/j + "
" + (float)i/(float)j);
System.out.println((float)1/(float)2);
System.exit(0);
}
}
Als Ausgabe erhält man:
0
0.5
0
0.5
0.5
c MM
Joachim Lammarsch, Rothenberg
(j000096.tex)
52
Java-Schulung
3.3
Literale
Literale (Konstanten) dienen zum Bezeichnen einfacher Werte in einem Java-Programm.
Obwohl sie meist selbsterklärend sind, gibt es innerhalb von Java einige Besonderheiten für
die unterschiedlichen Arten von
• Ganzzahligen Konstanten,
• Gleitkomma-Konstanten,
• Zeichen-Konstanten,
• Zeichenketten-Konstanten,
• Boolschen Konstanten.
c MM
Joachim Lammarsch, Rothenberg
(j000072.tex)
53
Java-Schulung
3.3.1 Ganzzahlige Konstanten
• Sie sind standardmäßig vom Datentyp int.
• Eine Konstante wird automatisch zum Datentyp long, wenn sie für den Datentyp int
zu groß ist.
• Den Datentyp long kann man immer erhalten, wenn man an die Zahl ein L oder l
anhängt.
• Ganzzahlige Konstanten kann man auch oktal bzw. hexadezimal ausdrücken. Eine führende 0 zeigt an, daß eine Zahl oktal ist. Ein vorangestelltes 0x oder 0X bedeutet, daß
es sich um eine Hexadezimalzahl handelt.
Beispiel:
1234
5000000000
1234L
0777
0xAD3F
c MM
Joachim Lammarsch, Rothenberg
//
//
//
//
//
(j000072.tex)
int
long
long
oktal
hexadezimal
54
Java-Schulung
3.3.2 Gleitkomma-Konstanten
• Als Gleitkomma-Konstanten werden, – dem Standard IEEE 754 gemäß – Werte mit
einfacher (float) und doppelter Genauigkeit (double) angeboten.
• Sie sind standardmäßig vom Datentyp double.
• Gleitkommazahlen können mit einem Suffix f bzw. F für float und d bzw. D für
double gekennzeichnet werden.
• Es existiert der Wert -0.0 (negative Null), der entweder durch Initialisierung oder durch
besondere Umstände erreicht werden kann. Multiplikation und Division durch -0.0
ergeben wieder -0.0. Bei anderen Operationen verhält sich -0.0 wie 0.0
Beispiel:
1234.45
1234.45f
1234.45d
1234.45E-67
c MM
Joachim Lammarsch, Rothenberg
//
//
//
//
(j000072.tex)
doppelt genau
einfach genau
doppelt genau
mit Exponent
55
Java-Schulung
3.3.3 Zeichen-Konstanten
• Zeichen-Konstanten sind einzelne Zeichen, die in einfache Hochkommata eingeschlossen werden.
• Sie sind standardmäßig vom Datentype char.
• Java verwendet Unicode zur Zeichendarstellung.
Beispiel:
’a’
’ ’
’0’
c MM
Joachim Lammarsch, Rothenberg
// Ein Zeichen
// Ein Leerzeichen
// Das Zeichen Null
(j000072.tex)
56
Java-Schulung
3.3.4 Zeichenketten-Konstanten
• Mehrere Zeichen zusammen bilden eine Zeichenkette.
• Sie werden in doppelte Hochkommata eingeschlossen.
• Sie können Konstanten wie neue Zeile, Tabulator- und Unicode-Zeichen enthalten.
Beispiel:
"Ich bin eine Zeichenkette."
""
"\n"
c MM
Joachim Lammarsch, Rothenberg
(j000072.tex)
// Zeichenkette
// Leere Zeichenkette
// Neue Zeile
57
Java-Schulung
3.3.5 Boolsche Konstanten
• Boolsche Konstanten sind true und false.
• Sie werden bei den Operatoren
– Gleichheit und Ungleichheit sowie bei
– Konjunktion, Disjunktion und Negation
verwendet
• Sie sind die einzig möglichen Werte für boolsche Variablen.
Beispiel:
true
false
c MM
Joachim Lammarsch, Rothenberg
// wahr
// falsch
(j000072.tex)
58
Java-Schulung
3.4
Parameter bei main
Um auf die Parameter der Methode main() zuzugreifen, muß man den Namen args verwenden. Es ist bei jeder Methode main deklariert.
Im Gegensatz zu C/C++ ist args[0] nicht der Programmname, sondern der erste Parameter.
• Den ersten Parameter erhält man durch args[0],
• den zweiten Parameter durch args[1].
• ...
Beispiel:
public class bspargs_a
{
public static void main(String args[])
{
System.out.println("1. Parameter: " + args[0]);
System.out.println("2. Parameter: " + args[1]);
System.exit(0);
}
}
c MM
Joachim Lammarsch, Rothenberg
(j000140.tex)
59
Java-Schulung
ergibt bei dem Aufruf
java bspargs_a 1.1111 2.2222
als Ausgabe am Bildschirm:
1. Parameter:
2. Parameter:
1.1111
2.2222
3.4.1 Konvertierung der Zeichenketten args[n]
Der Wert, den man durch args[n] erhält, ist eine Zeichenkette, die zur weiteren arithmetischen Bearbeitung in einen geeigneten Datentyp konvertiert werden muß.
Hierfür gibt es eigene Methoden wie beispielsweise:
byte
short
int
long
float
double
char
c MM
Byte.valueOf(args[n]).byteValue()
Short.valueOf(args[n]).shortValue()
Integer.valueOf(args[n]).intValue()
Long.valueOf(args[n]).longValue()
Float.valueOf(args[n]).floatValue()
Double.valueOf(args[n]).doubleValue()
args[n].charAt(0)
Joachim Lammarsch, Rothenberg
(j000140.tex)
60
Java-Schulung
Beispiel:
public class bspargs_c
{
public static void main(String args[])
{
int v1, v2;
v1 = Integer.valueOf(args[0]).intValue();
v2 = Integer.valueOf(args[1]).intValue();
System.out.println(v1+v2);
System.exit(0);
}
}
ergibt bei dem Aufruf
java bspargs_c 1 2
als Ausgabe am Bildschirm:
3
c MM
Joachim Lammarsch, Rothenberg
(j000140.tex)
61
Java-Schulung
Beispiel:
public class bspargs_b
{
public static void main(String args[])
{
double v1, v2;
v1 = Double.valueOf(args[0]).doubleValue();
v2 = Double.valueOf(args[1]).doubleValue();
System.out.println(v1+v2);
System.exit(0);
}
}
ergibt bei dem Aufruf
java bspargs_b 1.1111 2.2222
als Ausgabe am Bildschirm:
3.3333
c MM
Joachim Lammarsch, Rothenberg
(j000140.tex)
62
Kapitel 4
Operatoren
4.1
Zuweisungsoperator (=)
Syntax:
variable = ausdruck
• Der Variablen auf der linken Seite des Zuweisungsoperators wird der Wert zugewiesen,
den der Ausdruck auf der rechten Seite liefert.
• Der Ausdruck wird vollständig ausgewertet, bevor die Zuweisung durchgeführt wird.
63
Java-Schulung
Beispiel:
x = a + b;
y = y + 25;
z = 2 * (a + b);
• Da ein Zuweisungsoperator einen Wert ergibt, kann man Zuweisungsoperatoren verketten.
Beispiel:
x = y = z = 100;
• Der Zuweisungsoperator ist kein mathematisches Gleichheitszeichen.
c MM
Joachim Lammarsch, Rothenberg
(j000100.tex)
64
Java-Schulung
4.2
Arithmetische Operatoren
Java besitzt fünf Operatoren für die Arithmetik:
+
*
/
%
Addition
Subtraktion
Multiplikation
Division
Modulus
3
9
7
9
9
+
*
/
%
4
6
8
2
4
• Jeder Operator besitzt zwei Operanden, je einen auf jeder Seite des Operators.
• Der Subtraktionsoperator kann auch zum Negieren eines einzelnen Operanden benutzt
werden.
• Die Division einer ganzen Zahl durch eine ganze Zahl ergibt wiederum eine ganze Zahl.
• Der Modulus gibt den Divisionsrest einer ganzzahligen Division. Beispielsweise ergibt
33 % 9 die Zahl 6, da 9 in 33 dreimal enthalten ist und den Rest 6 ergibt.
c MM
Joachim Lammarsch, Rothenberg
(j000110.tex)
65
Java-Schulung
Beispiel:
public class beisp04
{
public static void main(String args[])
{
int var_1=50, var_2=20,
var_3, var_4, var_5, var_6;
var_3 = var_1 + var_2;
var_4 = var_1 - var_2;
var_5 = var_1 * var_2;
var_6 = var_1 / var_2;
System.out.println(var_3 + " " + var_4 + " " +
var_5 + " " + var_6);
System.exit(0);
}
}
Als Ausgabe erhält man:
70 30 1000 2
c MM
Joachim Lammarsch, Rothenberg
(j000110.tex)
66
Java-Schulung
• Alle arithmetischen ganzzahligen Operationen werden mit 32 Bit Genauigkeit ausgeführt, im Falle langer ganzen Zahlen long mit 64 Bit.
• Möchte man ein ganzzahliges 32- oder 64-Bit-Ergebnis in eine kleinere Variable abspeichern, muß es in den entsprechenden Datentyp konvertiert werden.
• byte- und short-Zuweisungen müssen immer angepaßt werden, wenn sie das Ergebnis einer arithmetischen Operation sind.
Beispiel:
byte a, b=2, c=100;
a = (byte) (b + c);
• Ist das Ergebnis zu groß, werden nur die niederwertigen Bits gespeichert, d. h. die Ganzzahl-Arithmetik ist in Wirklichkeit eine Modulo-2n -Arithmetik.
• Ein Fehler wird nur bei Division durch Null angezeigt.
c MM
Joachim Lammarsch, Rothenberg
(j000110.tex)
67
Java-Schulung
4.2.1 Arithmetik von Gleitkommazahlen
• Die Operationen sind Addition, Subtraktion, Multiplikation und Division.
• Eine Division durch Null ergibt keinen Fehler.
Beispiel:
public class beisp03
{
public static void main(String args[])
{
float a=3.14F, b=0.0F, c=-3.14F;
System.out.println(a/b);
System.out.println(b/b);
System.out.println(c/b);
}
}
Als Ausgabe erhält man:
Infinity
NaN
-Infinity
c MM
Joachim Lammarsch, Rothenberg
(j000110.tex)
68
Java-Schulung
4.2.2 Verkürzte Schreibweisen
Java unterstützt ebenfalls die Kurzschreibweise arithmetischer Ausdrücke. Da relativ oft die
Form
operand1 = operand1 operator operand2
auftritt, wird vorzugsweise die verkürzte Schreibweise
operand1
operator =
operand2
eingesetzt.
Angewendet wird diese Schreibweise bei folgenden Operatoren:
Symbol
+
*
/
%
c MM
Operation
Addition
Subtraktion
Multiplikation
Division
Modulus
Joachim Lammarsch, Rothenberg
(j000120.tex)
Kurzform
n += 10
n -= 10
n *= 10
n /= 10
n %= 10
n
n
n
n
n
Langform
= n + 10
= n - 10
= n * 10
= n / 10
= n % 10
69
Java-Schulung
4.2.3 Inkrement- und Dekrement-Operatoren
Java unterstützt wie C bzw. C++ die Inkrementierung und Dekrementierung von Variablen.
Da relativ oft die Form
operand = operand + 1;
bzw.
operand = operand - 1;
auftritt, wird die verkürzte Schreibweise
operand ++;
oder
++ operand;
operand --;
oder
-- operand;
bzw.
benutzt.
• Diese Operatoren können auch bei Gleitkommazahlen verwendet werden.
• Die Operatoren können vorangestellt oder auch angefügt werden, wenn es sich um einfache Inkrement- oder Dekrement-Operationen handelt.
• In Kombination mit anderen Operationen ergibt sich allerdings bei der Auswertung ein
Unterschied.
c MM
Joachim Lammarsch, Rothenberg
(j000120.tex)
70
Java-Schulung
4.2.4 Prefix- und Postfix-Operatoren
Wird der Befehl ++ bzw. -- vorangestellt, wird zuerst diese Operation ausgeführt, anschließend die andere Operation.
Wird der Befehl ++ bzw. -- nachgestellt, wird zuerst die andere Operation ausgeführt, anschließend das Inkrement bzw. Dekrement.
Beispiel:
x=++i;
y=--j;
wird wie folgt ausgeführt:
i=i+1;
x=i;
j=j-1;
y=j;
Beispiel:
x=i++;
y=j--;
wird wie folgt ausgeführt:
x=i;
i=i+1;
c MM
Joachim Lammarsch, Rothenberg
y=j;
j=j-1;
(j000120.tex)
71
Java-Schulung
Beispiel:
public class oper01
{
public static void main(String args[])
{
int var_1=10, var_2=20;
float var_3=5.4321F, var_4=1.2345F;
var_1 *= var_2;
System.out.println("var_1:
var_2++;
System.out.println("var_2:
var_3--;
System.out.println("var_3:
var_3 = ++var_4;
System.out.println("var_4:
" + var_1);
" + var_2);
" + var_3);
" + var_4);
System.exit(0);
}
}
c MM
Joachim Lammarsch, Rothenberg
(j000120.tex)
72
Java-Schulung
Als Ausgabe erhält man:
var_1:
var_2:
var_3:
var_4:
c MM
200
21
4.4321
2.2345
Joachim Lammarsch, Rothenberg
(j000120.tex)
73
Java-Schulung
4.3
Vergleichsoperatoren
• Java stellt mehrere Ausdrücke zum Testen von Gleichheit und Größe zur Verfügung
• Alle diese Ausdrücke geben einen boolschen Wert (true oder false) zurück.
• Die Vergleichsoperatoren sind:
Operator
==
!=
<
>
<=
>=
4.4
Bedeutung
Gleich
Ungleich
Kleiner als
Größer als
Kleiner als oder gleich
Größer als oder gleich
Beispiel
a == 10
a != 10
a < 10
a > 10
a <= 10
a >= 10
Logische Operatoren
• Boolsche Ausdrücke können entweder wahr (true) oder falsch (false) sein.
• Sie sind keine Zahlen und man darf ihnen auch keine Zahlen zuweisen.
• Die logischen Operatoren sind:
c MM
Joachim Lammarsch, Rothenberg
(j000150.tex)
74
Java-Schulung
Operator
&&
||
!
&
|
^
Bedeutung
Und
Oder
Negation
logisches Und
logisches Oder
logisches Exklusiv-Oder
• Für Und-Verknüpfungen wird && und & verwendet. Mit & werden beide Seiten des Ausdrucks ungeachtet des Ergebnisses ausgewertet. Mit && wird der ganze Ausdruck als
falsch angenommen, wenn die linke Seite falsch ist.
• Für Oder-Verknüpfungen wird || und | verwendet. Mit | werden beide Seiten des
Ausdrucks ungeachtet des Ergebnisses ausgewertet. Mit || wird der ganze Ausdruck
als wahr angenommen, wenn die linke Seite wahr ist.
c MM
Joachim Lammarsch, Rothenberg (j000150.tex)
75
Java-Schulung
4.4.1 Wahrheitstafeln
4.4.1.1 Und-Operator (&& und &)
Operand 1
wahr
wahr
falsch
falsch
Operand 2
wahr
falsch
wahr
falsch
Ergebnis
wahr
falsch
falsch
falsch
• Der Ausdruck ist nur dann wahr, wenn beide Operanden auf beiden Seiten des Operators
wahr sind.
• Ist ein Operand falsch, ist der gesamte Ausdruck falsch.
c MM
Joachim Lammarsch, Rothenberg
(j000150.tex)
76
Java-Schulung
4.4.1.2 Oder-Operator (|| und |)
Operand 1
wahr
wahr
falsch
falsch
Operand 2
wahr
falsch
wahr
falsch
Ergebnis
wahr
wahr
wahr
falsch
• Der Ausdruck ist nur dann falsch, wenn beide Operanden auf beiden Seiten des Operators falsch sind.
• Ist ein Operand wahr, ist der gesammte Ausdruck wahr.
4.4.1.3
Nicht-Operator (!)
Operand
wahr
falsch
Ergebnis
falsch
wahr
• Ist der Operand wahr, ist der Ausdruck falsch, und umgekehrt.
c MM
Joachim Lammarsch, Rothenberg
(j000150.tex)
77
Java-Schulung
4.4.1.4 Exklusiv-Oder-Operator (ˆ)
Operand 1
wahr
wahr
falsch
falsch
Operand 2
wahr
falsch
wahr
falsch
Ergebnis
falsch
wahr
wahr
falsch
• Der Ausdruck ist nur dann wahr, wenn beide Operanden unterschiedlich sind (einer ist
wahr und der andere ist falsch).
• Sind beide Operanden gleich (beide sind wahr oder beide sind falsch), ist der Ausdruck
falsch.
Im allgemeinen werden nur && und || häufig als logische Operatoren benutzt, & und | werden normalerweise für bitweise logische Operationen verwendet.
c MM
Joachim Lammarsch, Rothenberg (j000150.tex)
78
Java-Schulung
4.4.2 Bitweise Operatoren
Es gibt drei Gruppen von Operatoren zur Verarbeitung von Bits:
1. die Verschiebungsoperatoren,
2. der Negationsoperator,
3. die binären Operatoren.
• Bei allen Operatoren müssen die Bitfolgen einen ganzahligen Typ besitzen.
• Gleitkommawerte können nicht angesprochen werden.
• Die Operatoren wurden von C/C++ übernommen.
c MM
Joachim Lammarsch, Rothenberg
(j000150.tex)
79
Java-Schulung
4.4.2.1 Die Verschiebungsoperatoren
Operator
<<
>>
>>>
Bedeutung
Verschiebung nach links
Verschiebung nach rechts
Verschiebung nach rechts mit Füllnullen
• Bei der Verschiebung mit << nach links werden die freien Stellen rechts mit Nullen
aufgefüllt.
(Bem.: i<<1 entspricht der Multiplikation mit 2, i<<2 entspricht der Multiplikation
mit 4, usw.)
• Bei der Verschiebung mit >> nach rechts wird von links mit Vorzeichenbits aufgefüllt.
(Bem.: i>>1 entspricht der Division durch 2, i>>2 entspricht der Division durch 4,
usw.)
• Bei der Verschiebung mit >>> nach rechts werden die freien Stellen links mit Nullen
aufgefüllt.
c MM
Joachim Lammarsch, Rothenberg
(j000150.tex)
80
Java-Schulung
Beispiel:
public class Shft01
{
public static void main(String args[])
{
int i,x,y,z,t;
i
x
y
z
t
=
=
=
=
=
Integer.valueOf(args[0]).intValue();
i << 1;
i << 2;
i >> 2;
i >>> 3;
System.out.println(i
System.out.println(x
System.out.println(y
System.out.println(z
System.out.println(t
System.exit(0);
+
+
+
+
+
",
",
",
",
",
"
"
"
"
"
+
+
+
+
+
Integer.toBinaryString(i));
Integer.toBinaryString(x));
Integer.toBinaryString(y));
Integer.toBinaryString(z));
Integer.toBinaryString(t));
}
}
c MM
Joachim Lammarsch, Rothenberg
(j000150.tex)
81
Java-Schulung
ergibt bei dem Aufruf
java Shft01 512
als Ausgabe am Bildschirm:
512, 1000000000
1024, 10000000000
2048, 100000000000
128, 10000000
64, 1000000
bzw. vollständig ausgeschrieben (mit führenden Nullen):
512
1024
2048
128
64
c MM
0000
0000
0000
0000
0000
Joachim Lammarsch, Rothenberg
0000
0000
0000
0000
0000
0000
0000
0000
0000
0000
(j000150.tex)
0000
0000
0000
0000
0000
0000
0000
0000
0000
0000
0010
0100
1000
0000
0000
0000
0000
0000
1000
0100
0000
0000
0000
0000
0000
82
Java-Schulung
ergibt bei dem Aufruf
java Shft01 -1
als Ausgabe am Bildschirm:
-1, 11111111111111111111111111111111
-2, 11111111111111111111111111111110
-4, 11111111111111111111111111111100
-1, 11111111111111111111111111111111
536870911, 11111111111111111111111111111
bzw. vollstständig ausgeschrieben (mit führenden Nullen):
-1
-2
-4
-1
536870911
c MM
1111
1111
1111
1111
0001
Joachim Lammarsch, Rothenberg
1111
1111
1111
1111
1111
1111
1111
1111
1111
1111
(j000150.tex)
1111
1111
1111
1111
1111
1111
1111
1111
1111
1111
1111
1111
1111
1111
1111
1111
1111
1111
1111
1111
1111
1110
1100
1111
1111
83
Java-Schulung
4.4.2.2 Der Negationsoperator
Operator
~
Bedeutung
Bitweises Komplement
• Der unäre Negationsoperator ~ invertiert jedes Bit seines Operanden.
Beispiel:
public class Komp01
{
public static void main(String args[])
{
int i=512,x;
x = ~i;
System.out.println(i + ", " + Integer.toBinaryString(i));
System.out.println(x + ", " + Integer.toBinaryString(x));
System.exit(0);
}
}
c MM
Joachim Lammarsch, Rothenberg (j000150.tex)
84
Java-Schulung
Als Ausgabe erhält man:
512, 1000000000
-513, 11111111111111111111110111111111
bzw. vollständig ausgeschrieben (mit führenden Nullen):
512
-513
c MM
0000 0000 0000 0000 0000 0010 0000 0000
1111 1111 1111 1111 1111 1101 1111 1111
Joachim Lammarsch, Rothenberg
(j000150.tex)
85
Java-Schulung
4.4.2.3 Die binären Operatoren
Operator
&
|
^
Bedeutung
Bitweises Und
Bitweises Oder
Bitweises Exklusiv-Oder
• Ersetzt man in den Wahrheitstabellen wahr(true) durch 1 und falsch(false) durch 0
erhält man die Verknüpfungsregeln für die binären Operatoren.
• Die binären Operatoren & und | bilden das logische Produkt bzw. die logische Summe
ihrer Operanden.
• Der binäre Operator ^ realisiert bitweise das Exklusiv-Oder.
c MM
Joachim Lammarsch, Rothenberg (j000150.tex)
86
Java-Schulung
Beispiel:
public class Biop01
{
public static void main(String args[])
{
int i=1111, j=-2222, x;
x = i & j;
System.out.println(i + ", " + Integer.toBinaryString(i));
System.out.println(j + ", " + Integer.toBinaryString(j));
System.out.println(x + ", " + Integer.toBinaryString(x));
System.exit(0);
}
}
c MM
Joachim Lammarsch, Rothenberg
(j000150.tex)
87
Java-Schulung
Als Ausgabe erhält man:
1111, 10001010111
-2222, 11111111111111111111011101010010
1106, 10001010010
bzw. vollständig ausgeschrieben (mit führenden Nullen)
1111
0000 0000 0000 0000 0000 0100 0101 0111
-2222
1111 1111 1111 1111 1111 0111 0101 0010
----------------------------------------------------&
1106
0000 0000 0000 0000 0000 0100 0101 0010
c MM
Joachim Lammarsch, Rothenberg
(j000150.tex)
88
Java-Schulung
Beispiel:
public class Biop02
{
public static void main(String args[])
{
int i=1111, j=-2222, x;
x = i | j;
System.out.println(i + ", " + Integer.toBinaryString(i));
System.out.println(j + ", " + Integer.toBinaryString(j));
System.out.println(x + ", " + Integer.toBinaryString(x));
System.exit(0);
}
}
c MM
Joachim Lammarsch, Rothenberg
(j000150.tex)
89
Java-Schulung
Als Ausgabe erhält man:
1111, 10001010111
-2222, 11111111111111111111011101010010
-2217, 11111111111111111111011101010111
bzw. vollständig ausgeschrieben (mit führenden Nullen)
1111
0000 0000 0000 0000 0000 0100 0101 0111
-2222
1111 1111 1111 1111 1111 0111 0101 0010
----------------------------------------------------|
-2217
1111 1111 1111 1111 1111 0111 0101 0111
c MM
Joachim Lammarsch, Rothenberg
(j000150.tex)
90
Java-Schulung
Beispiel:
public class Biop03
{
public static void main(String args[])
{
int i=1111, j=-2222, x;
x = i ^ j;
System.out.println(i + ", " + Integer.toBinaryString(i));
System.out.println(j + ", " + Integer.toBinaryString(j));
System.out.println(x + ", " + Integer.toBinaryString(x));
System.exit(0);
}
}
c MM
Joachim Lammarsch, Rothenberg
(j000150.tex)
91
Java-Schulung
Als Ausgabe erhält man:
1111, 10001010111
-2222, 11111111111111111111011101010010
-3323, 11111111111111111111001100000101
bzw. vollständig ausgeschrieben (mit führenden Nullen)
1111
0000 0000 0000 0000 0000 0100 0101 0111
-2222
1111 1111 1111 1111 1111 0111 0101 0010
----------------------------------------------------^
-3323
1111 1111 1111 1111 1111 0011 0000 0101
c MM
Joachim Lammarsch, Rothenberg
(j000150.tex)
92
Java-Schulung
4.4.3 Verkürzte logische Operatoren
Java unterstützt ebenfalls die Kurzschreibweise logischer Ausdrücke. Da relativ oft die Form
operand1
=
operand1
operator
operand2
auftritt, wird vorzugsweise die verkürzte Schreibweise
operand1
operator =
operand2
eingesetzt.
Angewendet wird diese Schreibweise bei folgenden Operatoren:
Symbol
<<
>>
>>>
&
|
^
c MM
Operation
Verschiebung nach links
Verschiebung nach rechts
Verschiebung nach rechts
Füllnullen)
Bitweises Und
Bitweises Oder
Bitweises Exclusiv-Oder
Joachim Lammarsch, Rothenberg
(j000150.tex)
Kurzform
n <<= 10
n >>= 10
n >>>= 10
n &= 10
n |= 10
n ^= 10
Langform
n = n << 10
n = n >> 10
n = n >>> 10
n = n >>> 10
n = n & 10
n = n | 10
n = n ^ 10
93
Kapitel 5
Verzweigungen
5.1
Entscheidungen
Entscheidungen treffen heißt eine Bedingung zu prüfen, um dann, abhängig vom Ergebnis der
Überprüfung, mit dem einen oder anderen Programmteil fortzufahren.
94
Java-Schulung
5.1.1
if-Anweisung
Bei diesem Befehl werden eine oder mehrere Anweisungen ausgeführt, wenn die Bedingung
war ist.
Syntax:
if (bedingung)
anweisung;
oder
if (bedingung)
{
anweisung_1;
anweisung_2;
anweisung_n;
}
c MM
Joachim Lammarsch, Rothenberg
(j000160.tex)
95
Java-Schulung
Beispiel:
public class Verif01
{
public static void main(String args[])
{
int v1,v2;
v1 = Integer.valueOf(args[0]).intValue();
v2 = Integer.valueOf(args[1]).intValue();
if(v1==v2)
System.out.println("Die Zahlen sind gleich.");
System.exit(0);
}
}
c MM
Joachim Lammarsch, Rothenberg
(j000160.tex)
96
Java-Schulung
5.1.2
if-else-Anweisung
Mit diesem Befehl wird in Abhängigkeit von einer Bedingung entweder die eine oder die
andere Anweisung bzw. die einen oder die anderen Anweisungen ausgeführt.
Syntax:
if (bedingung)
anweisung_1;
else
anweisung_2;
oder
if (bedingung)
{
anweisung_a_1;
anweisung_a_n;
}
else
{
anweisung_b_1;
anweisung_b_n;
}
c MM
Joachim Lammarsch, Rothenberg
(j000160.tex)
97
Java-Schulung
Beispiel:
public class Verif02
{
public static void main(String args[])
{
int v1,v2;
v1 = Integer.valueOf(args[0]).intValue();
v2 = Integer.valueOf(args[1]).intValue();
if(v1==v2)
System.out.println("Die Zahlen sind gleich.");
else
System.out.println("Die Zahlen sind nicht gleich.");
System.exit(0);
}
}
c MM
Joachim Lammarsch, Rothenberg
(j000160.tex)
98
Java-Schulung
Beispiel:
public class Verel01
{
public static void main(String args[])
{
int v1;
v1 = Integer.valueOf(args[0]).intValue();
if(v1<0)
System.out.println("Die Zahl ist negativ.");
else
System.out.println("Die Zahl ist positiv.");
System.exit(0);
}
}
c MM
Joachim Lammarsch, Rothenberg
(j000160.tex)
99
Java-Schulung
Außerdem kann auch eine ganze Serie von Bedingungen geprüft werden.
if (bedingung_1)
anweisung_1;
else if (bedingung_2)
anweisung_2;
else if (bedingung_3)
anweisung_3;
else if (bedingung_4)
anweisung_4;
...
...
else if (bedingung_n)
anweisung_n;
else
standard_anweisung;
• Ist bedingung_1 wahr, wird anweisung_1 ausgeführt, ist bedingung_2 wahr,
wird anweisung_2 ausgeführt, u. s. w.
• Trifft keine der Bedingungen zu, wird standard_anweisung ausgeführt.
c MM
Joachim Lammarsch, Rothenberg
(j000160.tex)
100
Java-Schulung
Beispiel:
public class Verel02
{
public static void main(String args[])
{
int v1;
v1 = Integer.valueOf(args[0]).intValue();
if(v1<0)
System.out.println("Die Zahl ist negativ.");
else if(v1>0)
System.out.println("Die Zahl ist positiv.");
else
System.out.println("Die Zahl ist Null.");
System.exit(0);
}
}
c MM
Joachim Lammarsch, Rothenberg
(j000160.tex)
101
Java-Schulung
Beispiel:
public class Verel03
{
public static void main(String args[])
{
int v1;
v1 = Integer.valueOf(args[0]).intValue();
if(v1==1)
System.out.println("Die
else if(v1==2)
System.out.println("Die
else if(v1==3)
System.out.println("Die
else
System.out.println("Die
Zahl ist Eins.");
Zahl ist Zwei.");
Zahl ist Drei.");
Zahl ist ungleich 1, 2, 3.");
System.exit(0);
}
}
c MM
Joachim Lammarsch, Rothenberg
(j000160.tex)
102
Java-Schulung
Es ergibt sich beispielsweise folgender Dialog bei der Ausführung:
x92@pc:/j000160 > java Verel03 1
Die Zahl ist Eins.
x92@pc:/j000160 > java Verel03 2
Die Zahl ist Zwei.
x92@pc:/j000160 > java Verel03 3
Die Zahl ist Drei.
x92@pc:/j000160 > java Verel03 4
Die Zahl ist ungleich 1, 2, 3.
x92@pc:/j000160 > java Verel03 5
Die Zahl ist ungleich 1, 2, 3.
c MM
Joachim Lammarsch, Rothenberg
(j000160.tex)
103
Java-Schulung
5.1.3 Bedingte Ausdrücke
if-Ausdrücke der Form
if (bedingung)
x=ausdruck_1;
else
x=ausdruck_2;
sind durchaus nicht selten. Bei ihnen liegt es nahe, die Variable x und den Zuweisungsoperator
= „auszuklammern“, wodurch folgender Ausdruck entsteht:
Syntax:
bedingung ? ausdruck_1 : ausdruck_2
Der Wert des gesamten Befehls ist der Wert von ausdruck_1 bzw. ausdruck_2, je nachdem ob die Aussage von bedingung wahr oder falsch ist.
c MM
Joachim Lammarsch, Rothenberg
(j000160.tex)
104
Java-Schulung
Ein Programm der folgenden Form
Beispiel:
public class Verel04
{
public static void main(String args[])
{
int v1,v2,max;
v1 = Integer.valueOf(args[0]).intValue();
v2 = Integer.valueOf(args[1]).intValue();
if(v1<v2)
max = v2;
else
max = v1;
System.out.println(max + "
System.exit(0);
" + v1 + "
" + v2);
}
}
c MM
Joachim Lammarsch, Rothenberg
(j000160.tex)
105
Java-Schulung
kann nun wie folgt formuliert werden.
Beispiel:
public class Verel05
{
public static void main(String args[])
{
int v1,v2,max;
v1 = Integer.valueOf(args[0]).intValue();
v2 = Integer.valueOf(args[1]).intValue();
max = (v1<v2) ? v2 : v1;
System.out.println(max + "
" + v1 + "
" + v2);
System.exit(0);
}
}
c MM
Joachim Lammarsch, Rothenberg
(j000160.tex)
106
Java-Schulung
5.1.4 Geschachtelte if- oder if...else-Anweisungen
Java kennt bei der Schachtelung von Anweisungen keine grundsätzlichen Einschränkungen.
So dürfen bei den if-Anweisungen die Anweisungen beliebig sein – insbesondere selbst
wieder if-Anweisungen.
Syntax:
if(bedingung_1)
{
if(bedingung_1a)
...
else
...
}
else
{
if(bedingung_1b)
...
else
...
}
Die geschweiften Klammern dienen hier nur der Übersichtlichkeit, sie sind nicht erforderlich.
c MM
Joachim Lammarsch, Rothenberg
(j000160.tex)
107
Java-Schulung
Beispiel:
Zu einem Koodinatenpaar (x,y) soll ermittelt werden, in welchem Quadranten es liegt:
public class Verel06
{
public static void main(String args[])
{
int quadrant, x, y;
x = Integer.valueOf(args[0]).intValue();
y = Integer.valueOf(args[1]).intValue();
if (x>=0)
if (y>=0)
quadrant=1;
else
quadrant=4;
else
if (y>=0)
quadrant=2;
else
quadrant=3;
c MM
Joachim Lammarsch, Rothenberg
(j000160.tex)
108
Java-Schulung
System.out.println("Punkt liegt im " + quadrant +
". Quadranten");
System.exit(0);
}
}
oder unter Verwendung bedingter Ausdrücke:
public class Verel06a
{
public static void main(String args[])
{
int quadrant, x, y;
x = Integer.valueOf(args[0]).intValue();
y = Integer.valueOf(args[1]).intValue();
quadrant = x>=0
?
y>=0 ? 1 : 4
:
y>=0 ? 2 : 3;
System.out.println("Punkt liegt im " + quadrant +
". Quadranten");
System.exit(0);
}
}
c MM
Joachim Lammarsch, Rothenberg
(j000160.tex)
109
Java-Schulung
5.1.5 switch-Anweisung
Mit geschachtelten if-Anweisungen lassen sich grundsätzlich alle Entscheidungsfolgen realisieren:
public class Swch01
{
public static void main(String args[])
{
int zahl;
zahl=Integer.valueOf(args[0]).intValue();
if(zahl==1)
System.out.println("Die Zahl ist Eins.");
else
if(zahl==2)
System.out.println("Die Zahl ist Zwei.");
else
if(zahl==3 || zahl==4 || zahl==5)
System.out.println(
"Die Zahl ist Drei, Vier oder Fünf.");
else
c MM
Joachim Lammarsch, Rothenberg
(j000162.tex)
110
Java-Schulung
System.out.println(
"Die Zahl ist weder Eins noch ... Fünf.");
System.exit(0);
}
}
c MM
Joachim Lammarsch, Rothenberg
(j000162.tex)
111
Java-Schulung
Da Entscheidungsfolgen dieser Art keineswegs selten vorkommen, kennt Java mit der Anweisung switch eine Realisierung:
Syntax:
switch (ausdruck)
{
case konstanter
anweisung_1;
case konstanter
anweisung_2;
case konstanter
anweisung_3;
...
...
case konstanter
anweisung_n;
default:
anweisungen
}
c MM
Joachim Lammarsch, Rothenberg
ausdruck_1:
ausdruck_2:
ausdruck_3:
ausdruck_n:
(j000162.tex)
112
Java-Schulung
• Der Ausdruck ausdruck wird vollständig ausgewertet.
• Wir eine Übereinstimmung mit case konstanter ausdruck_i: (1 ≤ i ≤ n)
gefunden, dann wird bei dieser Anweisung die Abarbeitung fortgesetzt.
• Wird keine Übereinstimmung gefunden, wird bei default: fortgefahren.
• Gibt es kein default: wird der Anweisungsteil der switch-Anweisung ignoriert.
• Sowohl der Ausdruck ausdruck als auch die konstanten Ausdrücke müssen ganzzahlig
(byte, char, short oder int) sein.
• Die Reihenfolge der case- oder default-Anweisung ist beliebig.
• Durch den Befehl break wird die switch-Anweisung sofort verlassen.
c MM
Joachim Lammarsch, Rothenberg
(j000162.tex)
113
Java-Schulung
Beispiel:
public class Swch02
{
public static void main(String args[])
{
int zahl;
zahl=Integer.valueOf(args[0]).intValue();
switch(zahl)
{
case 1:
System.out.println("Die Zahl ist Eins."); break;
case 2:
System.out.println("Die Zahl ist Zwei."); break;
case 3: case 4: case 5:
System.out.println(
"Die Zahl ist Drei, Vier oder Fünf."); break;
default:
System.out.println(
"Die Zahl ist weder Eins noch ... Fünf.");
c MM
Joachim Lammarsch, Rothenberg
(j000162.tex)
114
Java-Schulung
}
System.exit(0);
}
}
c MM
Joachim Lammarsch, Rothenberg
(j000162.tex)
115
Java-Schulung
Beispiel:
public class Swch03
{
public static void main(String args[])
{
int zahl;
zahl=Integer.valueOf(args[0]).intValue();
switch(zahl)
{
case 1:
System.out.println("Montag");
case 2:
System.out.println("Dienstag");
case 3:
System.out.println("Mittwoch");
case 4:
System.out.println("Donnerstag");
case 5:
System.out.println("Freitag");
case 6:
c MM
Joachim Lammarsch, Rothenberg
(j000162.tex)
break;
break;
break;
break;
break;
116
Java-Schulung
System.out.println("Samstag");
break;
case 7:
System.out.println("Sonntag");
break;
default:
System.out.println("Eingabe ist falsch.");
}
System.exit(0);
}
}
• Es sind nur Vergleiche mit primitiven Datentypen möglich.
• Es können keine größeren primitiven Typen (long, float, double) oder Objekte benutzt
werden.
• Es kann abgesehen von Gleichheit keine Beziehung geprüft werden. Verschachtelte ifAnweisungen sind dagegen auf jede Art der Prüfung und auf jeden Datentyp anwendbar.
c MM
Joachim Lammarsch, Rothenberg
(j000162.tex)
117
Java-Schulung
5.2
Wiederholungen
Wiederholung bedeutet, daß ein Programmteil mehrfach nacheinander ausgeführt wird. Java
stellt hierzu folgende Befehle zur Verfügung:
• while
• do ... while
• for
c MM
Joachim Lammarsch, Rothenberg
(j000170.tex)
118
Java-Schulung
5.2.1
while-Anweisung
Bei diesem Befehl werden eine oder mehrere Anweisungen immer wieder ausgeführt, wenn
die Bedingung wahr ist.
Syntax:
while (bedingung)
anweisung;
oder
while (bedingung)
{
anweisung_1;
anweisung_2;
anweisung_n;
}
c MM
Joachim Lammarsch, Rothenberg
(j000170.tex)
119
Java-Schulung
• Zunächst wird der Ausdruck bedingung ausgewertet.
• Ist sein logischer Wert wahr wird die Anweisung bzw. werden die Anweisungen ausgeführt.
• Danach wird wiederum der Ausdruck bedingung ausgewertet.
• usw.
c MM
Joachim Lammarsch, Rothenberg
(j000170.tex)
120
Java-Schulung
Beispiel 1:
Ausgabe der Zahlen von 1 bis 10 am Bildschirm
public class Wwhl01
{
public static void main(String args[])
{
int i;
i=0;
while (i<10)
{
i=i+1;
System.out.println("Die Zahl ist: " + i);
}
System.exit(0);
}
}
c MM
Joachim Lammarsch, Rothenberg
(j000170.tex)
121
Java-Schulung
Als Ausgabe erhält man:
Die
Die
Die
Die
Die
Die
Die
Die
Die
Die
c MM
Zahl
Zahl
Zahl
Zahl
Zahl
Zahl
Zahl
Zahl
Zahl
Zahl
ist:
ist:
ist:
ist:
ist:
ist:
ist:
ist:
ist:
ist:
1
2
3
4
5
6
7
8
9
10
Joachim Lammarsch, Rothenberg
(j000170.tex)
122
Java-Schulung
Beispiel 2:
Berechnung der Summe der Zahlen von 1 bis 10 und Ausgabe der Summe am Bildschirm
public class Wwhl02
{
public static void main(String args[])
{
int i=0, summe=0;
while (i<10)
{
i=i+1;
summe=summe+i;
}
System.out.println("Die Summe ist: " + summe);
System.exit(0);
}
}
Als Ausgabe erhält man:
Die Summe ist: 55
c MM
Joachim Lammarsch, Rothenberg
(j000170.tex)
123
Java-Schulung
Beispiel 3:
Eine Endlosschleife . . .
public class Wwhl03
{
public static void main(String args[])
{
boolean ok=true;
while (ok)
{
System.out.print("X");
}
System.exit(0);
}
}
c MM
Joachim Lammarsch, Rothenberg
(j000170.tex)
124
Java-Schulung
5.2.2 Geschachtelte while-Anweisungen
Innerhalb einer while-Schleife ist eine weitere Schleife erlaubt.
Syntax:
while (bedingung_1)
{
...
...
while (bedingung_2)
{
...
...
...
...
}
...
...
}
c MM
Joachim Lammarsch, Rothenberg
(j000170.tex)
125
Java-Schulung
Beispiel:
public class Wwhl04
{
public static void main(String args[])
{
int i=0, j;
while (i++<3)
{
j=0;
while (j++<3)
System.out.print(i + " * " + j + " = " + i*j +
"
");
System.out.println("");
}
System.exit(0);
}
}
c MM
Joachim Lammarsch, Rothenberg
(j000170.tex)
126
Java-Schulung
Als Ausgabe erhält man:
1 * 1 = 1
2 * 1 = 2
3 * 1 = 3
c MM
1 * 2 = 2
2 * 2 = 4
3 * 2 = 6
Joachim Lammarsch, Rothenberg
(j000170.tex)
1 * 3 = 3
2 * 3 = 6
3 * 3 = 9
127
Java-Schulung
5.2.3
do ... while-Anweisung
Bei diesem Befehl werden eine oder mehrere Anweisungen immer wieder ausgeführt, wenn
die Bedingung wahr ist.
Syntax:
do
anweisung;
while (bedingung);
oder
do
{
anweisung_1;
anweisung_2;
anweisung_n;
}
while (bedingung);
c MM
Joachim Lammarsch, Rothenberg
(j000172.tex)
128
Java-Schulung
• Zunächst wird die Anweisung bzw. werden die Anweisungen ausgeführt.
• Danach wird der Ausdruck bedingung ausgewertet.
• Ist das Ergebnis wahr wird wiederum die Anweisung bzw. werden wiederum die Anweisungen ausgeführt.
• u.s.w.
5.2.3.1
Unterschied zwischen den Befehlen while und do ... while
• Bei einer while-Schleife wird der Ausdruck zum erstem Mal ausgewertet, bevor die
Anweisung der Schleife zum ersten Mal ausgeführt wird.
• Daher wird die Anweisung niemals ausgeführt, wenn der Ausdruck von vornherein
falsch war.
• Bei einer do ... while-Schleife wird der Ausdruck zum erstem Mal ausgewertet,
nachdem die Anweisung der Schleife zum ersten Mal ausgeführt wurde.
• Daher wird die Anweisung mindestens einmal ausgeführt, selbst wenn der Ausdruck von
vornherein falsch war.
c MM
Joachim Lammarsch, Rothenberg
(j000172.tex)
129
Java-Schulung
Beispiel 1:
Ausgabe der Zahlen von 1 bis 10 am Bildschirm
public class Wdwh01
{
public static void main(String args[])
{
int i;
i=0;
do
{
i=i+1;
System.out.println("Die Zahl ist: " + i);
}
while (i<10);
System.exit(0);
}
}
c MM
Joachim Lammarsch, Rothenberg
(j000172.tex)
130
Java-Schulung
Als Ausgabe erhält man:
Die
Die
Die
Die
Die
Die
Die
Die
Die
Die
c MM
Zahl
Zahl
Zahl
Zahl
Zahl
Zahl
Zahl
Zahl
Zahl
Zahl
ist:
ist:
ist:
ist:
ist:
ist:
ist:
ist:
ist:
ist:
1
2
3
4
5
6
7
8
9
10
Joachim Lammarsch, Rothenberg
(j000172.tex)
131
Java-Schulung
Beispiel 2:
Berechnung der Summe der Zahlen von 1 bis 10 und Ausgabe der Summe am Bildschirm
public class Wdwh02
{
public static void main(String args[])
{
int i=0, summe=0;
do
{
i=i+1;
summe=summe+i;
}
while (i<10);
System.out.println("Die Summe ist: " + summe);
System.exit(0);
}
}
Als Ausgabe erhält man:
Die Summe ist: 55
c MM
Joachim Lammarsch, Rothenberg
(j000172.tex)
132
Java-Schulung
Beispiel 3:
Eine Endlosschleife . . .
public class Wwhl03
{
public static void main(String args[])
{
boolean ok=true;
do
{
System.out.print("X");
}
while (ok);
System.exit(0);
}
}
c MM
Joachim Lammarsch, Rothenberg
(j000172.tex)
133
Java-Schulung
5.2.4 Geschachtelte do ... while-Anweisungen
Innerhalb einer do ... while-Schleife ist eine weitere Schleife erlaubt.
Syntax:
do
{
...
...
do
{
...
...
...
...
}
while (bedingung_2);
...
...
}
while (bedingung_1);
c MM
Joachim Lammarsch, Rothenberg
(j000173.tex)
134
Java-Schulung
Beispiel:
public class Wdwh04
{
public static void main(String args[])
{
int i=1, j;
do
{
j=1;
do
System.out.print(i + " * " + j + " = " + i*j +
"
");
while (j++<3);
System.out.println("");
}
while (i++<3);
System.exit(0);
}
}
c MM
Joachim Lammarsch, Rothenberg
(j000173.tex)
135
Java-Schulung
Als Ausgabe erhält man:
1 * 1 = 1
2 * 1 = 2
3 * 1 = 3
c MM
1 * 2 = 2
2 * 2 = 4
3 * 2 = 6
Joachim Lammarsch, Rothenberg
(j000173.tex)
1 * 3 = 3
2 * 3 = 6
3 * 3 = 9
136
Java-Schulung
5.2.5
for-Anweisung
Bei diesem Befehl werden eine oder mehrere Anweisungen immer wieder ausgeführt, wenn
die Bedingung wahr ist.
Syntax:
for (ausdruck_1; bedingung; ausdruck_2)
anweisung;
oder
for (ausdruck_1; bedingung; ausdruck_2)
{
anweisung_1;
anweisung_2;
anweisung_n;
}
c MM
Joachim Lammarsch, Rothenberg
(j000180.tex)
137
Java-Schulung
• anweisung_1 ist die Initialisierung, die den Beginn der Schleife einleitet.
• bedingung ist der Test, der nach jeder Iteration der Schleife ausgeführt wird. Der Test
muß ein boolscher Ausdruck sein. Ergibt der Test wahr, wird die Schleife ausgeführt.
• anweisung_2 ist ein beliebiger Ausdrucks- oder Funktionsaufruf. Üblicherweise wird
anweisung_2 verwendet, um den Wert des Schleifenindexes zu ändern.
• Die drei Komponenten der for-Anweisung können einzeln oder auch zusammen fehlen,
jedoch müssen die Semikolon in der Klammer an der richtigen Stelle stehen.
• for ( i=5 ; i<10 ;
)
• for (
; i<10 ; i++ )
• for (
; i<10 ;
)
• for (
;
)
c MM
Joachim Lammarsch, Rothenberg
;
(j000180.tex)
138
Java-Schulung
Beispiel 1:
Ausgabe der Zahlen von 1 bis 10 am Bildschirm
public class Wfor01
{
public static void main(String args[])
{
int i;
for (i=1; i<=10; i++)
System.out.println("Die Zahl ist: " + i);
System.exit(0);
}
}
c MM
Joachim Lammarsch, Rothenberg
(j000180.tex)
139
Java-Schulung
Als Ausgabe erhält man:
Die
Die
Die
Die
Die
Die
Die
Die
Die
Die
c MM
Zahl
Zahl
Zahl
Zahl
Zahl
Zahl
Zahl
Zahl
Zahl
Zahl
ist:
ist:
ist:
ist:
ist:
ist:
ist:
ist:
ist:
ist:
1
2
3
4
5
6
7
8
9
10
Joachim Lammarsch, Rothenberg
(j000180.tex)
140
Java-Schulung
Beispiel 2:
Berechnung der Summe der Zahlen von 1 bis 10 und Ausgabe der Summe am Bildschirm
public class Wfor02
{
public static void main(String args[])
{
int i, summe=0;
for (i=1; i<=10; i++)
summe = summe+i;
System.out.println("Die Summe ist: " + summe);
System.exit(0);
}
}
Als Ausgabe erhält man:
Die Summe ist: 55
c MM
Joachim Lammarsch, Rothenberg
(j000180.tex)
141
Java-Schulung
Beispiel 3:
Berechnung der Summe der Zahlen von 1 bis 10 und Ausgabe der Summe sowie der Zwischenergebnisse am Bildschirm
public class Wfor03
{
public static void main(String args[])
{
int i, summe=0;
for (i=1; i<=10; i++)
{
summe = summe+i;
System.out.println("i: " + i + " --- summe: " + summe);
}
System.out.println("Die Summe ist: " + summe);
System.exit(0);
}
}
c MM
Joachim Lammarsch, Rothenberg
(j000180.tex)
142
Java-Schulung
Als Ausgabe erhält man:
i: 1 --- summe: 1
i: 2 --- summe: 3
i: 3 --- summe: 6
i: 4 --- summe: 10
i: 5 --- summe: 15
i: 6 --- summe: 21
i: 7 --- summe: 28
i: 8 --- summe: 36
i: 9 --- summe: 45
i: 10 --- summe: 55
Die Summe ist: 55
c MM
Joachim Lammarsch, Rothenberg
(j000180.tex)
143
Java-Schulung
5.2.6 Geschachtelte for-Anweisungen
Innerhalb einer for-Schleife ist eine weitere Schleife erlaubt.
Syntax:
for (ausdruck_1; bedingung; ausdruck_2)
{
...
...
for (ausdruck_1; bedingung; ausdruck_2)
{
...
...
...
...
}
...
...
}
c MM
Joachim Lammarsch, Rothenberg
(j000180.tex)
144
Java-Schulung
Beispiel:
public class Wfor04
{
public static void main(String args[])
{
int i, j;
for (i=1; i<4; i++)
{
for (j=1; j<4; j++)
System.out.print(i + " * " + j + " = " + i*j +
"
");
System.out.println("");
}
System.exit(0);
}
}
c MM
Joachim Lammarsch, Rothenberg
(j000180.tex)
145
Java-Schulung
Als Ausgabe erhält man:
1 * 1 = 1
2 * 1 = 2
3 * 1 = 3
c MM
1 * 2 = 2
2 * 2 = 4
3 * 2 = 6
Joachim Lammarsch, Rothenberg
(j000180.tex)
1 * 3 = 3
2 * 3 = 6
3 * 3 = 9
146
Java-Schulung
5.2.7 Weitere Anwendungen für Schleifen
Beispiel 1:
Es soll die Reihe
1+
1
1 1 1
+ + + ··· + n
2 4 8
2
berechnet werden.
public class Wfor11
{
public static void main(String args[])
{
int i, n;
double summand=1., summe=1.;
n=Integer.valueOf(args[0]).intValue();
for (i=1; i<=n; i++)
{
summand/=2.;
summe+=summand;
}
System.out.println("Die Summe ist: " + summe);
c MM
Joachim Lammarsch, Rothenberg
(j000185.tex)
147
Java-Schulung
System.exit(0);
}
}
ergibt bei dem Aufruf
java Wfor11 11
als Ausgabe am Bildschirm:
Die Summe ist: 1.99951171875
c MM
Joachim Lammarsch, Rothenberg
(j000185.tex)
148
Java-Schulung
Beispiel 2:
public class Wfor10
{
public static void main(String args[])
{
long i, n, fakultaet;
n=Integer.valueOf(args[0]).intValue();
for (i=fakultaet=1; i<=n; fakultaet*=i++) ;
System.out.println("Die Fakultaet ist: " + fakultaet);
System.exit(0);
}
}
ergibt bei dem Aufruf
java Wfor10 5
als Ausgabe am Bildschirm:
Die Fakultaet ist: 120
c MM
Joachim Lammarsch, Rothenberg
(j000185.tex)
149
Java-Schulung
Beispiel 3:
public class Wfor12
{
public static void main(String args[])
{
int i, summe=0;
for (i=1; i>10; i++)
{
summe+=i;
}
System.out.println("Die Summe ist: " + summe);
System.exit(0);
}
}
Als Ausgabe erhält man:
Die Summe ist: 0
c MM
Joachim Lammarsch, Rothenberg
(j000185.tex)
150
Java-Schulung
5.2.7.1 Richtig ist:
public class Wfor12a
{
public static void main(String args[])
{
int i, summe=0;
for (i=1; i<10; i++)
{
summe+=i;
}
System.out.println("Die Summe ist: " + summe);
System.exit(0);
}
}
Als Ausgabe erhält man:
Die Summe ist: 45
c MM
Joachim Lammarsch, Rothenberg
(j000185.tex)
151
Java-Schulung
Beispiel 4:
public class Wfor13
{
public static void main(String args[])
{
int i, summe=0;
for (i=1; i<=10; i++) ;
{
System.out.println(i + "
}
" + i*i);
System.exit(0);
}
}
Als Ausgabe erhält man:
11
c MM
121
Joachim Lammarsch, Rothenberg
(j000185.tex)
152
Java-Schulung
5.2.7.2 Richtig ist:
public class Wfor13a
{
public static void main(String args[])
{
int i, summe=0;
for (i=1; i<=10; i++)
{
System.out.println(i + "
}
" + i*i);
System.exit(0);
}
}
c MM
Joachim Lammarsch, Rothenberg
(j000185.tex)
153
Java-Schulung
Als Ausgabe erhält man:
1
2
3
4
5
6
7
8
9
10
c MM
1
4
9
16
25
36
49
64
81
100
Joachim Lammarsch, Rothenberg
(j000185.tex)
154
Java-Schulung
5.2.8 Die Anweisung break
Die Anweisung break bewirkt, daß mit ihrer Ausführung die Abarbeitung der Schleife sofort
beendet wird. Dies geschieht unabhängig davon, ob das Abbruchkriterium der Schleife erfüllt
ist oder nicht.
Syntax:
break;
Die Anweisung break darf nicht direkt auftreten sondern darf nur bedingt ausgeführt werden. Daher kann die Anweisung nur in einer if- oder if-else-Anweisung auftreten.
c MM
Joachim Lammarsch, Rothenberg
(j000190.tex)
155
Java-Schulung
Beispiel:
public class Brk001
{
public static void main(String args[])
{
int x=0;
while(true)
{
System.out.println("x: " + x);
if(x++==5) break;
}
System.out.println("X: " + x);
System.exit(0);
}
}
c MM
Joachim Lammarsch, Rothenberg
(j000190.tex)
156
Java-Schulung
Als Ausgabe erhält man:
x:
x:
x:
x:
x:
x:
X:
0
1
2
3
4
5
6
c MM
Joachim Lammarsch, Rothenberg
(j000190.tex)
157
Java-Schulung
Bei geschachtelten Schleifen bewirkt die Anweisung break, daß mit ihrer Ausführung die
Abarbeitung der inneren Schleife sofort beendet wird.
Beispiel:
public class Brk002
{
public static void main(String args[])
{
int x=0, y=0;
for (x=0; x<5; x++)
{
System.out.println("x: " + x);
for (y=0; y<10; y++)
{
System.out.print(" " + y);
if(y==5) break;
}
System.out.println("");
}
System.out.println("X: " + x);
c MM
Joachim Lammarsch, Rothenberg
(j000190.tex)
158
Java-Schulung
System.out.println("Y: " + y);
System.exit(0);
}
}
Als Ausgabe erhält man:
x: 0
0
x: 1
0
x: 2
0
x: 3
0
x: 4
0
X: 5
Y: 5
c MM
1
2
3
4
5
1
2
3
4
5
1
2
3
4
5
1
2
3
4
5
1
2
3
4
5
Joachim Lammarsch, Rothenberg
(j000190.tex)
159
Java-Schulung
5.2.9 Die Anweisung continue
Die Anweisung continue bewirkt, daß mit ihrer Ausführung die Schleife erneut aufgerufen
wird. Die Schleifenvariable erhält dabei den nächsten Wert.
Syntax:
continue;
Die Anweisung continue darf nicht direkt auftreten sondern darf nur bedingt ausgeführt
werden. Daher kann die Anweisung nur in einer if- oder if-else-Anweisung auftreten.
c MM
Joachim Lammarsch, Rothenberg
(j000195.tex)
160
Java-Schulung
Beispiel:
public class Con001
{
public static void main(String args[])
{
double i;
for (i=-4.; i<=4.; i++)
{
if(i==0.)
continue;
System.out.println("Der Kehrwert ist: " + 1./i);
}
System.exit(0);
}
}
c MM
Joachim Lammarsch, Rothenberg
(j000195.tex)
161
Java-Schulung
Als Ausgabe erhält man:
Der
Der
Der
Der
Der
Der
Der
Der
Kehrwert
Kehrwert
Kehrwert
Kehrwert
Kehrwert
Kehrwert
Kehrwert
Kehrwert
ist:
ist:
ist:
ist:
ist:
ist:
ist:
ist:
-0.25
-0.3333333333333333
-0.5
-1.0
1.0
0.5
0.3333333333333333
0.25
Die Anweisung continue sorgt in diesem Fall dafür, daß bei dem Schleifenwert 0 nicht
dividiert wird.
c MM
Joachim Lammarsch, Rothenberg
(j000195.tex)
162
Java-Schulung
5.2.10
Benannte Schleifen
Sowohl break- als auch continue-Konstrukte können mit einem optionalen Argument
versehen werden.
Syntax:
break label;
bzw.
continue label;
Während bei der üblichen Verwendung von break als auch continue immer nur die gerade aktuelle Schleife verlassen bzw. von vorne durchlaufen wird, kann durch die Verwendung
von Marken auch ein Sprung über mehrere Schleifen durchgeführt werden.
c MM
Joachim Lammarsch, Rothenberg
(j000200.tex)
163
Java-Schulung
Beispiel (break):
public class Brk004
{
public static void main(String args[])
{
int i,j;
sch_1: for (i=1; i<=5; i++)
{
sch_2: for (j=1; j<=5; j++)
{
System.out.print(i+j + "\t");
if(i+j == 7)
{
System.out.println("");
break sch_1;
}
}
System.out.println("");
}
c MM
Joachim Lammarsch, Rothenberg
(j000200.tex)
164
Java-Schulung
System.exit(0);
}
}
Als Ausgabe erhält man:
2 3 4 5 6
3 4 5 6 7
c MM
Joachim Lammarsch, Rothenberg
(j000200.tex)
165
Java-Schulung
Beispiel (continue):
public class Con003
{
public static void main(String args[])
{
int i,j;
sch_1: for (i=1; i<=5; i++)
{
sch_2: for (j=1; j<=5; j++)
{
System.out.print(i+j + "\t");
if(i+j == 7)
{
System.out.println("");
continue sch_1;
}
}
System.out.println("");
}
c MM
Joachim Lammarsch, Rothenberg
(j000200.tex)
166
Java-Schulung
System.exit(0);
}
}
Als Ausgabe erhält man:
2
3
4
5
6
3
4
5
6
7
c MM
4 5 6
5 6 7
6 7
7
Joachim Lammarsch, Rothenberg
(j000200.tex)
167
Kapitel 6
Felder (Arrays oder Vektoren)
Felder speichern mehrere Variablen eines Datentyps, beispielsweise fünf Variablen des Datentyps int unter einem Variablennamen.
• Ein einzelner Platz in einem Feld heißt Element.
• Die Anzahl der Elemente ist gleich der Größe des Feldes.
• Jedes Element bekommt einen Index zugeordnet entsprechend seiner Position im Feld.
• Die Numerierung beginnt stets bei Null.
Felder müssen deklariert, allokiert und initialisiert werden.
168
Java-Schulung
Ein Feld wird in Java als Objekt behandelt und über Referenzen verwaltet. Seine Behandlung
unterliegt folgenden Gesichtspunkten:
• Felder werden über Referenzen manipuliert.
• Felder werden mittels new dynamisch generiert.
• Felder werden vom garbage Collector entsorgt.
c MM
Joachim Lammarsch, Rothenberg
(j000130.tex)
169
Java-Schulung
6.1
Anlegen eines Feldes
6.1.1 Deklaration eines Feldes
Felder müssen von einem bestimmten Datentyp sein. Der erste Schritt ist das Anlegen einer
Variablen (Referenz), die das Feld aufnimmt.
Syntax:
datentyp [] variablenname
Beispiel:
int [] Zahl;
double [] Gzahl;
Wichtig ist, daß die Größe des Feldes hier nicht angegeben wird. Die eckigen Klammern
können vor oder hinter dem Bezeichner angeordnet werden. Sie dienen nur der Information,
daß es sich um ein Feld handelt.
Beispiel:
int [] Zahl;
int Zahl [];
c MM
Joachim Lammarsch, Rothenberg
(j000130.tex)
170
Java-Schulung
6.1.2 Allokierung eines Feldes
Im nächsten Schritt müssen wir Speicherplatz anfordern. Die geschieht mittels des Befehls
new.
Syntax:
variablenname = new datentyp[elementanzahl]
Beispiel:
Zahl = new int [2];
Gzahl = new double [2];
Wenn Felder auf diese Weise angelegt werden, so werden alle Element mit Defaultwerten (0)
belegt.
c MM
Joachim Lammarsch, Rothenberg
(j000130.tex)
171
Java-Schulung
6.1.3 Initialisierung eines Feldes
Mittels des Befehls new haben wir ein Feld angelegt und es muß nun mit Werten belegt
werden.
Syntax:
variablenname[index] = wert
Beispiel:
Zahl[0] = 24;
Zahl[1] = 12;
c MM
Joachim Lammarsch, Rothenberg
(j000131.tex)
172
Java-Schulung
6.1.4 Gleichzeitiges Initialisieren und Anlegen eines Feldes
Es ist ferner möglich Deklaration, Allokierung und Initialisierung in einem Schritt durchzuführen.
Syntax:
datentyp [] variablenname = {wert1,wert2,wert3,...}
Beispiel:
int [] Zahl = {24,18,12,6};
double [] Gzahl = {1.2345,2.3456,3.4567};
Die Werte dürfen auch errechnete Werte sein, wenn sie zur Generierungszeit eindeutig definiert sind.
c MM
Joachim Lammarsch, Rothenberg
(j000131.tex)
173
Java-Schulung
Beispiel:
public class Feld01
{
public static void main(String args[])
{
int
[] Zahl;
int
[] Zahl2;
Zahl = new int[2];
Zahl2 = new int[2];
Zahl[0] = 12;
Zahl[1] = 24;
double [] Gzahl = {6.54321,1.23456,2.22222};
System.out.println(Zahl[0]*Zahl[1]);
System.out.println(Zahl2[0]+" "+Zahl2[1]);
System.out.println(Gzahl[0]+Gzahl[1]+Gzahl[2]);
}
}
c MM
Joachim Lammarsch, Rothenberg
(j000131.tex)
174
Java-Schulung
ergibt als Ausgabe am Bildschirm:
288
0 0
9.99999
Bei jedem Zugriff auf ein Feldelement wird überprüft, ob das Element innerhalb der Dimensionen des Feldes liegt.
c MM
Joachim Lammarsch, Rothenberg
(j000131.tex)
175
Java-Schulung
Durch die Instanzvariable length kann man zu jeder Zeit überprüfen, wieviele Elemente in
dem Feld enthalten sind.
Beispiel:
public class Feld02
{
public static void main(String args[])
{
int [] Zahl = new int[2];
System.out.println("Anzahl der Elemente: "
+ Zahl.length);
System.exit(0);
}
}
ergibt als Ausgabe am Bildschirm:
Anzahl der Elemente:
c MM
Joachim Lammarsch, Rothenberg
2
(j000131.tex)
176
Java-Schulung
6.2
Schleifen und Felder
Felder können mittels Schleifen bearbeitet werden:
Beispiel:
public class Schl01
{
public static void main(String args[])
{
int i,summe=0;
int [] feld = new int[11];
for(i=1;i<=10;i++)
feld[i]=2*i;
for(i=1;i<=10;i++)
System.out.print(feld[i] + "
System.out.println("\n");
");
for(i=1;i<=10;i++)
c MM
Joachim Lammarsch, Rothenberg
(j000240.tex)
177
Java-Schulung
summe+=feld[i];
System.out.println("Die Summe ist: " + summe);
System.exit(0);
}
}
ergibt als Ausgabe am Bildschirm:
2
4
6
8
10
12
14
16
18
20
Die Summe ist: 110
c MM
Joachim Lammarsch, Rothenberg
(j000240.tex)
178
Java-Schulung
6.2.1 Beispiel: Sieb des Eratosthenes
Durch das Sieb des Eratosthenes kann man schnell Primzahlen errechnen.
Zum Beispiel Berechnung der Primzahlen von 1 bis 100:
1
11
21
31
41
51
61
71
81
91
c MM
2
12
22
32
42
52
62
72
82
92
3
13
23
33
43
53
63
73
83
93
Joachim Lammarsch, Rothenberg
4
14
24
34
44
54
64
74
84
94
5
15
25
35
45
55
65
75
85
95
(j000250.tex)
6
16
26
36
46
56
66
76
86
96
7
17
27
37
47
57
67
77
87
97
8
18
28
38
48
58
68
78
88
98
9
19
29
39
49
59
69
79
89
99
10
20
30
40
50
60
70
80
90
100
179
Java-Schulung
Schritt 1:
(Löschen der Vielfachen von 2)
-11
21
31
41
51
61
71
81
91
c MM
2
----------
3
13
23
33
43
53
63
73
83
93
-----------
5
15
25
35
45
55
65
75
85
95
Joachim Lammarsch, Rothenberg
-----------
7
17
27
37
47
57
67
77
87
97
-----------
(j000250.tex)
9
19
29
39
49
59
69
79
89
99
-----------
180
Java-Schulung
Schritt 2:
(Löschen der Vielfachen von 3)
-11
-31
41
-61
71
-91
c MM
2
----------
3
13
23
-43
53
-73
83
--
-----------
5
-25
35
-55
65
-85
95
Joachim Lammarsch, Rothenberg
-----------
7
17
-37
47
-67
77
-97
-----------
(j000250.tex)
-19
29
-49
59
-79
89
--
-----------
181
Java-Schulung
Schritt 3:
(Löschen der Vielfachen von 5)
-11
-31
41
-61
71
-91
c MM
2
----------
3
13
23
-43
53
-73
83
--
-----------
5
----------
Joachim Lammarsch, Rothenberg
-----------
7
17
-37
47
-67
77
-97
-----------
(j000250.tex)
-19
29
-49
59
-79
89
--
-----------
182
Java-Schulung
Schritt 4:
(Löschen der Vielfachen von 7)
-11
-31
41
-61
71
---
c MM
2
----------
3
13
23
-43
53
-73
83
--
-----------
5
----------
Joachim Lammarsch, Rothenberg
-----------
7
17
-37
47
-67
--97
-----------
(j000250.tex)
-19
29
--59
-79
89
--
-----------
183
Java-Schulung
Als Ergebnis erhält man alle Primzahlen zwischen 1 und 100:
2
11
31
41
61
71
3
13
23
5
7
17
19
29
37
47
43
53
59
67
73
83
79
89
97
c MM
Joachim Lammarsch, Rothenberg
(j000250.tex)
184
Java-Schulung
6.2.1.1 Variante 1
Um dieses Verfahren zu Programmieren kann man man wie folgt vorgehen:
public class Sieb
{
public static void main(String args[])
{
// 1. Deklaration der Variablen
int i, j;
int [] sieb = new int[101];
// 2. Initialisierung des Feldes, sieb[0] unbenutzt
for (i=1; i<=100; i++)
sieb[i]=i;
// 3. Loeschen der Vielfachen
for (i=2; i<=10; i++)
for (j=2*i; j<=100; j+=i)
sieb[j]=0;
c MM
Joachim Lammarsch, Rothenberg
(j000250.tex)
185
Java-Schulung
// 4. Ausgabe der Primzahlen
for (i=2; i<=100; i++)
if (sieb[i]>0)
System.out.println(sieb[i]);
// Beenden des Programms
System.exit(0);
}
}
c MM
Joachim Lammarsch, Rothenberg
(j000250.tex)
186
Java-Schulung
ergibt als Ausgabe am Bildschirm:
2
3
5
7
11
13
17
19
23
29
31
37
41
43
c MM
47
53
59
61
67
71
73
79
83
89
97
Joachim Lammarsch, Rothenberg
(j000250.tex)
187
Java-Schulung
6.2.1.2 Variante 2
Die Umsetzung des Verfahrens ist nicht besonders effektiv, daher werden einige Verbessungungen vorgenommen:
public class Sieb2
{
public static void main(String args[])
{
// 1. Deklaration der Variablen
int i, j;
int [] sieb = new int[101];
// 2. Initialisierung des Feldes
// Neu: Feld wird erst ab 2. Element initialisiert
for (i=2; i<=100; i++)
sieb[i]=i;
// 3. Loeschen der Vielfachen
// Neu: Gerade Zahlen werden separat behandelt
for (j=4; j<=100; j+=2)
c MM
Joachim Lammarsch, Rothenberg
(j000250.tex)
188
Java-Schulung
sieb[j]=0;
// Neu: Mit bereits gestrichenen Zahlen wird nicht mehr
//
gestrichen; gerade Zahlen werden übergangen
for (i=3; i<=10; i++)
if (sieb[i]>0)
for (j=3*i; j<=100; j=j+2*i)
sieb[j]=0;
// 4. Ausgabe der Primzahlen
// Neu: Ausgabe des Index statt Inhalt des Feldelements
for (i=2; i<=100; i++)
if (sieb[i]>0)
System.out.println(i);
// 5. Beenden des Programms
System.exit(0);
}
}
c MM
Joachim Lammarsch, Rothenberg
(j000250.tex)
189
Java-Schulung
6.2.1.3 Variante 3
Als weitere Alternative kann man den Datentyp des Feldes von int auf boolean umstellen:
public class Sieb3
{
public static void main(String args[])
{
// 1. Deklaration der Variablen
int i, j;
// Neu: Datentyp wird auf boolean umgestellt
boolean [] sieb = new boolean[101];
// 2. Initialisierung des Feldes
for (i=2; i<=100; i++)
// Neu: Feld wird mit true initialisiert
sieb[i]=true;
// 3. Loeschen der Vielfachen
for (j=4; j<=100; j+=2)
sieb[j]=false;
c MM
Joachim Lammarsch, Rothenberg
(j000250.tex)
190
Java-Schulung
for (i=3; i<=10; i++)
// Neu: Feld-Element wird auf true abgefragt
if (sieb[i]==true)
for (j=3*i; j<=100; j+=2*i)
// Neu: Gestrichenes Feld-Element wird auf false gesetzt
sieb[j]=false;
// 4. Ausgabe der Primzahlen
for (i=2; i<=100; i++)
// Neu: Feld-Element wird auf true abgefragt
if (sieb[i]==true)
System.out.println(i);
// 5. Beenden des Programms
System.exit(0);
}
}
c MM
Joachim Lammarsch, Rothenberg
(j000250.tex)
191
Java-Schulung
6.2.1.4 Variante 4
Da die Zahl 2 die einzige gerade Primzahl ist, wird nur noch mit ungeraden Zahlen gearbeitet:
public class Sieb4
{
public static void main(String args[])
{
// 1. Deklaration der Variablen
int i, j;
// Feldgroesse halbiert
boolean [] sieb = new boolean[50];
// 2. Initialisierung des Feldes
for (i=1; i<50; i++)
sieb[i]=true;
// 3. Loeschen der Vielfachen
for (i=1; i<=10; i++)
if(sieb[i]==true)
for (j=3*i+1; j<50; j+=2*i+1)
c MM
Joachim Lammarsch, Rothenberg
(j000250.tex)
192
Java-Schulung
sieb[j]=false;
// 4. Ausgabe der Primzahlen
System.out.println(2);
for (i=1; i<50; i++)
if (sieb[i]==true)
System.out.println(2*i+1);
// 5. Beenden des Programms
System.exit(0);
}
}
c MM
Joachim Lammarsch, Rothenberg
(j000250.tex)
193
Java-Schulung
6.2.2 Zeitmessung: Sieb des Eratosthenes
Um Laufzeit-Vergleiche durchzuführen, wird die Anzahl der Primzahlen bis 1 000 000 für alle
4 Versionen bestimmt.
6.2.2.1 Variante 1
public class Sieba
{
public static void main(String args[])
{
int i, j;
int [] sieb = new int[1000001];
for (i=1; i<=1000000; i++)
sieb[i]=i;
for (i=2; i<=1000; i++)
for (j=2*i; j<=1000000; j+=i)
sieb[j]=0;
j=0;
for (i=2; i<=1000000; i++)
if (sieb[i]>0)
j++;
System.out.println("Anzahl der Primzahlen: " + j);
c MM
Joachim Lammarsch, Rothenberg
(j000250.tex)
194
Java-Schulung
System.exit(0);
}
}
c MM
Joachim Lammarsch, Rothenberg
(j000250.tex)
195
Java-Schulung
6.2.2.2 Variante 2
public class Sieb2a
{
public static void main(String args[])
{
int i, j;
int [] sieb = new int[1000001];
for (i=2; i<=1000000; i++)
sieb[i]=i;
for (j=4; j<=1000000; j+=2)
sieb[j]=0;
for (i=3; i<=1000; i++)
if (sieb[i]>0)
for (j=3*i; j<=1000000; j=j+2*i)
sieb[j]=0;
j=0;
for (i=2; i<=1000000; i++)
if (sieb[i]>0)
j++;
System.out.println("Anzahl der Primzahlen: " + j);
System.exit(0);
c MM
Joachim Lammarsch, Rothenberg
(j000250.tex)
196
Java-Schulung
}
}
c MM
Joachim Lammarsch, Rothenberg
(j000250.tex)
197
Java-Schulung
6.2.2.3 Variante 3
public class Sieb3a
{
public static void main(String args[])
{
int i, j;
boolean [] sieb = new boolean[1000001];
for (i=2; i<=1000000; i++)
sieb[i]=true;
for (j=4; j<=1000000; j+=2)
sieb[j]=false;
for (i=3; i<=1000; i++)
if (sieb[i]==true)
for (j=3*i; j<=1000000; j=j+2*i)
sieb[j]=false;
j=0;
for (i=2; i<=1000000; i++)
if (sieb[i]==true)
j++;
System.out.println("Anzahl der Primzahlen: " + j);
System.exit(0);
c MM
Joachim Lammarsch, Rothenberg
(j000250.tex)
198
Java-Schulung
}
}
c MM
Joachim Lammarsch, Rothenberg
(j000250.tex)
199
Java-Schulung
6.2.2.4 Variante 4
public class Sieb4a
{
public static void main(String args[])
{
int i, j;
boolean [] sieb = new boolean[500000];
for (i=1; i<500000; i++)
sieb[i]=true;
for (i=1; i<500; i++)
if(sieb[i]==true)
for (j=3*i+1; j<500000; j+=2*i+1)
sieb[j]=false;
j=1;
for (i=1; i<500000; i++)
if (sieb[i]==true)
j++;
System.out.println("Anzahl der Primzahlen: " + j);
System.exit(0);
}
}
c MM
Joachim Lammarsch, Rothenberg
(j000250.tex)
200
Java-Schulung
6.2.2.5 Ergebnisse
Als Ergebnis der Zeitmessungen erhält man:
Programmname
Sieba
Sieb2a
Sieb3a
Sieb4a
c MM
Joachim Lammarsch, Rothenberg
(j000250.tex)
Laufzeit in Sekunden
3.71
1.56
1.49
1.09
201
Java-Schulung
6.3
Schleifen und mehrdimensionale Felder
Mehrdimensionale Felder werden in Java nicht unterstützt. Allerdings kann man ein Feld mit
Felder deklarieren und darauf (wie in C/C++) zugreifen.
Diese mehrdimensionalen Felder können ebenfalls mittels Schleifen bearbeitet werden, wobei
für jede Dimension meist eine Laufvariable vorgesehen ist:
Syntax:
int i,j;
int [][] name = new int[dimension][dimension]
for(i=0;i<dimension;i++)
for(j=0;j<dimension;j++)
{
name[i][j]=befehl;
...
}
c MM
Joachim Lammarsch, Rothenberg
(j000260.tex)
202
Java-Schulung
Beispiel (Addition zweier Matrizen):
public class Schl02
{
public static void
{
// Deklarationen
int i,j;
int [][] mat_1 =
int [][] mat_2 =
int [][] mat_3 =
main(String args[])
new int[3][3];
new int[3][3];
new int[3][3];
// Initialisierung
for(i=0;i<3;i++)
for(j=0;j<3;j++)
{
mat_1[i][j]=3*i+j+1;
mat_2[i][j]=(3*i+j+1)*10;
}
c MM
Joachim Lammarsch, Rothenberg
(j000260.tex)
203
Java-Schulung
// Addition der Matrizen
for(i=0;i<3;i++)
for(j=0;j<3;j++)
mat_3[i][j]=mat_1[i][j]+mat_2[i][j];
// Ausgabe der Matrix mat_1
for(i=0;i<3;i++)
{
for(j=0;j<3;j++)
System.out.print(" " + mat_1[i][j] + "
System.out.println("");
}
System.out.println("");
// Ausgabe der Matrix mat_2
for(i=0;i<3;i++)
{
for(j=0;j<3;j++)
System.out.print(mat_2[i][j] + "
System.out.println("");
}
System.out.println("");
c MM
Joachim Lammarsch, Rothenberg
(j000260.tex)
");
");
204
Java-Schulung
// Ausgabe der Matrix mat_3
for(i=0;i<3;i++)
{
for(j=0;j<3;j++)
System.out.print(mat_3[i][j] + "
System.out.println("");
}
");
// Beenden des Programms
System.exit(0);
}
}
c MM
Joachim Lammarsch, Rothenberg
(j000260.tex)
205
Java-Schulung
ergibt als Ausgabe am Bildschirm:
1
4
7
2
5
8
3
6
9
10
40
70
20
50
80
30
60
90
11
44
77
22
55
88
33
66
99
c MM
Joachim Lammarsch, Rothenberg
(j000260.tex)
206
Teil II
Objektorientierte Programmierung mit Java
207
Java-Schulung
Folgende Eigenschaften der objektorientierten Programmierung sind in Java integriert:
• Java ist eine Sprache, die auf Klassen fußt.
• Alle Klassen in Java haben eine gemeinsame Oberklasse, die Klasse Object.
• Java implementiert das Konzept des Late Binding.
• Java unterstützt nicht die Mehrfachvererbung.
• Java unterstützt Polymorphismus.
• Java erlaubt das Überladen von Methoden, aber nicht von Operatoren.
• Java hat ein Schnittstellenkonzept implementiert.
• Java ist eine rein objektorientierte Sprache und verfügt nicht über die Möglichkeit, globale Konstanten, Variablen oder Funktionen zu definieren.
c MM
Joachim Lammarsch, Rothenberg
(j000300.tex)
208
Kapitel 7
Java und Klassen
Ein Java-Programm besteht immer aus einer Ansammlung von Klassen.
• Klassen sind Datenstrukturen, die aus Variablen und Funktionen bestehen.
• Die Variablen bzw. die Klassenvariablen sind die Attribute der Klasse.
• Die Funktionen bzw. die Klassenfunktionen sind die Methoden der Klasse.
• Jedes Attribut und jede Methode muß zu einer Klasse gehören.
• Durch Klassen werden neue Datentypen erzeugt, die Daten enthalten und wissen, wie
man mit ihnen umgeht.
• In Java werden alle Klassen von einer einzigen Basisklasse abgeleitet.
209
Java-Schulung
• Diese Klasse heißt Object.
• Wird eine Klasse von Object abgeleitet, muß dies nicht explizit angegeben werden.
• Durch den Befehl class wird in Java eine Klasse deklariert.
• Durch das Schlüsselwort extents wird die Oberklasse angegeben, von der die deklarierte Klasse abgeleitet wird.
Syntax:
class Klassenname
{
// weitere Deklarationen
}
ist gleichbedeutend mit
class Klassenname extents Object
{
// weitere Deklarationen
}
c MM
Joachim Lammarsch, Rothenberg
(j000300.tex)
210
Java-Schulung
7.1
Deklaration einer Klasse
Deklarationen beschreiben, wie die Klasse aussehen soll.
• Durch die Deklaration wird lediglich der Aufbau beschrieben.
• Es wird kein Objekt erzeugt.
• Es wird kein Speicherplatz belegt.
c MM
Joachim Lammarsch, Rothenberg
(j000300.tex)
211
Java-Schulung
7.1.1 Deklarationen von Attributen in einer Klasse
Attribute werden deklariert, in dem man ihren Datentyp und ihren Namen angibt.
Syntax:
datentyp name
bzw. für mehrere Variablen des selben Datentyps schreibt man
datentyp name_1, name_2, ...
Beispiel:
class Rechteck
{
int laenge, breite;
}
c MM
Joachim Lammarsch, Rothenberg
(j000300.tex)
212
Java-Schulung
7.1.2 Deklarationen von Methoden in einer Klasse
Methoden sind mit den Funktionen in anderen Programmiersprachen vergleichbar. Bei Java
unterscheidet man Klassen- und Instanzmethoden.
Sie werden wie folgt deklariert:
Syntax:
rueckgabedatentyp methoden_name(parameter_liste)
{
// Rumpf der Methode
}
• Methoden können Rückgabewerte liefern, um Fehler anzuzeigen oder um die Ergebnisse
von Berechnungen zurückzugeben.
• Der Befehl return gibt genau einen Wert zurück.
• Die Parameter, die an die Methode übergeben werden, sind hierbei nur die Kopien der
Attribute, d.h. sie können innerhalb der Methode verändert werden.
• Methoden haben in der Regel einen nur auf ein aktuelles Objekt begrenzten Wirkungsradius.
• Der Aufruf von Methoden wird oft auch als das Versenden einer Nachricht an ein Objekt
bezeichnet.
c MM
Joachim Lammarsch, Rothenberg
(j000300.tex)
213
Java-Schulung
• Eine innerhalb der Methode deklarierte Variable ist nur innerhalb der Methode bekannt.
• Ihre Reichweite beginnt bei ihrer Deklaration und endet am Ende des Blocks, in dem sie
deklariert wurde.
Syntax:
class Klassenname
{
...
...
int methode(datentyp1 parm1, datentyp2 parm2)
{
...
Befehle
...
return(parm3);
}
...
...
}
c MM
Joachim Lammarsch, Rothenberg
(j000300.tex)
214
Java-Schulung
Beispiel:
public class Meth01
{
// Methode main
public static void main(String args[])
{
int fl, um, br, la;
br = Integer.valueOf(args[0]).intValue();
la = Integer.valueOf(args[1]).intValue();
// Berechnung der Fläche
fl = flaeche(br,la);
System.out.println("Die Fläche ist: " + fl);
// Berechnung des Umfangs
um = umfang(br,la);
System.out.println("Der Umfang ist: " + um);
System.exit(0);
}
c MM
Joachim Lammarsch, Rothenberg
(j000300.tex)
215
Java-Schulung
// Methode zur Berechnung der Fläche
static int flaeche(int xbr, int xla)
{
return(xbr*xla);
}
// Methode zur Berechnung des Umfangs
static int umfang(int ybr, int yla)
{
return(2*ybr+2*yla);
}
}
ergibt beim Aufruf durch
java Meth01 10 15
als Ausgabe am Bildschirm
Die Fläche ist: 150
Der Umfang ist: 50
c MM
Joachim Lammarsch, Rothenberg
(j000300.tex)
216
Java-Schulung
7.1.2.1 Übergabe von Parametern mittels Referenzen
Beim Aufruf einer Methode mit Parametern, die ein Objekt representieren, werden die Variablen an die Methode als Referenz übergeben. Damit wirken sich alle Änderungen, die man an
diesen Objekten innerhalb der Methode vornimmt, auf die Orginalvariable aus.
Beispiel:
public class Feld11
{
//Methode zur Bearbeitung des Feldes
static int tuwas(int [] ifeld)
{
int i,z=0;
for(i=0;i<ifeld.length;i++)
{
z++;
if(ifeld[i]>4) ifeld[i]*=10;
}
return(z);
}
c MM
Joachim Lammarsch, Rothenberg
(j000300.tex)
217
Java-Schulung
//Methode zur Ausgabe Feldes
static void ausgabe(int [] ofeld)
{
System.out.print("Feld: [ ");
for(int i=0;i<ofeld.length;i++)
System.out.print(ofeld[i] + " ");
System.out.println("]");
return;
}
public static void main(String args[])
{
int [] feld={1,3,5,3,1,7,9,3};
int anzahl=0;
System.out.print("vorher - ");
ausgabe(feld);
System.out.println("Anzahl: " + anzahl);
anzahl=tuwas(feld);
c MM
Joachim Lammarsch, Rothenberg
(j000300.tex)
218
Java-Schulung
System.out.print("nachher - ");
ausgabe(feld);
System.out.println("Anzahl: " + anzahl);
System.exit(0);
}
}
Als Ausgabe erhält man:
vorher
Anzahl:
nachher
Anzahl:
c MM
- Feld:
0
- Feld:
8
Joachim Lammarsch, Rothenberg
[ 1 3 5 3 1 7 9 3 ]
[ 1 3 50 3 1 70 90 3 ]
(j000300.tex)
219
Java-Schulung
7.1.2.2 Rückgabe von Parametern mittels Referenzen
Bei der Rückgabe von Objekten wird die Referenz mittels return an das rufende Programm
zurückgegeben.
Beispiel:
public class Folg01
{
//Methode zur Generierung der Folge
static int [] mfolge(int von,int bis)
{
int [] ifeld = new int[bis-von+1];
for(int i=0;i<ifeld.length;i++)
ifeld[i]=von++;
return(ifeld);
}
c MM
Joachim Lammarsch, Rothenberg
(j000300.tex)
220
Java-Schulung
public static void main(String args[])
{
int [] feld;
feld=mfolge(2,9);
System.out.print("[ ");
for(int i=0;i<feld.length;i++)
System.out.print(feld[i] + " ");
System.out.println("]");
System.exit(0);
}
}
Als Ausgabe erhält man:
[ 2 3 4 5 6 7 8 9 ]
c MM
Joachim Lammarsch, Rothenberg
(j000300.tex)
221
Java-Schulung
7.1.3 Instanzierung von Objekten
Die Deklaration einer Klasse selbst belegt noch keinen Speicherplatz und die Instanzmethoden führen noch keine Aktion aus.
• Mit dem Operator new wird ein Objekt ins Leben gerufen.
• Die Objekte werden instanziert und ihnen wird Speicherplatz zugewiesen.
• Die so erzeugten Objekte werden Instanzvariablen genannt.
• Zu diesem Zeitpunkt kann man die Methoden für das aktuelle Objekt aufrufen.
Syntax:
klassen-datentyp objekt-name = new klassen-datentyp
• Wenn eine Instanzvariable nicht mehr benutzt wird, wird der Speichplatz zur Wiederverwertung markiert.
c MM
Joachim Lammarsch, Rothenberg
(j000300.tex)
222
Java-Schulung
Beispiel:
public class Meth02
{
// Attribute
int fl, um, br, la;
// Methode main
public static void main(String args[])
{
int hbr,hla;
hbr = Integer.valueOf(args[0]).intValue();
hla = Integer.valueOf(args[1]).intValue();
// Erzeugen der Instanz
Meth02 rechteck = new Meth02();
// Eingabe von Breite und Länge
rechteck.eingabe(hbr,hla);
c MM
Joachim Lammarsch, Rothenberg
(j000300.tex)
223
Java-Schulung
// Berechnung der Fläche
rechteck.flaeche();
// Berechnung des Umfangs
rechteck.umfang();
// Ausgabe von Fläche und Umfang
rechteck.ausgabe();
System.exit(0);
}
// Methode zur Eingabe von Breite und Länge
void eingabe(int xbr,int xla)
{
br = xbr;
la = xla;
return;
}
c MM
Joachim Lammarsch, Rothenberg
(j000300.tex)
224
Java-Schulung
// Methode zur Berechnung der Fläche
void flaeche()
{
fl=br*la;
return;
}
// Methode zur Berechnung des Umfangs
void umfang()
{
um=2*br+2*la;
return;
}
// Methode zur Ausgabe der Fläche und des Umfangs
void ausgabe()
{
System.out.println("Die Fläche ist: " + fl);
System.out.println("Der Umfang ist: " + um);
return;
}
}
c MM
Joachim Lammarsch, Rothenberg
(j000300.tex)
225
Java-Schulung
ergibt beim Aufruf durch
java Meth02 10 15
als Ausgabe am Bildschirm
Die Fläche ist: 150
Der Umfang ist: 50
c MM
Joachim Lammarsch, Rothenberg
(j000300.tex)
226
Java-Schulung
Beispiel:
public class Feld12
{
int [] feld={1,3,5,3,1,7,9,3};
int anzahl=0;
//Methode zur Bearbeitung des Feldes
void tuwas()
{
for(int i=0;i<feld.length;i++)
{
anzahl++;
if(feld[i]>4) feld[i]*=10;
}
}
//Methode zur Ausgabe Feldes
void ausgabe()
{
System.out.print("Feld: [ ");
for(int i=0;i<feld.length;i++)
c MM
Joachim Lammarsch, Rothenberg
(j000300.tex)
227
Java-Schulung
System.out.print(feld[i] + " ");
System.out.println("]");
System.out.println("Anzahl: " + anzahl);
}
public static void main(String args[])
{
Feld02 zahlen = new Feld02();
System.out.print("vorher - ");
zahlen.ausgabe();
zahlen.tuwas();
System.out.print("nachher - ");
zahlen.ausgabe();
System.exit(0);
}
}
c MM
Joachim Lammarsch, Rothenberg
(j000300.tex)
228
Java-Schulung
Als Ausgabe erhält man:
vorher
Anzahl:
nachher
Anzahl:
c MM
- Feld:
0
- Feld:
8
Joachim Lammarsch, Rothenberg
[ 1 3 5 3 1 7 9 3 ]
[ 1 3 50 3 1 70 90 3 ]
(j000300.tex)
229
Java-Schulung
Beispiel:
public class Folg02
{
int [] feld;
int von,bis;
//Methode zur Generierung der Folge
void mfolge()
{
feld = new int[bis-von+1];
for(int i=0;i<feld.length;i++)
feld[i]=von++;
}
public static void main(String args[])
{
Folg02 folge = new Folg02();
c MM
Joachim Lammarsch, Rothenberg
(j000300.tex)
230
Java-Schulung
folge.von=2;
folge.bis=9;
folge.mfolge();
System.out.print("[ ");
for(int i=0;i<folge.feld.length;i++)
System.out.print(folge.feld[i] + " ");
System.out.println("]");
System.exit(0);
}
}
Als Ausgabe erhält man:
[ 2 3 4 5 6 7 8 9 ]
c MM
Joachim Lammarsch, Rothenberg
(j000300.tex)
231
Java-Schulung
7.1.4 Konstruktoren
Um ein Objekt zu initialisieren, wird automatisch beim Aufruf von new die KonstruktorMethode der Objekt-Klasse gerufen.
• Sie hat den gleichen Namen wie die Klasse, für die sie ein Objekt initialisiert.
• Sie hat keinen Rückgabewert, selbst void wird nicht angegeben.
• Die Parameter sind wie bei jeder Methode optional.
Syntax:
class Klassenname
{
...
Klassenname()
// Konstruktormethode
{
...
//Befehle der Konstruktor-Methode
}
...
}
c MM
Joachim Lammarsch, Rothenberg
(j000300.tex)
232
Java-Schulung
Beispiel:
public class Meth03
{
// Attribute
int fl, um, br, la;
// Konstruktor zur Eingabe von Breite und Länge
Meth03(int xbr,int xla)
{
br = xbr;
la = xla;
return;
}
// Methode zur Berechnung der Fläche
void flaeche()
{
fl=br*la;
return;
}
c MM
Joachim Lammarsch, Rothenberg
(j000300.tex)
233
Java-Schulung
// Methode zur Berechnung des Umfangs
void umfang()
{
um=2*br+2*la;
return;
}
// Methode zur Ausgabe der Fläche und des Umfangs
void ausgabe()
{
System.out.println("Die Fläche ist: " + fl);
System.out.println("Der Umfang ist: " + um);
return;
}
// Methode main
public static void main(String args[])
{
int hbr,hla;
hbr = Integer.valueOf(args[0]).intValue();
c MM
Joachim Lammarsch, Rothenberg
(j000300.tex)
234
Java-Schulung
hla = Integer.valueOf(args[1]).intValue();
// Erzeugen der Instanz
Meth03 rechteck = new Meth03(hbr,hla);
// Berechnung der Fläche
rechteck.flaeche();
// Berechnung des Umfangs
rechteck.umfang();
// Ausgabe von Fläche und Umfang
rechteck.ausgabe();
System.exit(0);
}
}
ergibt beim Aufruf durch
java Meth03 10 15
als Ausgabe am Bildschirm
Die Fläche ist: 150
Der Umfang ist: 50
c MM
Joachim Lammarsch, Rothenberg
(j000300.tex)
235
Java-Schulung
Beispiel:
public class Auto01
{
int anzahl_passagiere;
float geschwindigkeit;
// Konstruktor
Auto01()
{
anzahl_passagiere=0;
geschwindigkeit=0.F;
}
// Methode Transportieren
void transportieren(int mitfahrer)
{
if((anzahl_passagiere+mitfahrer)>5)
System.out.println("Es ist kein Platz mehr frei");
else
anzahl_passagiere+=mitfahrer;
return;
c MM
Joachim Lammarsch, Rothenberg
(j000300.tex)
236
Java-Schulung
}
// Methode Beschleunigen
void beschleunigen(float g)
{
geschwindigkeit += g;
return;
}
// Methode main
public static void main(String args[])
{
// Speicherplatz für Objekt anlegen, Referenz anlegen
// Konstruktor aufrufen, d.h. Erzeugen den Instanz:
Auto01 mein_auto = new Auto01();
System.out.println("Die Geschwindigkeit ist:
" +
mein_auto.geschwindigkeit);
System.out.println("Die Anzahl der Passagiere ist: " +
mein_auto.anzahl_passagiere);
mein_auto.transportieren(2);
System.out.println("Die Anzahl der Passagiere ist: " +
c MM
Joachim Lammarsch, Rothenberg
(j000300.tex)
237
Java-Schulung
mein_auto.anzahl_passagiere);
mein_auto.transportieren(2);
System.out.println("Die Anzahl der Passagiere ist: " +
mein_auto.anzahl_passagiere);
mein_auto.transportieren(2);
mein_auto.beschleunigen(40);
System.out.println("Die Geschwindigkeit ist:
" +
mein_auto.geschwindigkeit);
mein_auto.beschleunigen(-40);
System.out.println("Die Anzahl der Passagiere ist: " +
mein_auto.anzahl_passagiere);
System.out.println("Die Geschwindigkeit ist:
" +
mein_auto.geschwindigkeit);
System.exit(0);
}
}
c MM
Joachim Lammarsch, Rothenberg
(j000300.tex)
238
Java-Schulung
Als Ausgabe erhält man:
Die Geschwindigkeit ist:
Die Anzahl der Passagiere ist:
Die Anzahl der Passagiere ist:
Die Anzahl der Passagiere ist:
Es ist kein Platz mehr frei
Die Geschwindigkeit ist:
Die Anzahl der Passagiere ist:
Die Geschwindigkeit ist:
c MM
Joachim Lammarsch, Rothenberg
(j000300.tex)
0.0
0
2
4
40.0
4
0.0
239
Java-Schulung
7.1.5 Übergabe bzw. Rückgabe von Objekten
Auch Objekte können an Methoden übergeben bzw. von Methoden zurückgegeben werden.
Es ist hierbei nur notwendig, die entsprechende Referenz anzugeben.
Beispiel:
public class Brch01
{
// Attribute
int zaehler,nenner;
// Konstruktor zur Eingabe von Zähler und Nenner
Brch01(int z,int n)
{
zaehler = z;
nenner = n;
return;
}
// Konstruktor ohne Eingabe von Zähler und Nenner
Brch01()
{
c MM
Joachim Lammarsch, Rothenberg
(j000310.tex)
240
Java-Schulung
zaehler = 0;
nenner = 1;
return;
}
// Methode zur Multiplikation
Brch01 mult(Brch01 b)
{
Brch01 brch = new Brch01();
brch.zaehler=zaehler*b.zaehler;
brch.nenner=nenner*b.nenner;
return(brch);
}
void ausgabe()
{
System.out.println(zaehler + "/" + nenner);
return;
}
// Methode main
c MM
Joachim Lammarsch, Rothenberg
(j000310.tex)
241
Java-Schulung
public static void main(String args[])
{
int br1z,br1n,br2z,br2n;
br1z
br1n
br2z
br2n
=
=
=
=
Integer.valueOf(args[0]).intValue();
Integer.valueOf(args[1]).intValue();
Integer.valueOf(args[2]).intValue();
Integer.valueOf(args[3]).intValue();
// Erzeugen der Instanzen
Brch01 bb1 = new Brch01(br1z,br1n);
Brch01 bb2 = new Brch01(br2z,br2n);
Brch01 bb3 = new Brch01();
// Ausgabe der Startwerte
bb1.ausgabe();
bb2.ausgabe();
bb3.ausgabe();
bb3=bb1.mult(bb2);
// Ausgabe des Ergebnisses
c MM
Joachim Lammarsch, Rothenberg
(j000310.tex)
242
Java-Schulung
bb3.ausgabe();
System.exit(0);
}
}
ergibt beim Aufruf durch
java Brch01 2 3 3 4
Als Ausgabe erhält man:
2/3
3/4
0/1
6/12
c MM
Joachim Lammarsch, Rothenberg
(j000310.tex)
243
Java-Schulung
Möchte man den Aufruf der Methode symetrisch gestalten, muß mit Klassenmethoden gearbeitet werden. In diesem Fall werden die Referenzen aller Objekte als Parameter übergeben.
Beispiel:
public class Brch02
{
// Attribute
int zaehler,nenner;
// Konstruktor zur Eingabe von Zähler und Nenner
Brch02(int z,int n)
{
zaehler = z;
nenner = n;
return;
}
// Konstruktor ohne Eingabe von Zähler und Nenner
Brch02()
{
zaehler = 0;
c MM
Joachim Lammarsch, Rothenberg
(j000310.tex)
244
Java-Schulung
nenner = 1;
return;
}
// Methode zur Multiplikation
static Brch02 mult(Brch02 b1,Brch02 b2)
{
Brch02 brch = new Brch02();
brch.zaehler=b1.zaehler*b2.zaehler;
brch.nenner=b1.nenner*b2.nenner;
return(brch);
}
void ausgabe()
{
System.out.println(zaehler + "/" + nenner);
return;
}
// Methode main
public static void main(String args[])
c MM
Joachim Lammarsch, Rothenberg
(j000310.tex)
245
Java-Schulung
{
int br1z,br1n,br2z,br2n;
br1z
br1n
br2z
br2n
=
=
=
=
Integer.valueOf(args[0]).intValue();
Integer.valueOf(args[1]).intValue();
Integer.valueOf(args[2]).intValue();
Integer.valueOf(args[3]).intValue();
// Erzeugen der Instanzen
Brch02 bb1 = new Brch02(br1z,br1n);
Brch02 bb2 = new Brch02(br2z,br2n);
Brch02 bb3 = new Brch02();
// Ausgabe der Startwerte
bb1.ausgabe();
bb2.ausgabe();
bb3.ausgabe();
bb3=mult(bb1,bb2);
// Ausgabe des Ergebnisses
bb3.ausgabe();
c MM
Joachim Lammarsch, Rothenberg
(j000310.tex)
246
Java-Schulung
System.exit(0);
}
}
ergibt beim Aufruf durch
java Brch02 2 3 3 4
Als Ausgabe erhält man:
2/3
3/4
0/1
6/12
c MM
Joachim Lammarsch, Rothenberg
(j000310.tex)
247
Kapitel 8
Pakete
In größeren Programmsystemen reichen Klassen als Strukturelemente alleine nicht aus. Oberhalb der Ebene der Klassen ist mit den Paketen (Packages) eine weitere Kollektion für Programmelemente vorgesehen.
Pakete sind eine Sammlung von Klassen, die einen gemeinsamen Zweck verfolgen oder aus
anderen Gründen zusammengefaßt werden sollen.
Jede Methode und jede Variable ist Bestandteil einer Klasse. Jede Klasse ist Bestandteil genau
eines Paketes.
Der vollständige Name einer Klasse besteht aus paket.klasse oder paket.unterpaket.
klasse. Jeder Teil eines mehrstufigen Paketnamens bezeichnet ein Unterverzeichnis, in dem
die gewünschte Klassendatei zu finden ist. Beispielsweise befindet sich das Paket java.
util.zip im Unterverzeichnis java/util/zip.
Die Suche nach Klassen erfolgt relativ zur Umgebungsvariablen CLASSPATH oder in einem
248
Java-Schulung
systemspezifischen Installationsverzeichnis (z.B. c:\java.1.2\bin bzw. /usr/lib/
java/bin) und zusätzlich im aktuellen Verzeichnis.
8.1
Verwendung von Paketen
Um eine Klasse verwenden zu können, muß man angeben, in welchem Paket sie liegt. Hierzu
gibt es zwei unterschiedliche Möglichkeiten.
1.
Angabe des qualifizierten Namens
Pakte.Klasse Variable = new Paket.Klasse();
Beispiel:
java.util.Date d = new java.util.Date();
2a.
Einbindung einer Klasse am Anfang des Programms
import java.util.Date;
...
Date d = new Date();
c MM
Joachim Lammarsch, Rothenberg
(j000330.tex)
/* import Paket.Klasse */
249
Java-Schulung
2b.
Einbindung eines Paktes am Anfang des Programms
import java.util.*;
...
Date d = new Date();
/* import Paket.*
*/
Diese Variante spart Schreibarbeit und kostet keinen Speicherplatz, da die Klassen erst beim
Aufruf im Programm in den Paketen gesucht werden.
c MM
Joachim Lammarsch, Rothenberg
(j000330.tex)
250
Java-Schulung
8.2
Vordefinierte Pakete
Die von Sun mitgelieferte Klassenbibliothek ist in mehr als 20 Pakete aufgeteilt, von denen
hier nur die wichtigsten genannt werden:
java.applet zur Implementierung von Java-Applets,
java.awt (Abstract Windowing Toolkit) zur Gestaltung graphischer Benutzeroberflächen,
java.awt.image zur AWT Bildverarbeitung,
java.io zur Ein- und Ausgabe bei Bildschirm und Dateien,
java.lang für die rudimentären Sprachbestandteile,
dieses Paket wird implizit von jeder Klasse importiert,
java.net zur Netzwerkunterstützung,
java.security enthält Sicherheitsdienste,
java.security.acl zur Unterstützung von Access Control Lists,
java.sql zur Datenbankunterstützung (JDBC),
java.util zur Verwendung verschiedener Datenstrukturen wie Dictionary, Hashtables, usw.,
java.util.zip zur Verwendung von JAR-Files, Kompression, Prüfsummen.
c MM
Joachim Lammarsch, Rothenberg
(j000330.tex)
251
Kapitel 9
Zeichenketten
Sie werden durch die Klasse String repräsentiert. Da ein Zeichen in Java im UnicodeZeichensatz dargestellt wird, besteht auch eine Zeichenkette aus Unicode-Zeichen.
252
Java-Schulung
9.1
Statische Zeichenketten
9.1.1 Konstruktoren
Die Klasse String bietet eine Reihe von Möglichkeiten neue Instanzen zu erzeugen.
Syntax:
String();
Erzeugt ein leeres Zeichenketten-Objekt.
String(String zeichenkette);
Erzeugt eine neue Zeichenkette durch Duplizierung einer bereits vorhandenen.
String(char[] feld);
Erzeugt eine neue Zeichenkette aus einem vorhandenen Zeichen-Feld. Es werden alle Elemente des Feldes in die Zeichenkette übernommen. Der Inhalt des Feldes wird nicht kopiert.
c MM
Joachim Lammarsch, Rothenberg
(j000350.tex)
253
Java-Schulung
9.1.2 Methoden
Die Klasse String definiert eine Vielzahl von Methoden zur Manipulation und zur Bestimmung der Eigenschaften von Zeichenketten.
+
Verketten von zwei Zeichenketten
int length()
Länge einer Zeichenkette
char charAt(int position)
Zeichen an einer Position
int compareTo(String zeichenkette)
Vergleich von Zeichenketten
String substring(int anfangsindex, int endeindex)
Teil einer Zeichenkette
String toLowerCase()
Umwandlung in Kleinbuchstaben
String toUpperCase()
Umwandlung in Großbuchstaben
c MM
Joachim Lammarsch, Rothenberg
(j000350.tex)
254
Java-Schulung
int indexOf (String zeichenkette)
Suchen eines Zeichens in einer Zeichenkette (vom Anfang der Zeichenkette an)
int indexOf (String zeichenkette, int beginn)
Suchen eines Zeichens in einer Zeichenkette (von einer Position an)
int lastIndexOf (String zeichenkette)
Suchen eines Zeichens in einer Zeichenkette (vom Ende der Zeichenkette
beginnend an)
int lastIndexOf (String zeichenkette, int beginn)
Suchen eines Zeichens in einer Zeichenkette (von einer Position vom
Ende beginnend an)
c MM
Joachim Lammarsch, Rothenberg
(j000350.tex)
255
Java-Schulung
9.1.2.1 Verkettung von Zeichenketten
Hierzu steht der Operator + zur Verfügung.
Syntax:
zkneu = zk1 + zk2;
zkneu ist die Verkettung der Zeichenketten zk1 und zk2.
Beispiel:
public class Zk001
{
public static void main(String [] args)
{
String str1 = "Das ist eine Zeichenkette. ";
String str2 = "Das ist eine Zeichenkette. ";
String str3 = "Das ist eine neue Zeichenkette. ";
String str4;
str4=str1+str2;
System.out.println(str4);
c MM
Joachim Lammarsch, Rothenberg
(j000350.tex)
256
Java-Schulung
str1+=str3;
System.out.println(str1 + ’\n’);
}
}
Als Ausgabe erhält man:
Das ist eine Zeichenkette. Das ist eine Zeichenkette.
Das ist eine Zeichenkette. Das ist eine neue Zeichenkette.
c MM
Joachim Lammarsch, Rothenberg
(j000350.tex)
257
Java-Schulung
9.1.2.2 Länge einer Zeichenkette
Syntax:
int length();
liefert die aktuelle Länge einer Zeichenkette. Ist der Rückgabewert 0, dann ist die Zeichenkette leer. Ist die Zahl größer als 0 enthält die Zeichenkette n Zeichen, die an den Positionen
0 bis n − 1 stehen.
Beispiel:
public class Zk002
{
public static void main(String [] args)
{
String str1 = "Das ist eine Zeichenkette. ";
System.out.println("Länge:
" + str1.length());
}
}
Als Ausgabe erhält man:
Länge:
c MM
27
Joachim Lammarsch, Rothenberg
(j000350.tex)
258
Java-Schulung
9.1.2.3 Zeichenposition
Syntax:
char charAt(int position);
liefert das Zeichen an der Position position. Das erste Element hat die Position 0.
Beispiel:
public class Zk003
{
public static void main(String [] args)
{
String str1 = "Das ist eine Zeichenkette. ";
System.out.println("Zeichen:
" + str1.charAt(13));
}
}
Als Ausgabe erhält man:
Zeichen:
c MM
Z
Joachim Lammarsch, Rothenberg
(j000350.tex)
259
Java-Schulung
9.1.2.4 Vergleich von Zeichenketten
Syntax:
int compareTo(String zeichenkette);
führt einen lexikalischen Vergleich zweier Zeichenketten durch. Die Zeichen werden paarweise von links nach rechts miteinander verglichen. Bei Gleichheit liefert die Methode den
Rückgabewert 0.
Beispiel:
public class Zk004
{
public static void main(String [] args)
{
String str1 = "Das ist eine Zeichenkette. ";
String str2 = "Das ist eine Zeichenkette. ";
String str3 = "Das ist eine neue Zeichenkette. ";
System.out.println("Vergl1: " + str1.compareTo(str2));
System.out.println("Vergl2: " + str1.compareTo(str3) + ’\n’);
}
}
c MM
Joachim Lammarsch, Rothenberg
(j000350.tex)
260
Java-Schulung
Als Ausgabe erhält man:
Vergl1: 0
Vergl2: -20
c MM
Joachim Lammarsch, Rothenberg
(j000350.tex)
261
Java-Schulung
9.1.2.5 Teile von Zeichenketten
Syntax:
String substring(int anfangsindex, int endeindex)
substring liefert die Teil-Zeichenkette, die zwischen den Indizes anfangsindex und
endeindex−1 steht; die Länge der Zeichenkette ist damit anfangsindex−endeindex.
Beispiel:
public class Zk008
{
public static void main(String [] args)
{
String str2 = "Das ist eine Zeichenkette. ";
String str4 = new String();
String str5 = new String();
str4=str2.substring(0,7);
str5=str2.substring(8,13);
System.out.println(str2);
System.out.println(str4);
System.out.println(str5);
c MM
Joachim Lammarsch, Rothenberg
(j000350.tex)
262
Java-Schulung
}
}
Als Ausgabe erhält man:
Das ist eine Zeichenkette.
Das ist
eine
c MM
Joachim Lammarsch, Rothenberg
(j000350.tex)
263
Java-Schulung
9.1.2.6 Umwandlung in Groß- bzw. Kleinbuchstaben
Syntax:
String toLowerCase();
String toUpperCase();
toLowerCase liefert die Zeichenkette, die entsteht, wenn alle Zeichen in Kleinbuchstaben umgewandelt werden. toUpperCase liefert die Zeichenkette, die entsteht, wenn alle
Zeichen in Großbuchstaben umgewandelt werden.
Beispiel:
public class Zk006
{
public static void main(String [] args)
{
String str2 = "Das ist eine Zeichenkette. ";
System.out.println("Klein:
System.out.println("Gross:
" + str2.toLowerCase());
" + str2.toUpperCase());
}
}
c MM
Joachim Lammarsch, Rothenberg
(j000350.tex)
264
Java-Schulung
Als Ausgabe erhält man:
Klein:
Gross:
c MM
das ist eine zeichenkette.
DAS IST EINE ZEICHENKETTE.
Joachim Lammarsch, Rothenberg
(j000350.tex)
265
Java-Schulung
9.1.2.7 Suchen in Zeichenketten
indexOf und lastIndexOf suchen nach dem ersten bzw. letzten Zeichen in einer Zeichenkette.
Syntax:
int
int
int
int
indexOf (String zeichenkette);
indexOf (String zeichenkette, int beginn);
lastIndexOf (String zeichenkette);
lastIndexOf (String zeichenkette, int beginn);
indexOf sucht das erste Vorkommen der Zeichenkette zk innerhalb eines ZeichenkettenObjekts bzw. beginnt mit der Suche ab der Position beginn. Die Methode lastIndexOf
sucht nach dem letzten Vorkommen der Zeichenkette zk innerhalb eines ZeichenkettenObjekts bzw. beginnt mit der Suche ab der Position beginn rückwärts.
Beispiel:
public class Zk007
{
public static void main(String [] args)
{
String str2 = "Das ist eine Zeichenkette. ";
c MM
Joachim Lammarsch, Rothenberg
(j000350.tex)
266
Java-Schulung
System.out.println("Position: " + str2.indexOf("e"));
System.out.println("Position: " + str2.indexOf("e",13));
System.out.println("Position: " + str2.lastIndexOf("e"));
System.out.println("Position: " +
str2.lastIndexOf("e",10) + ’\n’);
}
}
Als Ausgabe erhält man:
Position:
Position:
Position:
Position:
c MM
8
14
24
8
Joachim Lammarsch, Rothenberg
(j000350.tex)
267
Java-Schulung
Beispiel:
/* Zählen der Zeichen in einer beliebigen Zeichenkette */
public class Zk010
{
public static void main(String [] args)
{
// Definieren der Zeichenkette
String zk = "Das ist eine Zeichenkette. ";
// Feld für alle Unicode-Zeichen anlegen
int [] zkZaehler = new int[65536];
int i;
// Bsp.: A hat im Unicode die Position 65, dann liefert
// charAt(i) den Buchstaben A und zk.charAt(i) ist der
// Feldindex für den Zähler des Buchstabens A, also 65
for(i=0;i<zk.length();i++)
zkZaehler[zk.charAt(i)]++;
c MM
Joachim Lammarsch, Rothenberg
(j000350.tex)
268
Java-Schulung
for(i=0;i<zkZaehler.length;i++)
if(zkZaehler[i]>0)
System.out.println((char)i + " [" + i + "] "
+ zkZaehler[i]);
}
}
Als Ausgabe erhält man:
.
D
Z
a
c
e
h
i
k
n
s
t
[32] 4
[46] 1
[68] 1
[90] 1
[97] 1
[99] 1
[101] 6
[104] 1
[105] 3
[107] 1
[110] 2
[115] 2
[116] 3
c MM
Joachim Lammarsch, Rothenberg
(j000350.tex)
269
Java-Schulung
9.2
Dynamische Zeichenketten
Durch die Klasse String werden keine dynamischen Zeichenketten implementiert. Nach
der Initialisierung einer Zeichenkette bleiben deren Länge und Inhalt konstant.
9.2.1 Konstruktoren
Syntax:
StringBuffer();
Erzeugt einen leeren StringBuffer.
StringBuffer(String zeichenkette);
Erzeugt ein neues StringBuffer-Objekt, durch Kopieren der Zeichenkette zeichenkette.
c MM
Joachim Lammarsch, Rothenberg
(j000350.tex)
270
Java-Schulung
9.2.2 Methoden
9.2.2.1 Einfügen von Elementen
append hängt an das StringBuffer-Objekt eine Zeichenkette an und insert fügt eine Zeichenkette ein.
Syntax:
StringBuffer append(String zeichenkette);
StringBuffer insert(int position, String zeichenkette);
9.2.2.2 Konvertieren in eine Zeichenkette
Mit dieser Methode kann ein StringBuffer-Objekt in ein String-Objekt verwandelt werden.
Syntax:
String toString();
c MM
Joachim Lammarsch, Rothenberg
(j000350.tex)
271
Java-Schulung
Beispiel:
public class Zk020
{
public static void main(String [] args)
{
String zk1= "Das eine";
String zk2= "ist";
String zk3= "Zeichenkette";
String zk4;
StringBuffer zkb = new StringBuffer(zk1);
zkb.insert(4,zk2);
System.out.println(zkb);
zkb.insert(7," ");
System.out.println(zkb);
zkb.append(" ");
zkb.append(zk3);
System.out.println(zkb);
zk4=zkb.toString();
c MM
Joachim Lammarsch, Rothenberg
(j000350.tex)
272
Java-Schulung
System.out.println(zk4);
}
}
Als Ausgabe erhält man:
Das
Das
Das
Das
c MM
isteine
ist eine
ist eine Zeichenkette
ist eine Zeichenkette
Joachim Lammarsch, Rothenberg
(j000350.tex)
273
Java-Schulung
Beispiel:
public class Zk021
{
public static void main(String args[])
{
int i=1234;
double d=3.14159;
StringBuffer s1 = new StringBuffer("abcde");
System.out.println("i: " + i);
System.out.println("s1: " + s1);
s1=s1.append(i);
System.out.println("s1: " + s1);
s1=s1.insert(0,d);
System.out.println("s1: " + s1);
}
}
c MM
Joachim Lammarsch, Rothenberg
(j000350.tex)
274
Java-Schulung
Als Ausgabe erhält man:
i:
s1:
s1:
s1:
c MM
1234
abcde
abcde1234
3.14159abcde1234
Joachim Lammarsch, Rothenberg
(j000350.tex)
275
Java-Schulung
9.2.2.3 Länge eines StringBuffer-Objekts
length liefert die Länge des Objekts.
Syntax:
int length();
9.2.2.4 Verändern von Elementen eines StringBuffer-Objekts
setCharAt ersetzt das an der Position position stehende Zeichen durch das Zeichen z.
Syntax:
void setCharAt(int position, char z);
c MM
Joachim Lammarsch, Rothenberg
(j000350.tex)
276
Kapitel 10
Mathematische Methoden
Die Klasse java.lang.Math enthält Funktionen zur Gleitkomma-Arithmetik. Alle Methoden dieser Klasse sind von Typ static und können daher ohne zugehöriges Objekt verwendet werden.
Die Konstanten e (Eulersche Zahl) und π (Kreiszahl) werden von der Klasse zur Verfügung
gestellt.
277
Java-Schulung
10.1
Winkelfunktionen
Die Klasse java.lang.Math stellt die üblichen Winkelfunktionen und ihre Umkehrungen
zur Verfügung. Winkelwerte werden dabei im Bogenmaß übergeben.
Beispiel:
public class Math01
{
public static void main(String [] args)
{
System.out.println( Math.PI );
System.out.println( Math.sin(Math.PI/2.) );
System.out.println( Math.asin(1.) );
System.out.println( Math.cos(Math.PI/2.) );
System.out.println( Math.acos(1.) );
System.out.println( Math.tan(Math.PI/2.) );
System.out.println( Math.atan(1.) );
}
c MM
Joachim Lammarsch, Rothenberg
(j000450.tex)
278
Java-Schulung
}
Als Ausgabe erhält man:
3.141592653589793
1.0
1.5707963267948966
6.123031769111886E-17
0.0
1.6331778728383844E16
0.7853981633974483
c MM
Joachim Lammarsch, Rothenberg
(j000450.tex)
279
Java-Schulung
10.2
Minimum und Maximum
Die Methoden min und max erwarten zwei numerische Werte als Argument und geben den
kleineren bzw. größeren von beiden zurück.
Beispiel:
public class Math03
{
public static void main(String [] args)
{
int a=3,b=5;
float c=3.F,d=5.F;
System.out.println( Math.min(a,b) );
System.out.println( Math.max(a,b) );
System.out.println( Math.min(c,d) );
System.out.println( Math.max(c,d) );
}
}
c MM
Joachim Lammarsch, Rothenberg
(j000450.tex)
280
Java-Schulung
Als Ausgabe erhält man:
3
5
3.0
5.0
c MM
Joachim Lammarsch, Rothenberg
(j000450.tex)
281
Java-Schulung
10.3
Arithmetik
Die nachfolgend aufgelisteten Methoden dienen zur Ausführung folgender arithmetischer
Operationen:
• Quadratwurzel einer Gleitkommazahl,
• Exponentialfunktion zur Basis e,
• natürlicher Logarithmus,
• Potenzieren einer Gleitpunktzahl mit einer Gleitpunktzahl.
Beispiel:
public class Math02
{
public static void main(String [] args)
{
System.out.println( Math.sqrt(4.) );
System.out.println( Math.exp(1.) );
System.out.println( Math.log(2.) );
System.out.println( Math.pow(2.,5.) );
}
}
c MM
Joachim Lammarsch, Rothenberg
(j000450.tex)
282
Java-Schulung
Als Ausgabe erhält man:
2.0
2.718281828459045
0.6931471805599453
32.0
c MM
Joachim Lammarsch, Rothenberg
(j000450.tex)
283
Java-Schulung
10.4
Runden und Abschneiden
Mit Hilfe der Methode abs wird der absolute Betrag eines numerischen Wertes bestimmt.
ceil liefert die kleinste ganze Zahl größer oder gleich dem übergebenen Argument. Äquivalent liefert floor die größte ganze Zahl kleiner oder gleich dem übergebenen Argument.
Mit Hilfe von round kann ein Wert gerundet werden.
Beispiel:
public class Math05
{
public static void main(String [] args)
{
float a=3.4F, b=3.6F;
System.out.println(
System.out.println(
System.out.println(
System.out.println(
System.out.println(
System.out.println(
Math.ceil(a) );
Math.ceil(b) );
Math.floor(a) );
Math.floor(b) );
Math.round(a) );
Math.round(b) );
}
c MM
Joachim Lammarsch, Rothenberg
(j000450.tex)
284
Java-Schulung
}
Als Ausgabe erhält man:
4.0
4.0
3.0
3.0
3
4
Wie man auch hier wieder sieht, wird durch den Datentyp des übergebenen Arguments die
Methode bestimmt, die zum Berechnen verwendet wird. Ein Beispiel für die sinnvolle Anwendung von überlagerten Methoden.
c MM
Joachim Lammarsch, Rothenberg
(j000450.tex)
285
Java-Schulung
Beispiel:
public class Math04
{
public static void main(String [] args)
{
int a=3, b=-5;
float c=3.F, d=-5.F;
System.out.println(
System.out.println(
System.out.println(
System.out.println(
Math.abs(a)
Math.abs(b)
Math.abs(c)
Math.abs(d)
);
);
);
);
}
}
Als Ausgabe erhält man:
3
5
3.0
5.0
c MM
Joachim Lammarsch, Rothenberg
(j000450.tex)
286
Java-Schulung
10.5
Zufallszahlen
Mit Hilfe der Methode random erzeugt man eine Zufallszahl zwischen 0.0 und 1.0.
public class Math06
{
public static void main(String [] args)
{
System.out.println( Math.random() );
System.out.println( Math.random() );
System.out.println( Math.random() );
System.out.println( Math.random() + "\n");
// Simulieren eines
System.out.println(
System.out.println(
System.out.println(
System.out.println(
Würfels
(int)(Math.random()*100000)%6+1
(int)(Math.random()*100000)%6+1
(int)(Math.random()*100000)%6+1
(int)(Math.random()*100000)%6+1
);
);
);
);
}
}
c MM
Joachim Lammarsch, Rothenberg
(j000450.tex)
287
Java-Schulung
Ausgabe:
0.3141913506943965
0.5097704406491489
0.1805366288803688
0.8388583417197011
3
1
1
5
c MM
Joachim Lammarsch, Rothenberg
(j000450.tex)
288
Kapitel 11
Exceptions
11.1
Behandlung von Laufzeitfehlern
Mit den Exceptions existiert in Java ein Mechanismus zur Behandlung von Laufzeitfehlern.
Die Behandlung von Ausnahmen erfolgt mit Hilfe der try...catch-Anweisung.
Syntax:
try
{
Anweisung;
...
}
289
Java-Schulung
catch(Ausnahmetyp x)
{
Anweisung;
...
}
Der try-Block enthält eine oder mehrere Anweisungen, bei deren Ausführung eine Exception des Typs Ausnahmetyp auftreten kann. In diesem Fall wird innerhalb des catch-Blocks
fortgefahren.
c MM
Joachim Lammarsch, Rothenberg
(j000400.tex)
290
Java-Schulung
Beispielsweise ist das folgende Programm fehlerhaft:
Beispiel:
public class Exc001
{
public static void main(String[] args)
{
int a, c, i;
a=60;
for(i=4;i>=-4;i--)
{
c=a/i;
System.out.println("Quotient: " + c);
}
}
}
c MM
Joachim Lammarsch, Rothenberg
(j000400.tex)
291
Java-Schulung
Als Ausgabe erhält man:
Quotient:
Quotient:
Quotient:
Quotient:
Exception
15
20
30
60
in thread "main" java.lang.ArithmeticException:
/ by zero at Exc001.main(Exc001.java:11)
Das Programm wird abgebrochen, da versucht wird, durch die Zahl 0 zu dividieren. Dieser
Versuch löst eine Arithmetic-Exception aus.
c MM
Joachim Lammarsch, Rothenberg
(j000400.tex)
292
Java-Schulung
Durch Einschließen des Programmteils, der den Fehler verursacht, in eine try...catchAnweisung, kann dies vermieden werden.
public class Exc002
{
public static void main(String[] args)
{
int a=60, c, i;
try
{
for(i=4;i>=-4;i--)
{
c=a/i;
System.out.println("Quotient: " + c);
}
}
catch(ArithmeticException e)
{
System.out.println("Division durch Null.");
}
}
}
c MM
Joachim Lammarsch, Rothenberg
(j000400.tex)
293
Java-Schulung
Als Ausgabe erhält man:
Quotient: 15
Quotient: 20
Quotient: 30
Quotient: 60
Division durch Null.
Der Fehler tritt immer noch auf. Das Programm fängt ihn aber ab und gibt eine Fehlermeldung
aus.
c MM
Joachim Lammarsch, Rothenberg
(j000400.tex)
294
Java-Schulung
11.2
Das Fehlerobjekt
In der catch-Anweisung wird ein formaler Parameter angegeben, der beim Auftreten der
Ausnahme ein Fehlerobjekt übernehmen soll.
Dieses Objekt enthält Informationen über die Art des aufgetretenen Fehlers. Die Methode
setMessage erzeugt einen Fehlertext über die Art des aufgetretenen Fehlers, und printStackTrace gibt einen Auszug aus dem Laufzeitstack aus.
Syntax:
public String getMessage();
public void printStackTrace();
Beispiel:
public class Exc003
{
public static void main(String[] args)
{
int a, c, i;
a=60;
c MM
Joachim Lammarsch, Rothenberg
(j000400.tex)
295
Java-Schulung
try
{
for(i=4;i>=-4;i--)
{
c=a/i;
System.out.println("Quotient: " + c);
}
}
catch(ArithmeticException e)
{
System.out.println("Ein Fehler ist aufgetreten!\n" +
"Die Ursache ist: " + e.getMessage());
System.out.println("\nStacktrace:");
e.printStackTrace();
}
}
}
c MM
Joachim Lammarsch, Rothenberg
(j000400.tex)
296
Java-Schulung
Als Ausgabe erhält man:
Quotient: 15
Quotient: 20
Quotient: 30
Quotient: 60
Ein Fehler ist aufgetreten!
Die Ursache ist: / by zero
Stacktrace:
java.lang.ArithmeticException: / by zero
at Exc003.main(Exc003.java:13)
c MM
Joachim Lammarsch, Rothenberg
(j000400.tex)
297
Java-Schulung
11.3
Fortfahren von Fehlern
Tritt eine Ausnahme auf, muß nicht zwangsläufig das Programm beendet werden.
Setzt man beispielsweise alle try...catch-Anweisungen in die Schleife, fährt das Programm nach einem Fehler fort und versucht die nächste Division durchzuführen.
Beispiel:
public class Exc004
{
public static void main(String[] args)
{
int a, c, i;
a=60;
for(i=4;i>=-4;i--)
{
try
{
c=a/i;
System.out.println("Quotient: " + c);
c MM
Joachim Lammarsch, Rothenberg
(j000400.tex)
298
Java-Schulung
}
catch(ArithmeticException e)
{
System.out.println("Division durch Null.");
}
}
}
}
Als Ausgabe erhält man:
Quotient: 15
Quotient: 20
Quotient: 30
Quotient: 60
Division durch Null.
Quotient: -60
Quotient: -30
Quotient: -20
Quotient: -15
c MM
Joachim Lammarsch, Rothenberg
(j000400.tex)
299
Java-Schulung
11.4
Mehrere catch-Klauseln
Es ist möglich, daß ein Programm auf mehrere Fehler reagieren muß. Dies ist möglich, indem
man mehrere catch-Klauseln verwendet.
Jede catch-Klausel fängt die Fehler ab, die zum Typ des angegebenen Fehlerobjekts passen.
Beispiel:
public class Exc005
{
public static void main(String[] args)
{
int c, i, j;
int [] a = {60,120};
for(i=3;i>=-3;i--)
{
for(j=0;j<=2;j++)
{
try
{
c=a[j]/i;
c MM
Joachim Lammarsch, Rothenberg
(j000400.tex)
300
Java-Schulung
System.out.println("Quotient: " + c);
}
catch(ArithmeticException e1)
{
System.out.println("-- ArithmeticException: "
+ e1.getMessage());
}
catch(IndexOutOfBoundsException e2)
{
System.out.println("-- IndexOutOfBoundsException: "
+ e2.getMessage());
}
}
}
}
}
c MM
Joachim Lammarsch, Rothenberg
(j000400.tex)
301
Java-Schulung
Als Ausgabe erhält man:
Quotient: 20
Quotient: 40
-- IndexOutOfBoundsException: 2
Quotient: 30
Quotient: 60
-- IndexOutOfBoundsException: 2
Quotient: 60
Quotient: 120
-- IndexOutOfBoundsException: 2
-- ArithmeticException: / by zero
-- ArithmeticException: / by zero
-- IndexOutOfBoundsException: 2
Quotient: -60
Quotient: -120
-- IndexOutOfBoundsException: 2
Quotient: -30
Quotient: -60
-- IndexOutOfBoundsException: 2
Quotient: -20
Quotient: -40
-- IndexOutOfBoundsException: 2
c MM
Joachim Lammarsch, Rothenberg
(j000400.tex)
302
Java-Schulung
11.5
Die finally-Klausel
Die try...catch-Anweisung besitzt als optionale Möglichkeit die finally-Klausel, die
als letzter Bestandteil einer try...catch-Anweisung verwendet werden kann. Sie wird
immer aufgerufen, wenn die try-Klausel ausgeführt wurde, ganz gleich welches Ereignis
dafür verantwortlich war.
Beispiel:
public class Exc006
{
public static void main(String[] args)
{
int a=60, c, i;
try
{
for(i=4;i>=-4;i--)
{
c=a/i;
System.out.println("Quotient: " + c);
}
c MM
Joachim Lammarsch, Rothenberg
(j000400.tex)
303
Java-Schulung
}
catch(ArithmeticException e)
{
System.out.println("Division durch Null.");
}
finally
{
System.out.println("Eine Exception wurde aufgerufen.");
}
}
}
Als Ausgabe erhält man:
Quotient: 15
Quotient: 20
Quotient: 30
Quotient: 60
Division durch Null.
Eine Exception wurde aufgerufen.
c MM
Joachim Lammarsch, Rothenberg
(j000400.tex)
304
Java-Schulung
11.6
Exceptions bei der Eingabe
Bei der Eingabe wird die IOException bereits vom Java-Compiler abgefangen, d.h. wenn
keine Exception codiert wurde, wird ein Fehler erzeugt.
Beispiel:
public class Inpt01
{
public static void main(String args[])
{
char ch=’ ’;
System.out.println("Geben Sie a, b oder c!");
try
{
ch=(char)System.in.read();
}
catch(java.io.IOException e)
{
System.out.println("Fehlerhafte Eingabe!");
System.exit(4);
c MM
Joachim Lammarsch, Rothenberg
(j000400.tex)
305
Java-Schulung
}
switch(ch)
{
case ’a’:
System.out.println("Eingabe: " + ch);
break;
case ’b’:
System.out.println("Eingabe: " + ch);
break;
case ’c’:
System.out.println("Eingabe: " + ch);
break;
default:
System.out.println("falsche Eingabe: " + ch);
}
System.exit(0);
}
}
c MM
Joachim Lammarsch, Rothenberg
(j000400.tex)
306
Java-Schulung
11.7
Deklaration von Exceptions mit throws
Wenn keine explizite Behandlung mittels try und catch vorgesehen ist, müssen zumindest
die möglichen Fehler deklariert werden.
Beispiel:
public class Inpt02
{
public static void main(String args[])
throws java.io.IOException
{
char ch=’ ’;
System.out.println("Geben Sie ein Zeichen ein!");
ch=(char)System.in.read();
System.out.println("Das Zeichen ist: " + ch);
System.exit(0);
}
}
c MM
Joachim Lammarsch, Rothenberg
(j000400.tex)
307
Kapitel 12
Eingabe
12.1
Eingabe von Zeichenketten
Bei den ersten Versionen von Java gab es nur byteorientierte Datenströme. Mit Java 1.1 wurde
diese Einschränkung abgeschafft. Zusätzlich zu den byteorientierten Klassen InputStream
und OutputStream wurden die zeichenorientierten Klassen Reader und Writer eingeführt.
Beispiel:
import java.io.*;
public class Zkin01
308
Java-Schulung
{
public static void main(String args[])
{
InputStreamReader inrd=new InputStreamReader(System.in);
BufferedReader bfrd=new BufferedReader(inrd);
String strg= new String();
try
{
do
{
System.out.print("> ");
strg=bfrd.readLine();
System.out.println("Echo: " + strg);
}
while((strg!=null)&(strg.length()>0));
}
catch (IOException e)
{
System.out.println("Fehler bei der Eingabe.");
System.exit(4);
c MM
Joachim Lammarsch, Rothenberg
(j000420.tex)
309
Java-Schulung
}
System.exit(0);
}
}
Als Ausgabe erhält man:
> Das
Echo:
> Das
Echo:
> Das
Echo:
>
Echo:
c MM
ist
Das
ist
Das
ist
Das
die
ist
die
ist
die
ist
1. Zeile
die 1. Zeile
2. Zeile
die 2. Zeile
3. Zeile
die 3. Zeile
Joachim Lammarsch, Rothenberg
(j000420.tex)
310
Java-Schulung
12.2
Lesen von Dateien
Wenn man Dateien einlesen möchte, kann man ebenfalls mit BufferedReader arbeiten.
Allerdings wird dieser auf einem FileReader aufgesetzt.
Beispiel:
import java.io.*;
public class Dain01
{
public static void main(String args[])
{
String strg= new String();
if(args.length<1)
System.exit(2);
try
{
FileReader fird=new FileReader(args[0]);
BufferedReader bfrd=new BufferedReader(fird);
c MM
Joachim Lammarsch, Rothenberg
(j000420.tex)
311
Java-Schulung
while( (strg=bfrd.readLine()) != null)
{
System.out.println(strg);
}
}
catch (IOException e)
{
if(e instanceof FileNotFoundException)
System.out.println("Datei existiert nicht.");
else
System.out.println("Fehler bei der Eingabe.");
System.exit(4);
}
System.exit(0);
}
}
c MM
Joachim Lammarsch, Rothenberg
(j000420.tex)
312
Kapitel 13
Erstellung eigener Pakete
Hierzu wird die Anweisung package verwendet, die als erste Anweisung im Programm
stehen muß.
package Paketname;
Beispiel:
Datei A.java im Unterverzeichnis demo:
package demo;
public class A
{
313
Java-Schulung
public void hello()
{
System.out.println("Hier ist A");
}
}
c MM
Joachim Lammarsch, Rothenberg
(j000500.tex)
314
Java-Schulung
Datei B.java im Unterverzeichnis demo:
package demo;
public class B
{
public void hello()
{
System.out.println("Hier ist B");
}
}
Datei C.java im Unterverzeichnis demo/tools:
package demo.tools;
public class C
{
public void hello()
{
System.out.println("Hier ist C");
}
}
c MM
Joachim Lammarsch, Rothenberg
(j000500.tex)
315
Java-Schulung
Hauptprogramm – Datei paket.java:
import demo.*;
import demo.tools.*;
public class paket
{
public static void main(String[] args)
{
(new A()).hello();
(new B()).hello();
(new C()).hello();
}
}
Es genügt die Datei paket.java zu übersetzen, der Compiler übersetzt automatisch alle
noch nicht übersetzten Quellen und bindet die entstehenden class-Dateien ein.
c MM
Joachim Lammarsch, Rothenberg
(j000500.tex)
316
Java-Schulung
13.1
Das Default-Paket
In Java gibt es ein Default-Paket, welches genau dann verwendet wird, wenn keine anderen
Paket-Zuordnungen für eine Klasse getroffen wurden. Die Klassen des Default-Paketes können ohne explizite import-Anweisung verwendet werden. Jedes beliebige Unterverzeichnis
kann die Rolle des Default-Paketes übernehmen, d.h. es können beliebig viele Default-Pakete
erzeugt werden.
13.2
Das public-Attribut
Damit eine Klasse A eine andere Klasse B einbinden darf, muß eine der beiden folgenden
Bedingungen erfüllt sein:
• entweder gehören A und B zu demselben Paket oder
• die Klasse B wurde als public deklariert.
Wenn nur Default-Pakete verwendet werden, liegen beide Klassen im selben Paket und die
public-Deklaration ist überflüssig. Werden jedoch Klassen aus externen Paketen eingebunden, so müssen diese public sein.
c MM
Joachim Lammarsch, Rothenberg
(j000500.tex)
317
Java-Schulung
13.3
Namensraum von Paketen
Basierend auf der Plattformunabhängigkeit von Java wurde für die Pakete ein Namensraum
definiert, der internetweit mögliche Namenskollisionen von Klassen und Paketen vermeiden
soll. Dazu wird die jeweilige Internet-Domain des Unternehmens in umgekehrter Reihenfolge
vor den Paketnamen gestellt.
Bei einem Unternehmen Namens markt.de heißt also die Klasse
wirtschaft.personal
dann vollständig
de.markt.wirtschaft.personal
Dies bedingt natürlich, daß sich das Paket wirtschaft beispielsweise im Verzeichnis
usr/classes/de/markt/wirtschaft
befindet.
Ganz offensichtlich lassen sich verschiedene Abteilungen des Unternehmens ebenfalls problemlos in diesem Namensraum abbilden.
c MM
Joachim Lammarsch, Rothenberg
(j000500.tex)
318
Kapitel 14
Attribute von Klassen, Methoden und Variablen
Die Attribute definieren die Eigenschaften von Klassen, Methoden und Variablen. Sie haben
insbesondere Einfluß auf Lebensdauer, Sichtbarkeit und Veränderbarkeit dieser Elemente.
14.1
private
• Elemente des Typs privat sind lediglich in der Klasse selbst sichtbar. Für abgeleitete Klassen und für Aufrufer von Objekten der Klasse (Instanzen) bleiben privateVariablen und -Methoden verdeckt.
• privat-Elemente sollten immer dann verwendet werden, wenn implementierungsabhängige Details zu verstecken sind, die auch in abgeleiteten Klassen nicht sichtbar sein
sollen.
319
Java-Schulung
14.2
protected
• Elemente des Typs protected sind in der Klasse selbst und in abgeleiteten Klassen
sichtbar. Für Aufrufer von Objekten der Klasse (Instanzen) sind protected-Variablen
und -Methoden nur dann verwendbar, wenn sie in dem selben Paket definiert wurden.
• protected-Elemente sind vor Zugriffen von außen geschützt, können aber von abgeleiteten Klassen verwendet werden.
• Werden Variablen und Methoden ohne eines der drei Attribute private, protected
oder public definiert, so entspricht ihr Verhalten im wesentlichen dem von Elementen
des Typs protected.
14.3
public
• Elemente des Typs public sind im Rahmen ihrer Lebensdauer überall sichtbar. Sie
können daher von den Methoden in der eigenen Klasse und von beliebigen anderen
Klassen verwendet werden. Das Attribut public ist zusätzlich auch bei der Klassendefinition selbst von Bedeutung, denn nur Klassen, die als public definiert wurden, sind
außerhalb des Paketes sichtbar, in dem sie definiert wurden.
• public-Elemente bilden die für alle sichtbaren Teile einer Klassendefinition und können daher als ihre Schnittstelle angesehen werden. In jeder Quelldatei darf nur eine Klasc MM
Joachim Lammarsch, Rothenberg
(j000600.tex)
320
Java-Schulung
se mit dem Attribut public angelegt werden.
14.4
static
• Varaiblen und Methoden mit dem Attribut public sind nicht an die Existenz eines konkreten Objekts gebunden, sonder existieren vom Laden der Klasse bis zum Beenden des
Programms. Das static-Attribut beeinflußt bei Instanzmerkmalen ihre Lebensdauer
und erlaubt bei Methoden den Aufruf, ohne daß der Aufrufer ein Objekt der Klasse besitzt, in der die Methode definiert wurde.
• Wird das Attribut static nicht verwendet, so sind Varaiblen innerhalb einer Klasse
immer an eine konkrete Instanz gebunden. Ihre Lebensdauer beginnt mit dem Anlegen
des Objekts und dem Aufruf eines Konstruktors und endet mit der Freigabe des Objekts
durch den Garbage Collector.
14.5
final
• Variablen mit dem Attribut final dürfen nicht verändert werden, sind also als Konstanten anzusehen. Methoden des Typs final dürfen nicht überlagert werden; ebensowenig
dürfen Klassen des Typs final zur Ableitung neuer Klassen verwendet werden.
• Falls eine Methode oder Klasse das Attribut final besitzt kann der Compiler in der Regel
c MM
Joachim Lammarsch, Rothenberg
(j000600.tex)
321
Java-Schulung
auf die dynamische Methodensuche verzichten, final-Methoden können daher schneller aufgerufen werden als normale Methoden. Einige der bei Java mitgelieferten Klassen
sind aus diesem Grund als final deklariert, ein Beispiel hierfür ist die Klasse String.
Dies führt aber gleichzeitig dazu, daß diese Klassen nicht mehr erweitert werden können.
c MM
Joachim Lammarsch, Rothenberg
(j000600.tex)
322
Kapitel 15
Die Wrapper-Klassen
Zu jedem primitiven Datentyp gibt es eine korrespondierende Wrapper-Klasse. Diese kapselt
die primitive Variable in einer objektorientierten Hülle und stellt eine Reihe von Methoden
zum Zugriff auf die Variable zur Verfügung. Die Anwendung einer Wrapper-Klasse kann
sinnvoll sein, bei der
• Übergabe von Objekten per Referenz an eine Methode, damit lassen sich Parameter aus
Methoden an den Aufrufer zurückgeben,
• Erweiterung des Pakets java.util. Hierin werden eine Reihe von Verbundklassen
zur Verfügung gestellt, die beliebige Objekte speichern können. Für elementare Typen
müssen anstelle der primitiven Typen ihre Wrapper-Klassen verwendet werden.
Wrapper-Klassen existieren zu allen numerischen Typen und zu den Typen char und boolean.
323
Java-Schulung
15.1
Korrespondierende primitive Typen
Wrapper-Klasse
Byte
Short
Integer
Long
Double
Float
Boolean
Character
Void
15.2
Primitiver Typ
byte
short
int
long
double
float
boolean
char
void
Instanzierung der Wrapper-Klasse
Die Instanzierung einer Wrapper-Klasse kann meist auf zwei unterschiedliche Arten erfolgen:
• Übergabe des korrespondierenden primitiven Typs an den Konstruktor, um ein Objekt
desselben Wertes zu erzeugen,
• Übergabe eines Strings an den Konstruktor und anschließende Konvertierung in den gewünschten primitiven Typ, um damit die Wrapper-Klasse zu initialisieren.
c MM
Joachim Lammarsch, Rothenberg (j000600.tex)
324
Java-Schulung
15.3
Konstruktoren
public Integer(int i);
public Integer(String s);
throws NumberFormatException;
public Long(long l);
public Long(String s);
throws NumberFormatException;
public Float(float f);
public Float(double d);
public Float(String s);
throws NumberFormatException;
public Double(double d);
public Double(String s);
throws NumberFormatException;
public Boolean(boolean b);
public Boolean(String s);
c MM
Joachim Lammarsch, Rothenberg
(j000600.tex)
325
Java-Schulung
public Character(char c);
15.4
Rückgabe eines Wertes
Wie man sieht besitzen die meisten Wrapper-Klassen zwei Methoden, um einen Wert zurückzugeben.
• Eine Methode liefert den Wert passend zum korrespondierenden Grundtyp.
Hierzu wird ein Name bestehend aus dem Basistyp und der Erweiterung Value gebildet, z.B. intValue, charValue, booleanValue. Die numerischen Methoden
intValue, longValue, floatValue und doubleValue stehen dabei für alle
numerischen Wrapper-Klassen zur Verfügung.
• Die andere Methode liefert den Wert als String, ihr Name ist toString. Sie steht in
allen Wrapper-Klassen zur Verfügung.
public
public
public
public
public
public
c MM
boolean booleanValue();
char charValue();
int intValue();
long longValue();
float floatValue();
double doubleValue();
Joachim Lammarsch, Rothenberg
(j000600.tex)
326
Java-Schulung
public String toString();
15.5
Numerische Konstanten
Die numerische Wrapper-Klassen stellen Konstanten zur Bezeichnung spezieller Elemente
zur Verfügung. Es gibt in jeder der Klassen Byte, Short, Integer, Long, Float und
Double die Konstanten MIN_VALUE und MAX_VALUE, die das kleinste bzw. größte Element des Wertebereichs wiedergeben. In den Klassen Float und Double gibt es zusätzlich
die Konstanten NEGATIVE_INFINITY, POSITIVE_INFINITY und NaN. Sie stellen die
Werte −∞, +∞ und „undefiniert“ dar.
c MM
Joachim Lammarsch, Rothenberg
(j000600.tex)
327
Kapitel 16
Interfaces (Schnittstellen)
Interfaces dienen dazu Methodendeklarationen von mehreren Klassen zu vererben.
Ein Interface ist ein besondere Form einer Klasse, die ausschließlich die Definition von Methoden und Konstanten enthält, nicht aber ihre Implementierung, sogenannte abstrakte Objekte.
Syntax:
public interface Interface-Name
{
...
}
328
Java-Schulung
Beispiel:
public interface Forbewegungsmittel
{
public int kapazitaet();
public double kilometerpreis();
}
c MM
Joachim Lammarsch, Rothenberg
(j000600.tex)
329
Java-Schulung
Das Interface muß in der Klasse implementiert werden, hier zu dient der Befehl implement.
Hierbei wird überprüft, ob zu allen abstrakten Methoden auch die zugehörigen Implentationen
vorhanden sind.
Syntax:
public class Klassen-Name
implements Interface-Name
{
...
}
c MM
Joachim Lammarsch, Rothenberg
(j000600.tex)
330
Java-Schulung
Beispiel:
public class Auto
implements Forbewegungsmittel
{
public String name;
public int
erstzulassung;
public int
leistung;
public int
anzahlsitze;
public double spritverbrauch;
public double spritpreis;
public int kapazitaet();
{
return anzahlsitze;
}
public double kilometerPreis();
{
return spritverbrauch*spritpreis/100;
}
}
c MM
Joachim Lammarsch, Rothenberg
(j000600.tex)
331
Java-Schulung
Ebenso wie die Klasse Auto könnte auch jede andere Klasse das Interface Fortbewegungsmittel implementieren und Konkretisierungen der beiden Methode vornehmen. Eine andere Klasse, die in keinem Zusammenhang mit der Klasse Auto und ihrer Vererbungshierarchie steht, könnte ebenfalls das Interface implementieren, beispielsweise die Klasse
Teppich.
Weiter gilt:
• Auch abgeleitete Klassen können Interfaces implementieren.
• Eine Klasse kann eine beliebige Anzahl von Interfaces implementieren.
• Interfaces lassen sich vererben.
Interfaces kann man als Typvereinbarung ansehen. Eine Klasse, die dieses Interface implementiert ist dann vom Typ dieses Interfaces. Wegen der Mehrfachvererbung von Interfaces
kann eine Instanzvariable damit insbesondere mehrere Typen haben und zu mehr als einem
Typen zuweisungskompatibel sein.
c MM
Joachim Lammarsch, Rothenberg
(j000600.tex)
332
Java-Schulung
16.1
Konstanten in Interfaces
Neben abstrakten Methoden können Interfaces auch Konstanten, also Variablen mit den Attributen static oder final, enthalten. Mit der Implementierung dieses Interfaces in einer
Klasse, erbt sie alle diese Konstanten.
In einem größeren Programm mit sehr vielen Konstanten kann es nützlich sein, alle Konstantendefinitionen aus den einzelnen Klassen in einem Interface zusammenzufassen. Die Konstanten können dann statt mit Klasse.Name direkt mit ihrem Namen aufgerufen werden.
c MM
Joachim Lammarsch, Rothenberg
(j000600.tex)
333
Kapitel 17
Applets
Statt der Methode main() bei Java-Applikationen wird für Applets die Steuerung verschiedener Ereignisse beispielsweise Initialisierung, Bildschirmausgabe, Tastatur- und Mausbewegungen benötigt. Diese Interaktion muß mit dem Browser erfolgen, der die entsprechenden
Methoden aufrufen muß. Daher sind alle Applets Ableitungen der Klasse Applet, die die
Methoden als Platzhalter vordefiniert hat.
Syntax:
public
public
public
public
void
void
void
void
init() { ... }
start() { ... }
stop() { ... }
destroy() { ... }
334
Java-Schulung
17.1
Applets und der Internet-Browser
Benutzeraktion im Browser
Starte Browser
Lade HTML-Seite
Verlasse HTML-Seite
Lade HTML-Seite erneut
Beende Browser
c MM
Joachim Lammarsch, Rothenberg
Browseraktion mit Applet (Methoden)
–
Init, Start
Stop
Start
Stop, Destroy
(j000700.tex)
335
Java-Schulung
Java-Programme (Applikationen) und Java-Applets unterscheiden sich gar nicht so stark voneinander. Sie werden mit denselben Werkzeugen und Techniken konstruiert. Vereinfacht kann
man sagen, daß
• Java-Applikationen sind eigenständige Programme sind, die zur Ausführung den StandAlone-Java-Interpreter benötigen,
• während Java-Applets werden aus HTML-Seiten heraus aufgerufen und benötigen zur
Ausführung einen Web-Browser.
Die Kommunikation zwischen einem Applet und seinem Browser läuft über Methodenaufrufe ab. Die aus dem Applet abgeleitete Klasse ist dafür verantwortlich die Methoden zu
überlagern und mit der erforderlichen Funktionalität auszustatten.
17.1.1
Instanzierung des Applets
Hierzu ruft der Browser ein Objekt der abgeleiteten Applet-Klasse auf, den parameterlosen
Default-Konstruktor:
Syntax:
public Applet();
c MM
Joachim Lammarsch, Rothenberg
(j000700.tex)
336
Java-Schulung
17.1.2
Initialisierung des Applets
Nach der Instanzierung ruft der Browser die Methode init auf, um dem Applet die Möglichkeit zu geben, Initialisierungen vorzunehmen:
Syntax:
public void init();
17.1.3
Starten des Applets
Nachdem die Initialisierung abgeschlossen ist, wird die Methode start aufgerufen, um die
Ausführung des Applets zu starten:
Syntax:
public void start();
Das Starten eines Applets kann mehrfach erfolgen. Wenn der Browser eine andere Web-Seite
lädt, wird das Applet nur gestoppt. Beim erneuten Aufruf der Seite wird die Methode start
erneut aufgerufen.
c MM
Joachim Lammarsch, Rothenberg
(j000700.tex)
337
Java-Schulung
17.1.4
Stoppen des Applets
Durch Aufrufen der Methode stop zeigt der Browser dem Applet an, daß es gestoppt werden
soll:
Syntax:
public void stop();
Da ein Applet mehrfach gestartet und gestoppt werden darf, dürfen keine Resourcen entfernt
werden, die bei einem eventuellen Neustart wieder benötigt werden.
17.1.5
Zerstören des Applets
Wenn ein Applet nicht mehr benötigt wird, beispielsweise beim Beenden des Browsers, ruft
der Browser die Methode destroy auf:
Syntax:
public void destroy();
Diese kann überlagert werden, um auch noch Aufräumarbeiten zu erledigen.
c MM
Joachim Lammarsch, Rothenberg
(j000700.tex)
338
Java-Schulung
17.1.6
Einbinden eines Applets
Die Einbindung eines Applets in ein HTML-Dokument erfolgt unter Verwendung des AppletTags.
Syntax:
<APPLET CODE="Klassenname.class" WIDTH=nnn HEIGHT=nnn>
Falls das Applet nicht aufgerufen werden kann erscheint
dieser Text.
</APPLET>
c MM
Joachim Lammarsch, Rothenberg
(j000700.tex)
339
Java-Schulung
17.2
Ein erstes Beispiel
17.2.1
Der Java-Kode
import java.awt.*;
public class Appl01 extends java.applet.Applet
{
public void init()
{
super.init();
System.out.println("Init()");
}
public void start()
{
System.out.println("Start()");
}
public void stop()
{
System.out.println("Stop()");
c MM
Joachim Lammarsch, Rothenberg
(j000700.tex)
340
Java-Schulung
}
public void destroy()
{
System.out.println("Destroy()");
}
public void paint()
{
System.out.println("Paint()");
}
}
c MM
Joachim Lammarsch, Rothenberg
(j000700.tex)
341
Java-Schulung
17.2.2
Zugehöriger HTML-Code
<HTML>
<HEAD>
<TITLE> Hello! </TITLE>
</HEAD>
<BODY>
Hier ist unser Test:
<p>
<APPLET CODE="Appl01.class" WIDTH=500 HEIGHT=300>
</APPLET>
</BODY>
</HTML>
c MM
Joachim Lammarsch, Rothenberg
(j000700.tex)
342
Java-Schulung
17.3
Ein zweites Beispiel
Beispiel:
import java.awt.*;
public class Helo01 extends java.applet.Applet
{
public void paint (Graphics g)
{
g.drawString("Hallo, viel Erfolg mit Java!",50,100);
}
}
c MM
Joachim Lammarsch, Rothenberg
(j000700.tex)
343
Java-Schulung
17.4
Schriften
Veränderungen der Schrift sowie Schriftgröße und Schriftart geschehen mittels des FontObjekts.
Syntax:
Font name = new Font("schriftname", Font.schriftart, groesse);
In der Methode paint wird die Schrift aktiviert. Ebenso kann eine andere Farbe gewählt
werden.
Syntax:
g.setFont(name)
g.setColor(Color.farbe)
c MM
Joachim Lammarsch, Rothenberg
(j000700.tex)
344
Java-Schulung
Beispiel:
import java.awt.*;
public class Helo02 extends java.applet.Applet
{
Font f = new Font("TimesRoman",Font.BOLD,36);
public void paint(Graphics g)
{
g.setFont(f);
g.setColor(Color.red);
g.drawString("Hallo Applet!",5,40);
}
}
c MM
Joachim Lammarsch, Rothenberg
(j000700.tex)
345
Java-Schulung
Beispiel:
import java.awt.*;
public
{
Font
Font
Font
Font
class Text03 extends java.applet.Applet
f = new Font("TimesRoman",Font.PLAIN,36);
fb = new Font("TimesRoman",Font.BOLD,36);
fi = new Font("TimesRoman",Font.ITALIC,36);
fbi = new Font("TimesRoman",Font.BOLD+Font.ITALIC,36);
public void paint(Graphics g)
{
g.setFont(f);
g.drawString("Normal",10,50);
g.setFont(fb);
g.drawString("Fett",10,100);
g.setFont(fi);
g.drawString("Schräg",10,150);
g.setFont(fbi);
g.drawString("Fett und Schräg",10,200);
} }
c MM
Joachim Lammarsch, Rothenberg
(j000700.tex)
346
Java-Schulung
17.5
Parameterübergabe
Die Übergabe von Parametern an Applets erfolgt in zwei Teilen durch eine Zeichenkette mit
einem frei wählbaren Namen und dem Wert des Parameters.
Syntax:
name = getParameter ("name")
Wird kein Parameterwert in der HTML-Datei definiert, gibt getParamter den Wert null
zurück.
Beispiel:
import java.awt.*;
public class Helo03 extends java.applet.Applet
{
Font f = new Font("TimesRoman",Font.BOLD,18);
String name;
public void init()
{
c MM
Joachim Lammarsch, Rothenberg
(j000700.tex)
347
Java-Schulung
name=getParameter("name");
if (name==null)
name="Java-Programmierer";
name="Hallo " + name + "!";
}
public void paint(Graphics g)
{
g.setFont(f);
g.setColor(Color.blue);
g.drawString(name,5,40);
}
}
c MM
Joachim Lammarsch, Rothenberg
(j000700.tex)
348
Java-Schulung
wird aufgerufen mit
<HTML>
<HEAD>
<TITLE> Hello! </TITLE>
</HEAD>
<BODY>
Hier ist unser Test:
<p>
<APPLET CODE="Helo03.class" WIDTH=300 HEIGHT=150>
</APPLET>
<p>
<APPLET CODE="Helo03.class" WIDTH=300 HEIGHT=150>
<PARAM NAME=name VALUE="Kursleiter">
</APPLET>
</BODY>
</HTML>
c MM
Joachim Lammarsch, Rothenberg
(j000700.tex)
349
Java-Schulung
17.6
Verwendung von Farben
Veränderungen der Farbe geschieht mit der Klasse Color. Java verwendet ein abstraktes
Farbmodell mit 24 Bit Farbtiefe, um Farben als Gemisch aus den Grundtönen Rot, Grün
und Blau darzustellen (RGB-Modell). Jede Komponente kann einen Wert zwischen 0 und
255 annehmen. Das abstrakte Farbmodell von Java wird auf das Farbmodell der Plattform
abgebildet, auf der das Applet läuft.
Syntax:
Color.farbname
Color name = new Color(rotwert, grünwert, blauwert)
c MM
Joachim Lammarsch, Rothenberg
(j000700.tex)
350
Java-Schulung
Objekt-Name
Color.white
Color.black
Color.gray
Color.lightGray
Color.darkGray
Color.red
Color.green
Color.blue
Color.yellow
Color.magenta
Color.cyan
Color.pink
Color.orange
c MM
Joachim Lammarsch, Rothenberg
Farbe
Weiß
Schwarz
Grau
Hellgrau
Dunkelgrau
Rot
Grün
Blau
Gelb
Magenta
Cyan
Rosa
Orange
(j000700.tex)
RGB-Wert
255, 255, 255
0, 0, 0
128, 128, 128
192, 192, 192
64, 64, 64
255, 0, 0
0, 255, 0
0, 0, 255
255, 255, 0
255, 0, 255
0, 255, 255
255, 175, 175
255, 200, 0
351
Java-Schulung
Beispiel:
import java.awt.*;
public class Farb01 extends java.applet.Applet
{
Dimension dim;
public void init()
{
dim=getSize();
System.out.println("Breite: " + dim.width +
", Höhe: " + dim.height);
}
public void paint(Graphics g)
{
int i,j,rval,gval,bval;
for(i=25;i<dim.height-30;i+=30)
for(j=25;j<dim.width-30;j+=30)
{
c MM
Joachim Lammarsch, Rothenberg
(j000700.tex)
352
Java-Schulung
rval=(int)Math.floor(Math.random()*256);
gval=(int)Math.floor(Math.random()*256);
bval=(int)Math.floor(Math.random()*256);
g.setColor(new Color(rval,gval,bval));
g.fillRect(j,i,25,25);
g.setColor(Color.black);
g.drawRect(j,i,25,25);
}
}
}
c MM
Joachim Lammarsch, Rothenberg
(j000700.tex)
353
Java-Schulung
17.7
Figuren
Beispiel 1:
import java.awt.*;
public class Figu01 extends java.applet.Applet
{
public void paint(Graphics g)
{
g.drawRect(50,50,400,200);
g.drawRect(80,60,100,50);
g.setColor(Color.red);
g.fillRect(200,60,100,50);
g.setColor(Color.green); g.fillRect(320,60,100,50);
g.setColor(Color.black); g.drawOval(80,125,100,50);
g.setColor(Color.cyan);
g.fillOval(225,125,50,50);
g.setColor(Color.pink);
g.fillOval(320,125,100,50);
g.setColor(Color.black);
g.drawRoundRect(80,190,100,50,20,20);
g.setColor(Color.yellow);
g.fillRoundRect(200,190,100,50,40,40);
g.setColor(Color.blue);
c MM
Joachim Lammarsch, Rothenberg
(j000700.tex)
354
Java-Schulung
g.fillRoundRect(320,190,100,50,100,50);
}
}
c MM
Joachim Lammarsch, Rothenberg
(j000700.tex)
355
Java-Schulung
Beispiel 2:
import java.awt.*;
public class Figu02 extends java.applet.Applet
{
public void paint(Graphics g)
{
g.drawRect(50,50,400,200);
g.setColor(Color.green);
for(int i=60;i<=240;i+=10)
g.drawLine(60,i,440,i);
for(int i=60;i<=440;i+=10)
g.drawLine(i,60,i,240);
g.setColor(Color.red);
Polygon pg1 = new Polygon();
pg1.addPoint(80,80);
pg1.addPoint(100,120);
pg1.addPoint(140,120);
pg1.addPoint(180,80);
g.drawPolygon(pg1);
c MM
Joachim Lammarsch, Rothenberg
(j000700.tex)
356
Java-Schulung
Polygon pg2 = new Polygon();
pg2.addPoint(280,80);
pg2.addPoint(260,120);
pg2.addPoint(340,120);
pg2.addPoint(420,80);
g.fillPolygon(pg2);
g.drawArc(80,160,100,60,0,360);
g.drawArc(200,160,100,60,30,270);
g.fillArc(320,160,100,60,30,270);
}
}
c MM
Joachim Lammarsch, Rothenberg
(j000700.tex)
357
Java-Schulung
17.7.1
Befehle für Figuren
g.drawLine(x-start, y-start, x-ende, y-ende)
g.drawRect(x-linke-ecke, y-linke-ecke, breite, höhe)
g.fillRect(x-linke-ecke, y-linke-ecke, breite, höhe)
g.drawRoundRect(x-ecke-l, y-ecke-l, breite, höhe, r1, r2)
g.fillRoundRect(x-ecke-l, y-ecke-l, breite, höhe, r1, r2)
g.draw3DRect(x-ecke-l, y-ecke-l, breite, höhe, boolean)
g.drawPolygon(x1, x2, ..., y1, y2, ..., anzahl)
g.drawOval(x-linke-ecke, y-linke-ecke, breite, höhe)
g.fillOval(x-linke-ecke, y-linke-ecke, breite, höhe)
g.drawArc(x-start, y-start, breite, höhe, winkel, wbereich)
g.fillArc(x-start, y-start, breite, höhe, winkel, wbereich)
objektname.addPoint(x, y)
g.copyarea(x-quelle, y-quelle, breite, höhe, x-ziel, y-ziel)
g.clearRect(x-linke-ecke, y-linke-ecke, breite, höhe)
c MM
Joachim Lammarsch, Rothenberg
(j000700.tex)
358
Java-Schulung
17.8
Einbinden von Bildern
Beispiel:
import java.awt.*;
import java.net.*;
public class Bild01 extends java.applet.Applet
{
Image bild;
URL url;
Dimension dim;
public void init()
{
System.out.println("INIT - Anfang");
try
{
url=new URL(getCodeBase(), "images/world.gif");
}
catch(MalformedURLException e)
c MM
Joachim Lammarsch, Rothenberg
(j000700.tex)
359
Java-Schulung
{
System.out.println(e);
}
System.out.println("URL: " + url);
bild=getImage(url);
System.out.println("INIT - Ende");
}
public void paint(Graphics g)
{
int iw=bild.getWidth(this);
int ih=bild.getHeight(this);
g.drawImage(bild,30,30,iw,ih,this);
g.drawImage(bild,30,180,iw*2,ih*2,this);
g.drawImage(bild,220,30,iw*4,ih*4,this);
}
}
c MM
Joachim Lammarsch, Rothenberg
(j000700.tex)
360
Java-Schulung
17.9
Threads
Beispiel:
import java.awt.*;
import java.util.*;
public class Zeit01 extends java.applet.Applet
implements Runnable
{
Font theFont = new Font("TimesRoman",Font.BOLD,24);
GregorianCalendar theDate;
Thread runner;
public void start()
{
if(runner==null)
{
runner=new Thread(this);
runner.start();
}
}
c MM
Joachim Lammarsch, Rothenberg
(j000700.tex)
361
Java-Schulung
public void stop()
{
if(runner!=null)
{
runner.stop();
runner=null;
}
}
public void run()
{
while(true)
{
repaint();
try
{
Thread.sleep(1000);
}
catch(InterruptedException e)
{
System.out.println(e);
c MM
Joachim Lammarsch, Rothenberg
(j000700.tex)
362
Java-Schulung
}
}
}
public void paint(Graphics g)
{
theDate=new GregorianCalendar();
g.setFont(theFont);
g.drawString(" " + theDate.getTime(), 10, 50);
}
}
c MM
Joachim Lammarsch, Rothenberg
(j000700.tex)
363
Java-Schulung
17.10
Ereignisse
Beispiel mit Schaltknöpfen:
import java.awt.*;
public class Butt01 extends java.applet.Applet
{
public void init()
{
Button bu1 = new Button("Taste1");
Button bu2 = new Button("Taste2");
Button bu3 = new Button("Taste3");
add(bu1);
add(bu2);
add(bu3);
}
}
c MM
Joachim Lammarsch, Rothenberg
(j000700.tex)
364
Java-Schulung
Beispiel 2:
import java.awt.*;
import java.awt.event.*;
public class
{
Button bu1
Button bu2
Button bu3
Butt02 extends java.applet.Applet
= new Button("Taste1");
= new Button("Taste2");
= new Button("Taste3");
Label l = new Label("
");
class Bl implements ActionListener
{
public void actionPerformed(ActionEvent e)
{
l.setText("Die " + e.getActionCommand() +
" wurde angeklickt!.");
}
}
Bl al = new Bl();
c MM
Joachim Lammarsch, Rothenberg
(j000700.tex)
365
Java-Schulung
public void init()
{
add(bu1);
bu1.addActionListener(al);
add(bu2);
bu2.addActionListener(al);
add(bu3);
bu3.addActionListener(al);
add(l);
}
}
c MM
Joachim Lammarsch, Rothenberg
(j000700.tex)
366
Java-Schulung
Beispiel 3:
import java.awt.*;
import java.awt.event.*;
public class Pan001 extends java.applet.Applet
{
TextField tx1 = new TextField("Textfeld1",20);
TextField tx2 = new TextField("Textfeld2",20);
TextField tx3 = new TextField("Textfeld3",20);
Checkbox kr1 = new Checkbox("Markierung1");
Checkbox kr2 = new Checkbox("Markierung2");
Checkbox kr3 = new Checkbox("Markierung3");
Button bu1 = new Button("Taste1");
Button bu2 = new Button("Taste2");
Button bu3 = new Button("Taste3");
Label la1 = new Label("Label1");
Label la2 = new Label("Label2");
Label la3 = new Label("Label3");
c MM
Joachim Lammarsch, Rothenberg
(j000700.tex)
367
Java-Schulung
Choice aw1 = new Choice();
Choice aw2 = new Choice();
Choice aw3 = new Choice();
class Tl implements ActionListener
{
public void actionPerformed(ActionEvent e)
{
System.out.println("\nTextfeld-Ereignis:");
System.out.println(e.getActionCommand());
System.out.println(e.getModifiers());
System.out.println(e.paramString());
}
}
Tl tl = new Tl();
class Il implements ItemListener
{
public void itemStateChanged(ItemEvent e)
{
System.out.println("\nAnkreuzfeld-Ereignis:");
c MM
Joachim Lammarsch, Rothenberg
(j000700.tex)
368
Java-Schulung
System.out.println(e.getItem());
System.out.println(e.getItemSelectable());
System.out.println(e.getStateChange());
System.out.println(e.paramString());
}
}
Il il = new Il();
class Bl implements ActionListener
{
public void actionPerformed(ActionEvent e)
{
System.out.println("\nSchaltaste-Ereignis:");
System.out.println(e.getActionCommand());
System.out.println(e.getModifiers());
System.out.println(e.paramString());
}
}
Bl al = new Bl();
class Cl implements ItemListener
{
c MM
Joachim Lammarsch, Rothenberg
(j000700.tex)
369
Java-Schulung
public void itemStateChanged(ItemEvent e)
{
System.out.println("\nAuswahlfeld-Ereignis:");
System.out.println(e.getItem());
System.out.println(e.getItemSelectable());
System.out.println(e.getStateChange());
System.out.println(e.paramString());
}
}
Cl cl = new Cl();
public void init()
{
add(la1);
add(tx1);
tx1.addActionListener(tl);
add(kr1);
kr1.addItemListener(il);
add(bu1);
bu1.addActionListener(al);
add(la2);
c MM
Joachim Lammarsch, Rothenberg
(j000700.tex)
370
Java-Schulung
add(tx2);
tx2.addActionListener(tl);
add(kr2);
kr2.addItemListener(il);
add(bu2);
bu2.addActionListener(al);
add(la3);
add(tx3);
tx3.addActionListener(tl);
add(kr3);
kr3.addItemListener(il);
add(bu3);
bu3.addActionListener(al);
aw1.addItem("Möglichkeit
aw1.addItem("Möglichkeit
aw1.addItem("Möglichkeit
aw1.addItem("Möglichkeit
add(aw1);
aw1.addItemListener(cl);
aw2.addItem("Möglichkeit
c MM
Joachim Lammarsch, Rothenberg
(j000700.tex)
1-1");
1-2");
1-3");
1-4");
2-1");
371
Java-Schulung
aw2.addItem("Möglichkeit
aw2.addItem("Möglichkeit
aw2.addItem("Möglichkeit
add(aw2);
aw2.addItemListener(cl);
aw3.addItem("Möglichkeit
aw3.addItem("Möglichkeit
aw3.addItem("Möglichkeit
aw3.addItem("Möglichkeit
add(aw3);
aw3.addItemListener(cl);
2-2");
2-3");
2-4");
3-1");
3-2");
3-3");
3-4");
}
}
c MM
Joachim Lammarsch, Rothenberg
(j000700.tex)
372
Java-Schulung
Beispiel 4:
import java.awt.*;
import java.awt.event.*;
public class Sreg01 extends java.applet.Applet
{
// Anlegen der Beschriftungen
Scrollbar sc1 = new Scrollbar(Scrollbar.VERTICAL,0,1,0,15);
Scrollbar sc2 = new Scrollbar(Scrollbar.VERTICAL,0,1,0,15);
Scrollbar sc3 = new Scrollbar(Scrollbar.VERTICAL,0,1,0,15);
class Sl1 implements AdjustmentListener
{
public void adjustmentValueChanged(AdjustmentEvent e)
{
System.out.println("\nScrollfeld-Ereignis 1:");
System.out.println(e.getAdjustable());
System.out.println(e.getAdjustmentType());
System.out.println(e.paramString());
System.out.println(e.getValue());
}
c MM
Joachim Lammarsch, Rothenberg
(j000700.tex)
373
Java-Schulung
}
Sl1 sl1 = new Sl1();
class Sl2 implements AdjustmentListener
{
public void adjustmentValueChanged(AdjustmentEvent e)
{
System.out.println("\nScrollfeld-Ereignis 2:");
System.out.println(e.getAdjustable());
System.out.println(e.getAdjustmentType());
System.out.println(e.paramString());
System.out.println(e.getValue());
}
}
Sl2 sl2 = new Sl2();
class Sl3 implements AdjustmentListener
{
public void adjustmentValueChanged(AdjustmentEvent e)
{
System.out.println("\nScrollfeld-Ereignis 3:");
System.out.println(e.getAdjustable());
c MM
Joachim Lammarsch, Rothenberg
(j000700.tex)
374
Java-Schulung
System.out.println(e.getAdjustmentType());
System.out.println(e.paramString());
System.out.println(e.getValue());
}
}
Sl3 sl3 = new Sl3();
public void init()
{
add(sc1);
sc1.addAdjustmentListener(sl1);
add(sc2);
sc2.addAdjustmentListener(sl2);
add(sc3);
sc3.addAdjustmentListener(sl3);
}
}
c MM
Joachim Lammarsch, Rothenberg
(j000700.tex)
375
Inhaltsverzeichnis
1
Einleitung
1.1 Geschichte . . . . . . . . . . . . . . . . . . .
1.2 Was ist Java? . . . . . . . . . . . . . . . . .
1.3 Wie arbeitet Java? . . . . . . . . . . . . . . .
1.4 Einführungsbeispiel 1 . . . . . . . . . . . . .
1.5 Einführungsbeispiel 1b . . . . . . . . . . . .
1.6 Einführungsbeispiel 1c . . . . . . . . . . . .
1.7 Der Zeichensatz . . . . . . . . . . . . . . . .
1.8 Besondere Zeichen- und Zeichenkettenobjekte
1.9 Einführungsbeispiel 2 . . . . . . . . . . . . .
1.10 Einführungsbeispiel 2b . . . . . . . . . . . .
1.11 Bearbeitung eines Java-Programms . . . . . .
376
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
6
6
8
9
10
14
16
18
19
20
25
28
Java-Schulung
I
Prozedurale Programmierung mit Java
29
2
Bezeichner, Variablen, Kommentare
2.1 Bezeichner . . . . . . . . . . . . .
2.2 Variablen . . . . . . . . . . . . . .
2.2.1 Initialisierung von Variablen
2.2.2 Schlüsselworte . . . . . . .
2.3 Kommentare . . . . . . . . . . . . .
2.3.1 Zeilenkommentare . . . . .
2.3.2 Blockkommentare . . . . .
2.3.3 HTML-Kommentare . . . .
.
.
.
.
.
.
.
.
30
30
32
33
34
35
36
37
38
.
.
.
.
.
.
.
.
.
40
40
41
47
49
49
50
51
53
54
3
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
Datentypen und Konstanten
3.1 Datentypen . . . . . . . . . . . . . . . . . . . .
3.1.1 Ganze Zahlen . . . . . . . . . . . . . . .
3.1.2 Gleitkomma-Zahlen (Gleitpunkt-Zahlen)
3.1.3 Boolsche Zahlen . . . . . . . . . . . . .
3.1.4 Zeichen . . . . . . . . . . . . . . . . . .
3.2 Datentyp-Umwandlungen . . . . . . . . . . . . .
3.2.1 Aufwand für Konvertierungen . . . . . .
3.3 Literale . . . . . . . . . . . . . . . . . . . . . .
3.3.1 Ganzzahlige Konstanten . . . . . . . . .
c MM
Joachim Lammarsch, Rothenberg
(toc)
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
377
Java-Schulung
.
.
.
.
.
.
55
56
57
58
59
60
.
.
.
.
.
.
.
.
.
.
.
63
63
65
68
69
70
71
74
74
76
79
93
Verzweigungen
5.1 Entscheidungen . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . .
94
94
3.4
4
5
3.3.2 Gleitkomma-Konstanten . . . . . . . . . .
3.3.3 Zeichen-Konstanten . . . . . . . . . . . .
3.3.4 Zeichenketten-Konstanten . . . . . . . . .
3.3.5 Boolsche Konstanten . . . . . . . . . . . .
Parameter bei main . . . . . . . . . . . . . . . . .
3.4.1 Konvertierung der Zeichenketten args[n]
Operatoren
4.1 Zuweisungsoperator (=) . . . . . . . . . . . . .
4.2 Arithmetische Operatoren . . . . . . . . . . . .
4.2.1 Arithmetik von Gleitkommazahlen . . .
4.2.2 Verkürzte Schreibweisen . . . . . . . .
4.2.3 Inkrement- und Dekrement-Operatoren
4.2.4 Prefix- und Postfix-Operatoren . . . . .
4.3 Vergleichsoperatoren . . . . . . . . . . . . . .
4.4 Logische Operatoren . . . . . . . . . . . . . .
4.4.1 Wahrheitstafeln . . . . . . . . . . . . .
4.4.2 Bitweise Operatoren . . . . . . . . . .
4.4.3 Verkürzte logische Operatoren . . . . .
c MM
Joachim Lammarsch, Rothenberg
(toc)
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
378
Java-Schulung
5.2
6
5.1.1 if-Anweisung . . . . . . . . . . . . . . . . . . . .
5.1.2 if-else-Anweisung . . . . . . . . . . . . . . . .
5.1.3 Bedingte Ausdrücke . . . . . . . . . . . . . . . . .
5.1.4 Geschachtelte if- oder if...else-Anweisungen
5.1.5 switch-Anweisung . . . . . . . . . . . . . . . . . .
Wiederholungen . . . . . . . . . . . . . . . . . . . . . . . .
5.2.1 while-Anweisung . . . . . . . . . . . . . . . . . .
5.2.2 Geschachtelte while-Anweisungen . . . . . . . . .
5.2.3 do ... while-Anweisung . . . . . . . . . . . .
5.2.4 Geschachtelte do ... while-Anweisungen . . .
5.2.5 for-Anweisung . . . . . . . . . . . . . . . . . . .
5.2.6 Geschachtelte for-Anweisungen . . . . . . . . . .
5.2.7 Weitere Anwendungen für Schleifen . . . . . . . . .
5.2.8 Die Anweisung break . . . . . . . . . . . . . . . .
5.2.9 Die Anweisung continue . . . . . . . . . . . . .
5.2.10 Benannte Schleifen . . . . . . . . . . . . . . . . . .
Felder (Arrays oder Vektoren)
6.1 Anlegen eines Feldes . . . . . . .
6.1.1 Deklaration eines Feldes .
6.1.2 Allokierung eines Feldes .
6.1.3 Initialisierung eines Feldes
c MM
Joachim Lammarsch, Rothenberg
(toc)
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
95
97
104
107
110
118
119
125
128
134
137
144
147
155
160
163
.
.
.
.
168
170
170
171
172
379
Java-Schulung
6.2
6.3
6.1.4 Gleichzeitiges Initialisieren und Anlegen eines Feldes
Schleifen und Felder . . . . . . . . . . . . . . . . . . . . . .
6.2.1 Beispiel: Sieb des Eratosthenes . . . . . . . . . . . .
6.2.2 Zeitmessung: Sieb des Eratosthenes . . . . . . . . . .
Schleifen und mehrdimensionale Felder . . . . . . . . . . . .
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
173
177
179
194
202
II
Objektorientierte Programmierung mit Java
207
7
Java und Klassen
7.1 Deklaration einer Klasse . . . . . . . . . . . . . . .
7.1.1 Deklarationen von Attributen in einer Klasse
7.1.2 Deklarationen von Methoden in einer Klasse
7.1.3 Instanzierung von Objekten . . . . . . . . .
7.1.4 Konstruktoren . . . . . . . . . . . . . . . . .
7.1.5 Übergabe bzw. Rückgabe von Objekten . . .
209
211
212
213
222
232
240
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
8
Pakete
248
8.1 Verwendung von Paketen . . . . . . . . . . . . . . . . . . . . . . . . . . . . 249
8.2 Vordefinierte Pakete . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 251
9
Zeichenketten
252
9.1 Statische Zeichenketten . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 253
c MM
Joachim Lammarsch, Rothenberg
(toc)
380
Java-Schulung
9.2
9.1.1 Konstruktoren . . .
9.1.2 Methoden . . . . .
Dynamische Zeichenketten
9.2.1 Konstruktoren . . .
9.2.2 Methoden . . . . .
10 Mathematische Methoden
10.1 Winkelfunktionen . . . .
10.2 Minimum und Maximum
10.3 Arithmetik . . . . . . . .
10.4 Runden und Abschneiden
10.5 Zufallszahlen . . . . . .
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
11 Exceptions
11.1 Behandlung von Laufzeitfehlern . . . . .
11.2 Das Fehlerobjekt . . . . . . . . . . . . .
11.3 Fortfahren von Fehlern . . . . . . . . . .
11.4 Mehrere catch-Klauseln . . . . . . . .
11.5 Die finally-Klausel . . . . . . . . . .
11.6 Exceptions bei der Eingabe . . . . . . . .
11.7 Deklaration von Exceptions mit throws
c MM
Joachim Lammarsch, Rothenberg
(toc)
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
253
254
270
270
271
.
.
.
.
.
277
278
280
282
284
287
.
.
.
.
.
.
.
289
289
295
298
300
303
305
307
381
Java-Schulung
12 Eingabe
308
12.1 Eingabe von Zeichenketten . . . . . . . . . . . . . . . . . . . . . . . . . . . 308
12.2 Lesen von Dateien . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 311
13 Erstellung eigener Pakete
13.1 Das Default-Paket . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . .
13.2 Das public-Attribut . . . . . . . . . . . . . . . . . . . . . . . . . . . . . .
13.3 Namensraum von Paketen . . . . . . . . . . . . . . . . . . . . . . . . . . .
313
317
317
318
14 Attribute von Klassen, Methoden und Variablen
14.1 private . . . . . . . . . . . . . . . . . . . . .
14.2 protected . . . . . . . . . . . . . . . . . . .
14.3 public . . . . . . . . . . . . . . . . . . . . .
14.4 static . . . . . . . . . . . . . . . . . . . . . .
14.5 final . . . . . . . . . . . . . . . . . . . . . .
.
.
.
.
.
319
319
320
320
321
321
.
.
.
.
.
323
324
324
325
326
327
15 Die Wrapper-Klassen
15.1 Korrespondierende primitive Typen
15.2 Instanzierung der Wrapper-Klasse .
15.3 Konstruktoren . . . . . . . . . . . .
15.4 Rückgabe eines Wertes . . . . . . .
15.5 Numerische Konstanten . . . . . . .
c MM
Joachim Lammarsch, Rothenberg
(toc)
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
382
Java-Schulung
16 Interfaces (Schnittstellen)
328
16.1 Konstanten in Interfaces . . . . . . . . . . . . . . . . . . . . . . . . . . . . 333
17 Applets
17.1 Applets und der Internet-Browser .
17.1.1 Instanzierung des Applets
17.1.2 Initialisierung des Applets
17.1.3 Starten des Applets . . . .
17.1.4 Stoppen des Applets . . .
17.1.5 Zerstören des Applets . .
17.1.6 Einbinden eines Applets .
17.2 Ein erstes Beispiel . . . . . . . . .
17.2.1 Der Java-Kode . . . . . .
17.2.2 Zugehöriger HTML-Code
17.3 Ein zweites Beispiel . . . . . . . .
17.4 Schriften . . . . . . . . . . . . . .
17.5 Parameterübergabe . . . . . . . .
17.6 Verwendung von Farben . . . . .
17.7 Figuren . . . . . . . . . . . . . .
17.7.1 Befehle für Figuren . . . .
17.8 Einbinden von Bildern . . . . . .
17.9 Threads . . . . . . . . . . . . . .
c MM
Joachim Lammarsch, Rothenberg
(toc)
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
334
335
336
337
337
338
338
339
340
340
342
343
344
347
350
354
358
359
361
383
Java-Schulung
17.10Ereignisse . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 364
c MM
Joachim Lammarsch, Rothenberg
(toc)
384
Java-Schulung
c MM
Joachim Lammarsch, Rothenberg
(toc)
385
Java-Schulung
c MM
Joachim Lammarsch, Rothenberg
(toc)
386
Java-Schulung
c MM
Joachim Lammarsch, Rothenberg
(toc)
387
Java-Schulung
c MM
Joachim Lammarsch, Rothenberg
(toc)
388
Java-Schulung
c MM
Joachim Lammarsch, Rothenberg
(toc)
389
Java-Schulung
c MM
Joachim Lammarsch, Rothenberg
(toc)
390
Java-Schulung
c MM
Joachim Lammarsch, Rothenberg
(toc)
391
Java-Schulung
c MM
Joachim Lammarsch, Rothenberg
(toc)
392