Teil I Prozedurale Programmierung mit Java - Urz

Java-Schulung 

Teil I 

Prozedurale Programmierung mit Java 

c○ MMI Joachim u. Marion Lammarsch, Rothenberg () P–1


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 

c○ MMI Joachim u. Marion Lammarsch, Rothenberg (j000080.tex) P–2


• alle Zeichen des Unicode-Zeichensatzes oberhalb 00C0 

als Bestandteile von Bezeichnern. Das erste Zeichen darf keine Ziffer sein und das Dollar- 

Zeichen ($) darf nur am Anfang stehen. 

Beispiel für erlaubte Bezeichner: 

kilometerstand 

kmstd 

zahl_1 

Beispiel für unerlaubte Bezeichner: 

kilometer-stand 

km/Std 

1_zahl 



Folgende Namenskonventionen werden empfohlen: 

• Klassennamen: erster Buchstabe groß, restliche klein 

• Variablennamen: Kleinbuchstaben 

• Methodennamen: Kleinbuchstaben 

• Konstante Variablen: Großbuchstaben 

Des weiteren hat es sich eingebürgert, zusammengesetzte Namen in einer gemischten Schreibweise 

zu verwenden. 

Beispiel: 

kilometerStand 

kmStd 

zahlEins 



2.2 Variablen 

Mittels Variablen können Daten im Hauptspeicher eines Rechners abgelegt werden. Java unterscheidet 

drei Arten von Variablen: 

• Lokale Variablen 

existieren nur innerhalb einer Methode oder eines Blocks und zwar nur so lange, bis das 

Ende der Methode oder des Blocks erreicht ist. 

• Klassenvariablen 

werden in einer Klassendefinition angelegt, sind aber unabhängig von Objekten. Sie existieren 

während der gesamten Laufzeit des Programms. 

• Objektvariablen 

werden durch eine Klassenbeschreibung definiert und bei erzeugen eines Objekts abgelegt. 

Sie existieren, solange das Objekt existiert. 

Variablen müssen vor ihrer ersten Verwendung initialisiert werden. In Java wird dies als Definite 

Assignment bezeichnet und vom Compiler erzwungen. 



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. 

• Es ist nicht möglich, Namen zu überlagern. 



Beispiel 1: 

1 public class Var001 

2 { 

3 public static void main(String args[]) 

4 { 

5 int a; 

6 a=1234; 

7 { 

8 int b; 

9 b=5678; 

10 System.out.println(a + " " + b); 

11 } 

12 System.out.println(a + " " + b); 

13 } 

14 } 

ergibt folgende Fehlermeldung: 

Var001.java:12: Undefined variable: b 

System.out.println(a + " " + b); 

^ 

1 error 



Beispiel 2: 

1 public class Var002 

2 { 


4 { 

5 int a; 

6 a=1234; 

7 { 

8 int a; 

9 a=5678; 

10 System.out.println(a); 

11 } 

12 System.out.println(a); 

13 } 

14 } 

ergibt folgende Fehlermeldung: 

Var002.java:8:Variable ’a’ is already defined in this method. 

int a; 

^ 

1 error 



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; 



2.2.2 Schlüsselworte 

Java definiert eine Reihe von Schlüsselworten, die man nicht als eigene Variablennamen verwenden 

darf: 

abstract boolean break byte byvalue case 

cast catch char class const continue 

default do double else extends false 

final finally float for future generic 

goto if implements import inner instanceof 

int interface long native new null 

operator outer package private protected public 

rest return short static super switch 

synchronized this threadsafe throw throws transient 

true try var void volatile while 



2.3 Kommentare 

Kommentare dienen der besseren Übersichtlichkeit und bieten eine gewisse Sicherheit dafür, 

dass 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. 



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 1: 

Beispiel 2: 

// Länge eines Marathonlaufs in Kilometer 

... 

// Länge eines Marathonlaufs 

// Berechnet wird bei Angabe von Meilen und Yards 

// die Länge in Kilometer 

... 



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, der sich über 

mehrere Zeilen erstreckt. */ 

... 



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. Er kann über 

einen längeren Text gehen. Die erste Satz wird in die 

’Method Summary’ übernommen. 

*/ 

public static void main(String args[]) 

{ 

System.out.println("Das ist ein Test."); 

} 

} 



Class Tree Deprecated Index Help 

PREV CLASS NEXT CLASS 

SUMMARY: INNER | FIELD | CONSTR | METHOD 

FRAMES NO FRAMES 

DETAIL: FIELD | CONSTR | METHOD 

Class test6 

java.lang.Object 

| 

+--test6 

public class test6 

extends java.lang.Object 

Constructor Summary 

test6() 

Method Summary 

static void main(java.lang.String[] args) 

Dieser Kommentar ist für die HTML-Dokumentation. 

Methods inherited from class java.lang.Object 

clone, equals, finalize, getClass, hashCode, notify, notifyAll, toString, wait, 

wait, wait 

Constructor Detail 

test6 

public test6() 

Method Detail 

main 

public static void main(java.lang.String[] args) 



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, 

• es sind nicht beliebige automatische Typumwandlungen möglich. 



3.1.1 Ganze Zahlen 

1. byte 

Größe: 8 bit (1 Byte), 

Bereich: −128 bis 127 

2. short 


Bereich: −32 768 bis 32 767 

3. int 


Bereich: −2 147 483 648 bis 2 147 483 647 

4. long 


Bereich: −9 223 372 036 854 775 808 bis 9 223 372 036 854 775 807 

Ganze Zahlen sind exakt und intern im binären Datenformat gespeichert. 



Den Zahlenbereich der einzelnen Datentypen erhält man, wenn man die Werte folgender Konstanten 

ausgibt: 

• Beim Datentyp byte 

Byte.MIN_VALUE 

Byte.MAX_VALUE 

• Beim Datentyp short 

Short.MIN_VALUE 

Short.MAX_VALUE 

• Beim Datentyp int 

Integer.MIN_VALUE 

Integer.MAX_VALUE 

• Beim Datentyp long 

Long.MIN_VALUE 

Long.MAX_VALUE 



Beispiel: 

1 public class Lim_gz 

2 { 


4 { 

5 System.out.println("Minimum und Maximum bei Byte:\n" + 

6 Byte.MIN_VALUE + ", " + 

7 Byte.MAX_VALUE + "\n"); 

8 System.out.println("Minimum und Maximum bei Short:\n" + 

9 Short.MIN_VALUE + ", " + 

10 Short.MAX_VALUE + "\n"); 

11 System.out.println("Minimum und Maximum bei Integer:\n" + 

12 Integer.MIN_VALUE + ", " + 

13 Integer.MAX_VALUE + "\n"); 

14 System.out.println("Minimum und Maximum bei Long:\n" + 

15 Long.MIN_VALUE + ", " + 

16 Long.MAX_VALUE + "\n"); 

17 

18 System.exit(0); 

19 } 

20 } 



Als Ausgabe erhält man: 

Minimum und Maximum bei Byte: 

-128, 127 

Minimum und Maximum bei Short: 

-32768, 32767 

Minimum und Maximum bei Integer: 

-2147483648, 2147483647 

Minimum und Maximum bei Long: 

-9223372036854775808, 9223372036854775807 



3.1.2 Ausgabe von ganzen Zahlen 

Um ganze Zahlen auszugeben, müssen diese in Zeichenketten umgewandelt werden. Es stehen 

nachfolgend beschriebene Methoden zur Verfügung. 

3.1.2.1 Datentyp Integer 

Integer.toString(n) 

Integer.toBinaryString(n) 

Integer.toHexString(n) 

Integer.toOctalString(n) 

Umwandlung ins Dezimalzahlensystem 

Umwandlung ins Dualzahlensystem 

Umwandlung ins Hexadezimalzahlensystem 

Umwandlung ins Oktalzahlensystem 

n ist die ganze Zahl, die umgewandelt werden soll. 

Bei der Ausgabe an den Bildschirm wird die Methode Integer.toString implizit aufgerufen. 

Beispiel: 

1 public class ConvInt 

2 { 


4 { 

5 int i = 123456789; 

6 System.out.println("Dezimal: " + i); 



7 System.out.println("Dezimal: " + 

8 Integer.toString(i)); 

9 System.out.println("Binär: " + 

10 Integer.toBinaryString(i)); 

11 System.out.println("Oktal: " + 

12 Integer.toOctalString(i)); 

13 System.out.println("Hexadezimal: " + 

14 Integer.toHexString(i)); 


16 } 

17 } 


Dezimal: 123456789 

Dezimal: 123456789 

Binär: 111010110111100110100010101 

Oktal: 726746425 

Hexadezimal: 75bcd15 



3.1.2.2 Datentyp Long 

Long.toString(n) 

Long.toBinaryString(n) 

Long.toHexString(n) 

Long.toOctalString(n) 


Umwandlung ins Dualzahlensystem 

Umwandlung ins Hexadezimalzahlensystem 

Umwandlung ins Oktalzahlensystem 


Bei der Ausgabe an den Bildschirm wird die Methode Long.toString implizit aufgerufen. 

Beispiel: 

1 public class ConvLong 

2 { 


4 { 

5 long i = 987654321; 

6 System.out.println("Dezimal: " + i); 

7 System.out.println("Dezimal: " + 

8 Long.toString(i)); 

9 System.out.println("Binär: " + 

10 Long.toBinaryString(i)); 



11 System.out.println("Oktal: " + 

12 Long.toOctalString(i)); 

13 System.out.println("Hexadezimal: " + 

14 Long.toHexString(i)); 


16 } 

17 } 


Dezimal: 987654321 

Dezimal: 987654321 

Binär: 111010110111100110100010110001 

Oktal: 7267464261 

Hexadezimal: 3ade68b1 



3.1.2.3 Datentyp Byte 

Byte.toString(n) 



Bei der Ausgabe an den Bildschirm wird die Methode Byte.toString implizit aufgerufen. 

Beispiel: 

1 public class ConvByte 

2 { 


4 { 

5 byte i = 123; 

6 System.out.println("Dezimal: " + i + 

7 " und " + Byte.toString(i)); 


9 } 

10 } 


Dezimal: 123 und 123 



3.1.2.4 Datentyp Short 

Short.toString(n) 



Bei der Ausgabe an den Bildschirm wird die Methode Short.toString implizit aufgerufen. 

Beispiel: 

1 public class ConvShort 

2 { 


4 { 

5 short i = 12345; 

6 System.out.println("Dezimal: " + i + 

7 " und " + Short.toString(i)); 


9 } 

10 } 


Dezimal: 12345 und 12345 



3.1.3 Gleitkomma-Zahlen (Gleitpunkt-Zahlen) 

1. float 

Größe: 32 bit (4 Byte) 

Bereich: 1,4 · 10 −45 bis 3,4 · 10 38 

Genauigkeit: 6 Dezimalstellen 

2. double 


Bereich: 4,9 · 10 −324 bis 1,7 · 10 308 

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 



Beispiel: 

1 public class Lim_gl 

2 { 


4 { 

5 System.out.println(Float.MIN_VALUE + ", " + 

6 Float.MAX_VALUE); 

7 System.out.println(Double.MIN_VALUE + ", " + 

8 Double.MAX_VALUE); 


10 } 

11 } 


1.4E-45, 3.4028235E38 

4.9E-324, 1.7976931348623157E308 



3.1.4 Boolsche Zahlen 

boolean 


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.5 Zeichen 

char 


Java verwendet den Unicode zur Zeichendarstellung (http://unicode.com). 



3.2 Datentyp-Umwandlungen 

Typ-Umwandlungen wandeln einen Datentyp in einen anderen um. Diesen Vorgang bezeichnet 

man als Casting. 

Syntax: 

Beispiel: 

(datentyp) ausdruck 

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. 



3.2.1 Aufwand für Konvertierungen 

nach 

Datentyp byte short char int long float double 

byte 0 1 2 3 4 7 8 

short A 0 A 1 2 5 6 

von char B A 0 1 2 5 6 

int C B A 0 1 4 5 

long D C B A 0 3 4 

float G F E D C 0 1 

double H G F E D A 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 (je höher die Zahl oder der Buchstabe, desto höher der Aufwand). 



Beispiel: 

1 public class Cast01 

2 { 


4 { 

5 int i=1,j=2; 

6 

7 System.out.println(1/2 + " " + 1./2.); 

8 System.out.println(i/j + " " + (float)i/(float)j); 

9 System.out.println((float)1/(float)2); 


11 } 

12 } 


0 0.5 

0 0.5 

0.5 



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. 



3.3.1 Ganzzahlige Konstanten 

• Sie sind standardmäßig vom Datentyp int. 

• Den Datentyp long kann man immer erhalten, wenn man an die Zahl den Buchstaben 

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 // int 

5000000000 // long 

1234L 

// long 

0777 // oktal 

0xAD3F 

// hexadezimal 



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 // doppelt genau 

1234.45f // einfach genau 

1234.45d // doppelt genau 

1234.45E-67 

// mit Exponent 



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’ 

// Ein Zeichen 

’ ’ // Ein Leerzeichen 

’0’ // Das Zeichen Null 



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." // Zeichenkette 

"" // Leere Zeichenkette 

"\n" 

// Neue Zeile 



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 

// wahr 

// falsch 



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. 



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. 



Beispiel: 

1 public class Aust01 

2 { 


4 { 

5 int v1, v2, h; 

6 

7 v1 = Integer.valueOf(args[0]).intValue(); 


9 

10 System.out.println("Vor dem Tauschen: \n\n" + 

11 " v1: " + v1 + "\n v2: " + v2 + "\n"); 

12 h=v1; 

13 v1=v2; 

14 v2=h; 

15 

16 System.out.println("Nach dem Tauschen: \n\n" + 

17 " v1: " + v1 + "\n v2: " + v2 + "\n"); 


19 } 

20 } 




Vor dem Tauschen: 

v1: 10 

v2: 20 

Nach dem Tauschen: 

v1: 20 

v2: 10 



4.2 Arithmetische Operatoren 

Java besitzt fünf Operatoren für die Arithmetik: 

+ Addition 3 + 4 

− Subtraktion 9 - 6 

* Multiplikation 7 * 8 

/ Division 9 / 2 

% Modulus 9 % 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. 



Beispiel: 

1 public class Beisp04 

2 { 


4 { 

5 int var_1=50, var_2=20, 

6 var_3, var_4, var_5, var_6, var_7; 

7 

8 var_3 = var_1 + var_2; 

9 var_4 = var_1 - var_2; 

10 var_5 = var_1 * var_2; 

11 var_6 = var_1 / var_2; 

12 var_7 = var_1 % var_2; 

13 System.out.println(var_3 + " " + var_4 + " " + 

14 var_5 + " " + var_6 + " " + var_7); 

15 


17 } 

18 } 


70 30 1000 2 10 



• Alle arithmetischen ganzzahligen Operationen werden mit 32 Bit Genauigkeit ausgeführt, 

im Falle langer ganzer Zahlen long mit 64 Bit. 

• Möchte man ein ganzzahliges 32- oder 64-Bit-Ergebnis in eine kleinere Variable abspeichern, 

muss es in den entsprechenden Datentyp konvertiert werden. 

• byte- und short-Zuweisungen müssen immer angepasst 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-2 n -Arithmetik. 

• Ein Fehler wird nur bei Division durch Null angezeigt. 



Beispiel Zahlenkreis: 

1 public class Beisp05 

2 { 


4 { 

5 byte zahl=0; 

6 

7 System.out.println("(1): " + zahl); 

8 zahl = (byte)(zahl + 127); 








16 


18 } 

19 } 




(1): 0 

(2): 127 

(3): -128 

(4): -1 

(5): 0 



4.2.1 Arithmetik von Gleitkommazahlen 

• Die Operationen sind Addition, Subtraktion, Multiplikation und Division. 

• Eine Division durch Null ergibt keinen Fehler. 

Beispiel: 

1 /* Länge des Marathonlaufs in Kilometer */ 

2 public class Beisp03b 

3 { 


5 { 

6 int meilen,yards; 

7 double kilometer; 

8 

9 meilen=26; 

10 yards=385; 

11 

12 kilometer=1.609*(meilen+yards/1760.0); 

13 System.out.println("Die Länge des Marathonlaufs " + 

14 "beträgt " + kilometer + " km."); 




16 } 

17 } 


Die Länge des Marathonlaufs beträgt 42.18596875 km. 



4.2.2 Verkürzte Schreibweisen 

Java unterstützt ebenfalls die Kurzschreibweise arithmetischer Ausdrücke. Da relativ oft die 

Form 

operand 1 = operand 1 operator operand 2 

auftritt, wird vorzugsweise die verkürzte Schreibweise 

eingesetzt. 

operand 1 operator = operand 2 

Angewendet wird diese Schreibweise bei folgenden Operatoren: 

Symbol Operation Kurzform Langform 

+ Addition n += 10 n = n + 10 

− Subtraktion n -= 10 n = n - 10 

* Multiplikation n *= 10 n = n * 10 

/ Division n /= 10 n = n / 10 

% Modulus n %= 10 n = n % 10 



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. 

auftritt, wird die verkürzte Schreibweise 

operand = operand - 1; 

operand ++; oder ++ operand; 

bzw. 

benutzt. 

operand --; oder -- operand; 

• 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. 



4.2.3.1 Prefix- und Postfix-Schreibweise 

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; 

y=j; 

j=j-1; 



Beispiel: 

1 public class Oper01 

2 { 


4 { 

5 int var_1=10, var_2=20; 

6 float var_3=5.4321F, var_4=1.2345F; 

7 

8 var_1 *= var_2; 

9 System.out.println("var_1: " + var_1); 

10 var_2++; 


12 var_3--; 


14 var_3 = ++var_4; 


16 


18 } 

19 } 




var_1: 200 

var_2: 21 

var_3: 4.4321 

var_4: 2.2345 



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 Bedeutung Beispiel 

== Gleich a == 10 

!= Ungleich a != 10 

< Kleiner als a < 10 

> Größer als a > 10 

= 10 



4.4 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: 

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. 



Beispiel: 

1 public class Logi01 

2 { 


4 { 

5 int a=0,b=2,c=3,x=0,y=4,z=5; 

6 boolean aa; 

7 

8 

9 // UND-Verknüpfung mit &: 

10 

11 aa=(a=b+c)


21 // UND-Verknüpfung mit &&: 

22 

23 aa=(a=b+c)


4.4.1 Wahrheitstafeln 

4.4.1.1 Und-Operator (&& und &) 

Operand 1 Operand 2 Ergebnis 

wahr wahr wahr 

wahr falsch falsch 

falsch wahr falsch 

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. 



4.4.1.2 Oder-Operator (|| und |) 


wahr wahr wahr 

wahr falsch wahr 

falsch wahr wahr 


• 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. 



4.4.1.4 Exklusiv-Oder-Operator (ˆ) 


wahr wahr falsch 

wahr falsch wahr 

falsch wahr wahr 


• 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. 



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. 



4.4.2.1 Die Verschiebungsoperatoren 


> Verschiebung nach rechts 

>>> Verschiebung nach rechts mit Füllnullen 

• Bei der Verschiebung mit >2 entspricht der Division durch 4, 

usw.) 

• Bei der Verschiebung mit >>> nach rechts werden die freien Stellen links mit Nullen 

aufgefüllt. 



Beispiel: 

1 public class Shft01 

2 { 


4 { 

5 int i,x,y,z,t; 

6 

7 i = Integer.valueOf(args[0]).intValue(); 

8 x = i 2; 

11 t = i >>> 3; 

12 

13 System.out.println(i + ", " + Integer.toBinaryString(i)); 

14 System.out.println(x + ", " + Integer.toBinaryString(x)); 

15 System.out.println(y + ", " + Integer.toBinaryString(y)); 

16 System.out.println(z + ", " + Integer.toBinaryString(z)); 

17 System.out.println(t + ", " + Integer.toBinaryString(t)); 


19 } 

20 } 



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 0000 0000 0000 0000 0000 0010 0000 0000 

1024 0000 0000 0000 0000 0000 0100 0000 0000 

2048 0000 0000 0000 0000 0000 1000 0000 0000 

128 0000 0000 0000 0000 0000 0000 1000 0000 

64 0000 0000 0000 0000 0000 0000 0100 0000 




java Shft01 -1 


-1, 11111111111111111111111111111111 

-2, 11111111111111111111111111111110 

-4, 11111111111111111111111111111100 

-1, 11111111111111111111111111111111 

536870911, 11111111111111111111111111111 

bzw. vollstständig ausgeschrieben (mit führenden Nullen): 

-1 1111 1111 1111 1111 1111 1111 1111 1111 

-2 1111 1111 1111 1111 1111 1111 1111 1110 

-4 1111 1111 1111 1111 1111 1111 1111 1100 

-1 1111 1111 1111 1111 1111 1111 1111 1111 

536870911 0001 1111 1111 1111 1111 1111 1111 1111 



4.4.2.2 Der Negationsoperator 

Operator 

˜ 

Bedeutung 

Bitweises Komplement 

• Der unäre Negationsoperator ˜ invertiert jedes Bit seines Operanden. 

Beispiel: 

1 public class Komp01 

2 { 


4 { 

5 int i=512,x; 

6 

7 x = ~i; 

8 




12 } 

13 } 




512, 1000000000 

-513, 11111111111111111111110111111111 

bzw. vollständig ausgeschrieben (mit führenden Nullen): 

512 0000 0000 0000 0000 0000 0010 0000 0000 

-513 1111 1111 1111 1111 1111 1101 1111 1111 



4.4.2.3 Die binären Operatoren 


& 

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. 



Beispiel: 

1 public class Biop01 

2 { 


4 { 

5 int i=1111, j=-2222, x; 

6 

7 x = i & j; 

8 


10 System.out.println(j + ", " + Integer.toBinaryString(j)); 


12 


14 } 

15 } 




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 



Beispiel: 


2 { 


4 { 

5 int i=1111, j=-2222, x; 

6 

7 x = i | j; 

8 




12 


14 } 

15 } 




1111, 10001010111 

-2222, 11111111111111111111011101010010 

-2217, 11111111111111111111011101010111 


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 



Beispiel: 


2 { 


4 { 

5 int i=1111, j=-2222, x; 

6 

7 x = i ^ j; 

8 




12 


14 } 

15 } 




1111, 10001010111 

-2222, 11111111111111111111011101010010 

-3323, 11111111111111111111001100000101 


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 



4.4.3 Verkürzte logische Operatoren 

Java unterstützt ebenfalls die Kurzschreibweise logischer Ausdrücke. Da relativ oft die Form 

operand 1 = operand 1 operator operand 2 

auftritt, wird vorzugsweise die verkürzte Schreibweise 

operand 1 operator = operand 2 

eingesetzt. 

Angewendet wird diese Schreibweise bei folgenden Operatoren: 

Symbol Operation Kurzform Langform 

= 10 n = n >> 10 

>>> Verschiebung nach rechts n >>>= 10 n = n >>> 10 

mit Füllnullen 

& Bitweises Und n &= 10 n = n & 10 

| Bitweises Oder n |= 10 n = n | 10 

ˆ Bitweises Exclusiv-Oder n ^= 10 n = n ^ 10 



Kapitel 5 

Verzweigungen 

5.1 Entscheidungen 

Entscheidungen treffen heisst eine Bedingung zu prüfen, um dann, abhängig vom Ergebnis 

der Überprüfung, mit dem einen oder anderen Programmteil fortzufahren. 



5.1.1 if-Anweisung 

Bei diesem Befehl werden eine oder mehrere Anweisungen ausgeführt, wenn die Bedingung 

war ist. 

Syntax: 

oder 

if (bedingung) 

anweisung; 


{ 

anweisung_1; 

anweisung_2; 

... 

anweisung_n; 

} 



Beispiel: 

1 public class Verif01 

2 { 


4 { 

5 int v1,v2; 

6 



9 

10 if(v1==v2) 

11 System.out.println("Die Zahlen sind gleich."); 


13 } 

14 } 


java Verif01 10 10 


Die Zahlen sind gleich. 



Beispiel: 

1 public class Verel11 

2 { 


4 { 

5 int v1; 

6 


8 

9 if(v1


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: 

oder 


anweisung_1; 

else 

anweisung_2; 


{ 

anweisung_a_1; 

anweisung_a_n; 

} 

else 

{ 

anweisung_b_1; 

anweisung_b_n; 

} 



Beispiel: 

1 public class Verif02 

2 { 


4 { 

5 int v1,v2; 

6 



9 

10 if(v1==v2) 

11 System.out.println("Die Zahlen sind gleich."); 

12 else 

13 System.out.println("Die Zahlen sind nicht gleich."); 

14 


16 } 

17 } 



Beispiel: 


2 { 


4 { 

5 int v1; 

6 


8 

9 if(v1


Außerdem kann auch eine ganze Serie von Bedingungen geprüft werden. 

if (bedingung_1) 

anweisung_1; 

else if (bedingung_2) 

anweisung_2; 


anweisung_3; 


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. 



Beispiel: 


2 { 


4 { 

5 int v1; 

6 


8 

9 if(v10) 

12 System.out.println("Die Zahl ist positiv."); 

13 else 

14 System.out.println("Die Zahl ist Null."); 

15 


17 } 

18 } 



Beispiel: 


2 { 


4 { 

5 int v1; 

6 


8 

9 if(v1==1) 

10 System.out.println("Die Zahl ist Eins."); 

11 else if(v1==2) 

12 System.out.println("Die Zahl ist Zwei."); 

13 else if(v1==3) 

14 System.out.println("Die Zahl ist Drei."); 

15 else 

16 System.out.println("Die Zahl ist ungleich 1, 2, 3."); 

17 


19 } 

20 } 



Es ergibt sich beispielsweise folgender Dialog bei der Ausführung: 

x92@pc:/j000160 > java Verel03 1 

Die Zahl ist Eins. 


Die Zahl ist Zwei. 


Die Zahl ist Drei. 


Die Zahl ist ungleich 1, 2, 3. 


Die Zahl ist ungleich 1, 2, 3. 



5.1.3 Bedingte Ausdrücke 

if-Ausdrücke der Form 


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. 



Ein Programm der folgenden Form 

Beispiel: 


2 { 


4 { 

5 int v1,v2,max; 

6 



9 

10 if(v1


kann nun wie folgt formuliert werden 

Beispiel: 


2 { 


4 { 

5 int v1,v2,max; 

6 



9 

10 max = (v1


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. 



Beispiel: 

Zu einem Koodinatenpaar (x,y) soll ermittelt werden, in welchem Quadranten es liegt: 


2 { 


4 { 

5 int quadrant, x, y; 

6 x = Integer.valueOf(args[0]).intValue(); 

7 y = Integer.valueOf(args[1]).intValue(); 

8 

9 if (x>=0) 

10 if (y>=0) 

11 quadrant=1; 

12 else 


14 else 

15 if (y>=0) 


17 else 


19 



20 System.out.println("Punkt liegt im " + quadrant + 

21 ". Quadranten"); 


23 } 

24 } 

oder unter Verwendung bedingter Ausdrücke: 

1 public class Verel06a 

2 { 


4 { 

5 int quadrant, x, y; 

6 x = Integer.valueOf(args[0]).intValue(); 

7 y = Integer.valueOf(args[1]).intValue(); 

8 

10 

9 quadrant = x>=0 y>=0 1 : 4 : y>=0 2 : 3; 

11 System.out.println("Punkt liegt im " + quadrant + 

12 ". Quadranten"); 


14 } 

15 } 



5.1.5 switch-Anweisung 

Mit geschachtelten if-Anweisungen lassen sich grundsätzlich alle Entscheidungsfolgen realisieren: 

1 public class Swch01 

2 { 


4 { 

5 int zahl; 

6 zahl=Integer.valueOf(args[0]).intValue(); 

7 

8 if(zahl==1) 

9 System.out.println("Die Zahl ist Eins."); 

10 else 

11 if(zahl==2) 

12 System.out.println("Die Zahl ist Zwei."); 

13 else 

14 if(zahl==3) 

15 System.out.println("Die Zahl ist Drei."); 

16 else 

17 if(zahl==4 || zahl==5) 

18 System.out.println( 



19 "Die Zahl ist Vier oder Fünf."); 

20 else 


22 "Die Zahl ist weder Eins noch ... Fünf."); 


24 } 

25 } 



Da Entscheidungsfolgen dieser Art keineswegs selten vorkommen, kennt Java mit der Anweisung 

switch eine Realisierung: 

Syntax: 

switch (ausdruck) 

{ 

case konstanter ausdruck_1: 

anweisung_1; 


anweisung_2; 


anweisung_3; 

... 

... 

case konstanter ausdruck_n: 

anweisung_n; 

default: 

anweisungen 

} 



• 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. 



Beispiel: 


2 { 


4 { 

5 int zahl; 


7 

8 switch(zahl) 

9 { 

10 case 1: 

11 System.out.println("Die Zahl ist Eins."); break; 

12 case 2: 

13 System.out.println("Die Zahl ist Zwei."); break; 

14 case 3: 

15 System.out.println("Die Zahl ist Drei."); break; 

16 case 4: 

17 case 5: 

18 System.out.println("Die Zahl ist Vier " + 

19 "oder Fünf."); break; 

20 default: 




22 "Die Zahl ist weder Eins noch ... Fünf."); 

23 } 


25 } 

26 } 


java Swch02 4 


Die Zahl ist Vier oder Fünf. 



Beispiel: 


2 { 


4 { 

5 int zahl; 


7 

8 switch(zahl) 

9 { 

10 case 1: 

11 System.out.println("Montag"); break; 

12 case 2: 

13 System.out.println("Dienstag"); break; 

14 case 3: 

15 System.out.println("Mittwoch"); break; 

16 case 4: 

17 System.out.println("Donnerstag"); break; 

18 case 5: 

19 System.out.println("Freitag"); break; 

20 case 6: 



21 System.out.println("Samstag"); break; 

22 case 7: 

23 System.out.println("Sonntag"); break; 

24 default: 

25 System.out.println("Eingabe ist falsch."); 

26 } 

27 


29 } 

30 } 

• Es sind nur Vergleiche mit primitiven Datentypen möglich. 

• Es können keine grösseren primitiven Typen (long, float, double) oder Objekte verwendet 

werden. 

• Es kann abgesehen von Gleichheit keine Beziehung geprüft werden. Verschachtelte if- 

Anweisungen sind dagegen auf jede Art der Prüfung und auf jeden Datentyp anwendbar. 



Beispiel Datum von Ostern: 

1 public class Osterdatum 

2 { 


4 { 

5 int jahr, monat, tag, m=0, n=0, a,b,c,d,e,f,g; 

6 jahr = Integer.valueOf(args[0]).intValue(); 

7 

8 switch(jahr/100) 

9 { 

10 case 15: 

11 case 16: m=22; n=2; break; 

12 case 17: m=23; n=3; break; 

13 case 18: m=23; n=4; break; 

14 case 19: 

15 case 20: m=24; n=5; break; 

16 case 21: m=24; n=6; 

17 } 

18 a=jahr%19; 

19 b=jahr%4; 

20 c=jahr%7; 



21 d=(19*a+m)%30; 

22 e=(2*b+4*c+6*d+n)%7; 

23 f=22+d+e; 

24 g=d+e-9; 

25 

26 if(f10) g=18; 

35 monat=4; 

36 tag=g; 

37 } 

38 System.out.println("Ostersonntag ist/war am " + tag + 

39 "." + monat + "." + jahr); 


41 } 

42 } 




java Osterdatum 2002 


Ostersonntag ist/war am 31.3.2002 



5.2 Wiederholungen (Schleifen) 

Wiederholung bedeutet, dass ein Programmteil mehrfach nacheinander ausgeführt wird. Java 

stellt hierzu folgende Befehle zur Verfügung: 

• while 

• do...while 

• for 



5.2.1 while-Schleife 

Bei diesem Befehl werden eine oder mehrere Anweisungen immer wieder ausgeführt, wenn 

die Bedingung wahr ist. 

Syntax: 

oder 

while (bedingung) 

anweisung; 

while (bedingung) 

{ 

anweisung_1; 

anweisung_2; 

... 

} 

• Zunächst wird der Ausdruck bedingung ausgewertet. 

• Ist sein logischer Wert wahr wird/werden die Anweisung/en ausgeführt. 

• Danach wird wiederum der Ausdruck bedingung ausgewertet. 

• usw. 



Beispiel 1: 

Ausgabe der Zahlen von 1 bis 10 am Bildschirm 

1 public class Wwhl01 

2 { 


4 { 

5 int i; 

6 i=0; 

7 

8 while (i



Die Zahl ist: 1 












Beispiel 2: 

Berechnung der Summe der Zahlen von 1 bis 10 und Ausgabe der Summe am Bildschirm 


2 { 


4 { 

5 int i=0, summe=0; 

6 

7 while (i


Beispiel 3: 

Eine Endlosschleife . . . 


2 { 


4 { 

5 boolean ok=true; 

6 

7 while (ok) 

8 { 

9 System.out.print("X"); 

10 } 

11 


13 } 

14 } 



5.2.2 Geschachtelte while-Schleifen 

Innerhalb einer while-Schleife sind weitere Schleifen erlaubt. 

Syntax: 

while (bedingung_1) 

{ 

... 

... 

while (bedingung_2) 

{ 

... 

... 

... 

... 

} 

... 

... 

} 



Beispiel: 


2 { 


4 { 

5 int i=0, j; 

6 while (i++


5.2.3 do...while-Schleife 



Syntax: 

oder 

do 

anweisung; 

while (bedingung); 

do 

{ 

anweisung_1; 

anweisung_2; 

... 

anweisung_n; 

} 

while (bedingung); 



• 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. 

• usw. 

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 ist. 

• 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. 



Beispiel 1: 


1 public class Wdwh01 

2 { 


4 { 

5 int i; 

6 i=0; 

7 

8 do 

9 { 

10 i=i+1; 

11 System.out.println("Die Zahl ist: " + i); 

12 } 

13 while (i















Beispiel 2: 



2 { 


4 { 

5 int i=0, summe=0; 

6 do 

7 { 

8 i=i+1; 

9 summe=summe+i; 

10 } 

11 while (i


Beispiel 3: 

Eine Endlosschleife . . . 


2 { 


4 { 

5 boolean ok=true; 

6 

7 do 

8 { 

9 System.out.print("X"); 

10 } 

11 while (ok); 

12 


14 } 

15 } 



5.2.4 Geschachtelte do...while-Schleifen 

Innerhalb einer do...while-Schleife sind weitere Schleifen erlaubt. 

Syntax: 

do 

{ 

... 

... 

do 

{ 

... 

... 

... 

... 

} 

while (bedingung_2); 

... 

... 

} 

while (bedingung_1); 



Beispiel: 


2 { 


4 { 

5 int i=1, j; 

6 do 

7 { 

8 j=1; 

9 do 

10 System.out.print(i+ " * " +j+ " = " +i*j+ " "); 

11 while (j++



1 * 1 = 1 1 * 2 = 2 1 * 3 = 3 

2 * 1 = 2 2 * 2 = 4 2 * 3 = 6 

3 * 1 = 3 3 * 2 = 6 3 * 3 = 9 



5.2.5 for-Schleife 



Syntax: 

oder 

for (ausdruck_1; bedingung; ausdruck_2) 

anweisung; 


{ 

anweisung_1; 

anweisung_2; 

... 

anweisung_n; 

} 



• 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 

muss 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


Beispiel 1: 


1 public class Wfor01 

2 { 


4 { 

5 int i; 

6 

7 for (i=1; i















Beispiel 2: 



2 { 


4 { 

5 int i, summe=0; 

6 

7 for (i=1; i


Beispiel 3: 

Berechnung der Summe der Zahlen von 1 bis 10 und Ausgabe der Summe sowie der Zwischenergebnisse 

am Bildschirm 


2 { 


4 { 


6 

7 for (i=1; i



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 Gesamtsumme ist: 55 



Beispiel 4: 

Berechnung des Sinus von 0 bis 90 Grad. 

1 public class Sico01 

2 { 


4 { 

5 int w; 

6 double b, ss; 

7 

8 for (w=0; w



w= 0 b= 0.0 sin= 0.0 

w= 1 b= 0.017453292519943295 sin= 0.01745240643728351 

w= 2 b= 0.03490658503988659 sin= 0.03489949670250097 

w= 3 b= 0.05235987755982988 sin= 0.05233595624294383 

w= 4 b= 0.06981317007977318 sin= 0.0697564737441253 

w= 5 b= 0.08726646259971647 sin= 0.08715574274765817 

w= 6 b= 0.10471975511965977 sin= 0.10452846326765346 

w= 7 b= 0.12217304763960307 sin= 0.12186934340514748 

w= 8 b= 0.13962634015954636 sin= 0.13917310096006544 

... 

... 

... 

w= 82 b= 1.43116998663535 sin= 0.9902680687415703 

w= 83 b= 1.4486232791552935 sin= 0.992546151641322 

w= 84 b= 1.4660765716752369 sin= 0.9945218953682733 

w= 85 b= 1.4835298641951802 sin= 0.9961946980917455 

w= 86 b= 1.5009831567151233 sin= 0.9975640502598242 

w= 87 b= 1.5184364492350666 sin= 0.9986295347545738 

w= 88 b= 1.53588974175501 sin= 0.9993908270190958 

w= 89 b= 1.5533430342749535 sin= 0.9998476951563913 

w= 90 b= 1.5707963267948966 sin= 1.0 



5.2.6 Geschachtelte for-Schleifen 

Innerhalb einer for-Schleife ist eine weitere Schleife erlaubt. 

Syntax: 


{ 

... 

... 


{ 

... 

... 

... 

... 

} 

... 

... 

} 



Beispiel: 


2 { 


4 { 

5 int i, j; 

6 

7 for (i=1; i


Beispiel 2: 

Berechnung der Hypothenuse rechtwinkliger Dreiecke. 

1 public class Hypo01 

2 { 


4 { 

5 int a, b; 

6 double c; 

7 

8 for (a=1; a



a= 1 b= 1 c= 1.4142135623730951 

a= 1 b= 2 c= 2.23606797749979 

a= 1 b= 3 c= 3.1622776601683795 

a= 1 b= 4 c= 4.123105625617661 

a= 1 b= 5 c= 5.0990195135927845 

a= 1 b= 6 c= 6.082762530298219 

a= 1 b= 7 c= 7.0710678118654755 

a= 1 b= 8 c= 8.06225774829855 

a= 1 b= 9 c= 9.055385138137417 

... 

... 

... 

a= 9 b= 1 c= 9.055385138137417 

a= 9 b= 2 c= 9.219544457292887 

a= 9 b= 3 c= 9.486832980505138 

a= 9 b= 4 c= 9.848857801796104 

a= 9 b= 5 c= 10.295630140987 

a= 9 b= 6 c= 10.816653826391969 

a= 9 b= 7 c= 11.40175425099138 

a= 9 b= 8 c= 12.041594578792296 

a= 9 b= 9 c= 12.727922061357855 



5.2.7 Weitere Anwendungen für Schleifen 

Beispiel 1: 

Es soll die Reihe 

berechnet werden. 

1 + 1 2 + 1 4 + 1 8 + · · · + 1 2 n 


2 { 


4 { 

5 int i, n; 

6 double summand=1., summe=1.; 

7 

8 n=Integer.valueOf(args[0]).intValue(); 

9 

10 for (i=1; i


16 


18 } 

19 } 


java Wfor11 11 


Die Summe ist: 1.99951171875 



Beispiel 2: 

Es soll die Fakultät einer Zahl berechnet werden. 


2 { 


4 { 

5 long i, n, fakultaet; 

6 n=Integer.valueOf(args[0]).intValue(); 

7 

8 for (i=fakultaet=1; i


Beispiel fehlerhafte Schleife (1): 


2 { 


4 { 


6 

7 for (i=1; i>10; i++) 

8 { 

9 summe+=i; 

10 } 

11 System.out.println("Die Summe ist: " + summe); 

12 


14 } 

15 } 


Die Summe ist: 0 



Richtig ist: 

1 public class Wfor12a 

2 { 


4 { 


6 

7 for (i=1; i


Beispiel fehlerhafte Schleife (2): 


2 { 


4 { 


6 

7 for (i=1; i


Richtig ist: 

1 public class Wfor13a 

2 { 


4 { 


6 

7 for (i=1; i



1 1 

2 4 

3 9 

4 16 

5 25 

6 36 

7 49 

8 64 

9 81 

10 100 



5.2.8 Die Anweisung break 

Die Anweisung break bewirkt, dass 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. 



Beispiel: 

1 public class Brk001 

2 { 


4 { 

5 int x=1; 

6 while(true) 

7 { 

8 System.out.println("x: " + x); 

9 if(x++==3) break; 

10 } 

11 System.out.println("X: " + x); 


13 } 

14 } 


x: 1 

x: 2 

x: 3 

X: 4 



Bei geschachtelten Schleifen bewirkt die Anweisung break, dass mit ihrer Ausführung die 

Abarbeitung der inneren Schleife sofort beendet wird. 

Beispiel: 


2 { 


4 { 

5 int x=0, y=0; 

6 for (x=0; x



19 } 

20 } 


x: 0 

0 1 2 3 4 5 

x: 1 

0 1 2 3 4 5 

x: 2 

0 1 2 3 4 5 

x: 3 

0 1 2 3 4 5 

x: 4 

0 1 2 3 4 5 

X: 5 

Y: 5 



5.2.9 Die Anweisung continue 

Die Anweisung continue bewirkt, dass 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. 



Beispiel: 

1 public class Con001 

2 { 


4 { 

5 double i; 

6 

7 for (i=-4.; i



Der Kehrwert ist: -0.25 




Der Kehrwert ist: 1.0 




Die Anweisung continue sorgt in diesem Fall dafür, dass bei dem Schleifenwert 0 nicht 

dividiert wird. 



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. 



Beispiel für break: 


2 { 


4 { 

5 int i,j; 

6 

7 sch_1: for (i=1; i



22 } 

23 } 


2 3 4 5 6 

3 4 5 6 7 



Beispiel für continue: 

1 public class Con003 

2 { 


4 { 

5 int i,j; 

6 

7 sch_1: for (i=1; i



22 } 

23 } 


2 3 4 5 6 

3 4 5 6 7 

4 5 6 7 

5 6 7 

6 7 



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. 



Felder werden über Referenzen verwaltet. Dies unterliegt folgenden Gesichtspunkten: 

• Felder werden über Referenzen manipuliert. 

• Felder werden mittels new dynamisch generiert. 

• Felder werden vom garbage Collector entsorgt. 

In den meisten Fällen kann die Besonderheit von Feldern vernachlässigt werden, sie hat allerdings 

folgende Auswirkungen: 

• Feld-Variablen sind Referenzen, 

• Felder werden zur Laufzeit eingerichtet, 

• Felder sind Methoden zugeordnet, 

• Felder besitzen Instanzvariablen. 



In Java erfolgt der Zugriff auf die Elemente eines Feldes mittels der Angabe des Index in eckigen 

Klammern. Bei mehrdimensionalen Arrays werden mehrere Klammernpaare verwendet: 

a[1] 

a[1][2] 

a[1][2][3] 

bzw. in allgemeiner Form 

a[i] 

a[i][j] 

a[i][j][k] 



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, 

dass es sich um ein Feld handelt. 

Beispiel: 

int [] Zahl; 

int Zahl []; 



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. 



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; 



6.1.4 Gleichzeitiges Deklarieren, Allokieren und Initialisieren 

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. 



Beispiel: 

1 public class Feld01 

2 { 


4 { 

5 int [] Zahl; 

6 int [] Zahl2; 

7 

8 Zahl = new int[2]; 

9 Zahl2 = new int[2]; 

10 

11 Zahl[0] = 12; 

12 Zahl[1] = 24; 

13 

14 double [] Gzahl = {6.54321, 1.23456, 2.22222}; 

15 

16 System.out.println(Zahl[0]*Zahl[1]); 

17 System.out.println(Zahl2[0]+" "+Zahl2[1]); 

18 System.out.println(Gzahl[0]+Gzahl[1]+Gzahl[2]); 

19 } 

20 } 




288 

0 0 

9.99999 

Bei jedem Zugriff auf ein Feldelement wird überprüft, ob das Element innerhalb der Dimensionen 

des Feldes liegt. 



Durch die Instanzvariable length kann man zu jeder Zeit überprüfen, wieviele Elemente in 

dem Feld enthalten sind. 

Beispiel: 

1 public class Feld02 

2 { 


4 { 

5 int [] Zahl = new int[2]; 

6 System.out.println("Anzahl der Elemente: " 

7 + Zahl.length); 


9 } 

10 } 


Anzahl der Elemente: 2 



6.2 Schleifen und Felder 

Felder können mittels Schleifen bearbeitet werden: 

Beispiel: 

1 public class Schl01 

2 { 


4 { 

5 

6 int i,summe=0; 

7 int [] feld = new int[11]; 

8 

9 for(i=1;i


17 summe+=feld[i]; 

18 System.out.println("Die Summe ist: " + summe); 

19 


21 } 

22 } 


2 4 6 8 10 12 14 16 18 20 

Die Summe ist: 110 



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 2 3 4 5 6 7 8 9 10 

11 12 13 14 15 16 17 18 19 20 

21 22 23 24 25 26 27 28 29 30 

31 32 33 34 35 36 37 38 39 40 

41 42 43 44 45 46 47 48 49 50 

51 52 53 54 55 56 57 58 59 60 

61 62 63 64 65 66 67 68 69 70 

71 72 73 74 75 76 77 78 79 80 

81 82 83 84 85 86 87 88 89 90 

91 92 93 94 95 96 97 98 99 100 



Schritt 1: 

(Löschen der Vielfachen von 2) 

-- 2 3 -- 5 -- 7 -- 9 -- 

11 -- 13 -- 15 -- 17 -- 19 -- 

21 -- 23 -- 25 -- 27 -- 29 -- 

31 -- 33 -- 35 -- 37 -- 39 -- 

41 -- 43 -- 45 -- 47 -- 49 -- 

51 -- 53 -- 55 -- 57 -- 59 -- 

61 -- 63 -- 65 -- 67 -- 69 -- 

71 -- 73 -- 75 -- 77 -- 79 -- 

81 -- 83 -- 85 -- 87 -- 89 -- 

91 -- 93 -- 95 -- 97 -- 99 -- 



Schritt 2: 


-- 2 3 -- 5 -- 7 -- -- -- 

11 -- 13 -- -- -- 17 -- 19 -- 

-- -- 23 -- 25 -- -- -- 29 -- 

31 -- -- -- 35 -- 37 -- -- -- 

41 -- 43 -- -- -- 47 -- 49 -- 

-- -- 53 -- 55 -- -- -- 59 -- 

61 -- -- -- 65 -- 67 -- -- -- 

71 -- 73 -- -- -- 77 -- 79 -- 

-- -- 83 -- 85 -- -- -- 89 -- 

91 -- -- -- 95 -- 97 -- -- -- 



Schritt 3: 


-- 2 3 -- 5 -- 7 -- -- -- 

11 -- 13 -- -- -- 17 -- 19 -- 

-- -- 23 -- -- -- -- -- 29 -- 

31 -- -- -- -- -- 37 -- -- -- 

41 -- 43 -- -- -- 47 -- 49 -- 

-- -- 53 -- -- -- -- -- 59 -- 

61 -- -- -- -- -- 67 -- -- -- 

71 -- 73 -- -- -- 77 -- 79 -- 

-- -- 83 -- -- -- -- -- 89 -- 

91 -- -- -- -- -- 97 -- -- -- 



Schritt 4: 


-- 2 3 -- 5 -- 7 -- -- -- 

11 -- 13 -- -- -- 17 -- 19 -- 

-- -- 23 -- -- -- -- -- 29 -- 

31 -- -- -- -- -- 37 -- -- -- 

41 -- 43 -- -- -- 47 -- -- -- 

-- -- 53 -- -- -- -- -- 59 -- 

61 -- -- -- -- -- 67 -- -- -- 

71 -- 73 -- -- -- -- -- 79 -- 

-- -- 83 -- -- -- -- -- 89 -- 

-- -- -- -- -- -- 97 -- -- -- 



Als Ergebnis erhält man alle Primzahlen zwischen 1 und 100: 

2 3 5 7 

11 13 17 19 

23 29 

31 37 

41 43 47 

53 59 

61 67 

71 73 79 

83 89 

97 



6.2.1.1 Variante 1 

Um dieses Verfahren zu Programmieren kann man man wie folgt vorgehen: 

1 public class Sieb 

2 { 


4 { 

5 // 1. Deklaration der Variablen 

6 int i, j; 

7 int [] sieb = new int[101]; 

8 

9 // 2. Initialisierung des Feldes, sieb[0] unbenutzt 

10 for (i=1; i


20 if (sieb[i]>0) 

21 System.out.println(sieb[i]); 

22 

23 // 5. Beendes des Programms 


25 } 

26 } 


2 43 

3 47 

5 53 

7 59 

11 61 

13 67 

17 71 

19 73 

23 79 

29 83 

31 89 

37 97 

41 




Die Umsetzung des Verfahrens ist nicht besonders effektiv, daher werden einige Verbessungungen 

vorgenommen: 

1 public class Sieb2 

2 { 


4 { 

5 


7 int i, j; 


9 

10 // 2. Initialisierung des Feldes 

11 // Neu: Feld wird erst ab 2. Element initialisiert 

12 for (i=2; i


19 

20 // Neu: Mit bereits gestrichenen Zahlen wird nicht mehr 

21 // gestrichen; gerade Zahlen werden übergangen 

22 for (i=3; i0) 

24 for (j=3*i; j



Als weitere Alternative kann man den Datentyp des Feldes von int auf boolean umstellen: 


2 { 


4 { 

5 


7 int i, j; 

8 // Neu: Datentyp wird auf boolean umgestellt 

9 boolean [] sieb = new boolean[101]; 

10 


12 for (i=2; i


20 for (i=3; i



Da die Zahl 2 die einzige gerade Primzahl ist, wird nur noch mit ungeraden Zahlen gearbeitet: 


2 { 


4 { 

5 


7 int i, j; 

8 // Feldgrösse halbiert 


10 


12 for (i=1; i


20 

21 // 4. Ausgabe der Primzahlen 

22 System.out.println(2); 

23 for (i=1; i


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. 


1 public class Sieba 

2 { public static void main(String args[]) 

3 { 

4 int i, j; 


6 for (i=1; i



1 public class Sieb2a 

2 { 


4 { 

5 int i, j; 


7 for (i=2; i




2 { 


4 { 

5 int i, j; 


7 for (i=2; i




2 { 


4 { 

5 int i, j; 


7 for (i=1; i


6.2.2.5 Ergebnisse 

Als Ergebnis der Zeitmessungen erhält man: 

Programmname Laufzeit in Sekunden 

Sieba 3.71 

Sieb2a 1.56 

Sieb3a 1.49 

Sieb4a 1.09 



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


Beispiel Addition zweier Matrizen: 

1 public class Schl02 

2 { 


4 { 

5 // Deklarationen 

6 int i,j; 

7 int [][] mat_1 = new int[3][3]; 

8 int [][] mat_2 = new int[3][3]; 

9 int [][] mat_3 = new int[3][3]; 

10 

11 // Initialisierung 

12 for(i=0;i


21 // Addition der Matrizen 

22 for(i=0;i


43 

44 // Ausgabe der Matrix mat_3 

45 for(i=0;i



1 2 3 

4 5 6 

7 8 9 

10 20 30 

40 50 60 

70 80 90 

11 22 33 

44 55 66 

77 88 99 



Kapitel 7 

Exkurs 

7.1 Oft gemachte Fehler 

7.1.1 Semikolon am Ende 

Am Ende eines Befehls muss ein Semikolon stehen. Der folgende Programmcode erzeugt 

einen Fehler beim kompilieren. 

Falsch ist: 


{ 

int a; 

a=0 

c○ MMI Joachim u. Marion Lammarsch, Rothenberg (fehler.tex) P–191


} 

Richtig ist: 


{ 

int a; 

a=0; 

} 

7.1.2 Semikolon in der Mitte 

Ein zuviel gesetztes Semikolon innerhalb eines Befehls wird möglicherweise als Nullanweisung 

gesehen und führt zu verdeckten Fehlern. Der folgende Programmcode schreibt die Meldung 

Ende erreicht immer auf den Bildschirm und nicht nur im Falle i gleich 10, da das 

zusätzliche Semikolon die if -Bedingung beendet. 

Falsch ist: 


{ 

int i=5; 

if (i==10); 

System.out.println("Ende erreicht"); 

} 



Richtig ist: 


{ 

int i=5; 

if (i==10) 


} 

Oder noch besser: 


{ 

int i=5; 

if (i==10) 

{ 


} 

} 

7.1.3 Dezimalkomma statt Dezimalpunkt 

Zur Trennung der Nachkommastellen bei Dezimalzahlen muss ein Punkt (amerikanische 

Schreibweise) statt ein Komma verwendet werden. Der folgende Programmcode erzeugt eine 



Fehlermeldung. 

Falsch ist: 

double r=1,234; 

Richtig ist: 

double r=1.234; 

7.1.4 Gleichheitsoperator 

Der Operator = ist ein Zuweisungs-Operator. Der relationale Operator zum Testen der Gleichheit 

zweiter Werte heisst ==. Der folgende Ausdruck testet nicht, ob a gleich b ist, sondern 

weist a den Wert von b zu und testet dann, ob a ungleich 0 ist. 

Falsch ist: 

if (a=b) ... 

Richtig ist: 

if (a==b) ... 

7.1.5 if-Anweisung 

Die Bedingung eines if -Befehls muss immer in Klammern stehen, das Schlüsselwort then 

gibt es in Java nicht. 



Falsch ist: 

if a >= 100 then 

... 

Richtig ist: 

if (a >= 100) 

... 

7.1.6 Mehrere Bedingungen 

Die logischen Operator zur Verknüpfung von Bedingungen lauten &, &&, | und ||. Die Operatoren 

&& und || sind schneller, da meist nicht alle Bedingungen zur Entscheidungsfindung 

ausgewertet werden müssen. 

if (i>0 & i0 && i


7.1.7 break in der switch-Anweisung 

Jeder Fall der Anweisung switch muss mit einem break abgeschlossen werden, damit die 

nachfolgenden Befehle nicht mehr ausgeführt werden. Der folgende Programmcode liefert 

nur dann das gewünschte Ergebnis, wenn i weder 10 noch 20 ist. 

switch(i) 

{ 

case 10: 

System.out.println("i ist 10"); 

case 20: 


default: 

System.out.println("i ist weder 10 noch 20"); 

} 

Richtig ist: 

switch(i) 

{ 

case 10: 


break; 

case 20: 



} 


break; 

default: 

System.out.println("i ist weder 10 noch 20"); 

break; 

7.1.8 for-Schleife 

Die drei Ausdrücke in der Bedingung der for-Schleife müssen mit Semikolon getrennt werden 

und nicht beispielsweise mit Komma. Der folgende Programmcode liefert einen Syntaxfehler. 

Falsch ist: 

for (i=0, i!=10, i++) ... 

Richtig ist: 

for (i=0; i!=10; i++) ... 

7.1.9 Blockklammern 

Man sollte nicht vergessen Blockklammern zu setzen, wenn man durch die Anweisungen if, 

do oder while mehrere Befehle ausführen lassen will. Der folgende Programmcode erzeugt 

eine Endlosschleife. 



Falsch ist: 


{ 

int i=0; 

while (i < 10) 

System.out.println("Wert von i=" + i); 

i++; 

} 

Richtig ist: 


{ 

int i=0; 

while (i < 10) 

{ 

System.out.println("Wert von i=" + i); 

i++; 

} 

} 



7.1.10 Geschachtelte if-Anweisungen 

Bei geschachtelten if -Anweisungen sind Blockklammern hilfreich. Der folgende Programmcode 

liefert als Ergebnis „i ist kleiner 0“. 

Falsch ist: 


{ 

int i=0; 

if (i >= 0) 

if (i != 0) 

System.out.println("i ist grösser 0"); 

else 

System.out.println("i ist kleiner 0"); 

} 

Richtig ist: 


{ 

int i=0; 

if (i >= 0) 

{ 

if (i != 0) 



} 


} 

else 


Oder noch besser: 


{ 

int i=0; 

if (i > 0) 


else if (i < 0) 


else 

System.out.println("i ist gleich 0"); 

} 

7.1.11 Ganzzahlige Division 

Falsch ist: 




{ 

} 

int i, sum=0, mean, fgr=5, feld [] = new int[fgr]; 

for (i=0; i


Falsch ist: 


{ 

int i=0, j=0; 

while (++i


7.1.13 Feld-Überlauf 

Das erste Element eines Feldes der Größe n hat immer den Index 0, das letzte den Index 

n − 1. Es wird nicht geprüft, ob Feld-Zugriffe innerhalb der erlaubten Feld-Grenzen liegen. 

Beim ausführen des Programms erhält man die Fehlermeldung Exception in thread 

¨main¨ java.lang.ArrayIndexOutOfBoundsException. 

Falsch ist: 


{ 

int i, feld [] = new int[345]; 

for (i=0; i


} 

} 

feld[i] = i; 

7.1.14 Tippfehler bei Konstanten 

Numerische Konstanten sollte man zu Beginn des Programms festlegen. Sie sind dann leichter 

zu finden und man vermeidet Tippfehler. Der folgende Programmcode stürzt wegen eines 

Feld-Überlaufs ab. 

Falsch ist: 


{ 

int i, feld [] = new int[345]; 

for (i=0; i


} 

int i, fgr=345, feld [] = new int[fgr]; 

for (i=0; i


} 

} 

} 

break; 

Besser wäre: 


{ 

int i=0; 

while (true) 

{ 

if (++i % 7 == 0) 

{ 

break; 

} 

else 

{ 

System.out.println(i); 

} 

} 

} 



7.2 Namenskonventionen 

Namenskonventionen erhöhen die Lesbarkeit eines Programms. Folgende Regeln haben sich 

durchgesetzt: 

Namen werden in der Regel sowohl mit Groß- als auch mit Kleinbuchstaben geschrieben. 

Dabei dienen die Großbuchstaben zum Trennen der Wortteile. 

Bsp.: 

DasIstEinLangerNamen 

Variablennamen beginnen immer mit einem Kleinbuchstaben 

Bsp.: 

nummer, alter, meinAlter, ganzeZahl 

Konstantennamen (d.h. Namen von Variablen, die nicht mehr geändert werden können) bestehen 

nur aus Großbuchstaben. Dabei dient der Unterstreichungsstrich zum Trennen der 

Wortteile. 

Bsp.: 

ANZAHL, MATRIX_RANG 

Methodennamen beginnen mit einem Kleinbuchstaben, wobei ihre Funktion sich im Namen 

wiederspiegeln soll. 

Bsp.: 

berechne, druckeErgebnis, zeichneKreis 

Klassennamen beginnen mit einem Großbuchstaben. Da der Klassenname mit dem Dateinamen 

übereinstimmen muss, unterliegt er auch den Regeln des Betriebssystems. 

Bsp.: 

Beispiel1, ErstesBeispiel 



Inhaltsverzeichnis 

I Prozedurale Programmierung mit Java P–1 

2 Bezeichner, Variablen, Kommentare P–2 

2.1 Bezeichner . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . P–2 

2.2 Variablen . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . P–5 

2.2.1 Initialisierung von Variablen . . . . . . . . . . . . . . . . . . . . P–9 

2.2.2 Schlüsselworte . . . . . . . . . . . . . . . . . . . . . . . . . . . P–10 

2.3 Kommentare . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . P–11 

2.3.1 Zeilenkommentare . . . . . . . . . . . . . . . . . . . . . . . . . P–12 

2.3.2 Blockkommentare . . . . . . . . . . . . . . . . . . . . . . . . . P–13 

2.3.3 HTML-Kommentare . . . . . . . . . . . . . . . . . . . . . . . . P–14 

3 Datentypen und Konstanten P–16 

3.1 Datentypen . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . P–16 

3.1.1 Ganze Zahlen . . . . . . . . . . . . . . . . . . . . . . . . . . . . P–17 

c○ MMI Joachim u. Marion Lammarsch, Rothenberg (toc) II–i


3.1.2 Ausgabe von ganzen Zahlen . . . . . . . . . . . . . . . . . . . . P–21 

3.1.3 Gleitkomma-Zahlen (Gleitpunkt-Zahlen) . . . . . . . . . . . . . P–27 

3.1.4 Boolsche Zahlen . . . . . . . . . . . . . . . . . . . . . . . . . . P–29 

3.1.5 Zeichen . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . P–29 

3.2 Datentyp-Umwandlungen . . . . . . . . . . . . . . . . . . . . . . . . . . P–30 

3.2.1 Aufwand für Konvertierungen . . . . . . . . . . . . . . . . . . . P–31 

3.3 Literale . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . P–33 

3.3.1 Ganzzahlige Konstanten . . . . . . . . . . . . . . . . . . . . . . P–34 

3.3.2 Gleitkomma-Konstanten . . . . . . . . . . . . . . . . . . . . . . P–35 

3.3.3 Zeichen-Konstanten . . . . . . . . . . . . . . . . . . . . . . . . P–36 

3.3.4 Zeichenketten-Konstanten . . . . . . . . . . . . . . . . . . . . . P–37 

3.3.5 Boolsche Konstanten . . . . . . . . . . . . . . . . . . . . . . . . P–38 

4 Operatoren P–39 

4.1 Zuweisungsoperator (=) . . . . . . . . . . . . . . . . . . . . . . . . . . . P–39 

4.2 Arithmetische Operatoren . . . . . . . . . . . . . . . . . . . . . . . . . . P–43 

4.2.1 Arithmetik von Gleitkommazahlen . . . . . . . . . . . . . . . . . P–48 

4.2.2 Verkürzte Schreibweisen . . . . . . . . . . . . . . . . . . . . . . P–50 

4.2.3 Inkrement- und Dekrement-Operatoren . . . . . . . . . . . . . . P–51 

4.3 Vergleichsoperatoren . . . . . . . . . . . . . . . . . . . . . . . . . . . . P–55 

4.4 Logische Operatoren . . . . . . . . . . . . . . . . . . . . . . . . . . . . P–56 

4.4.1 Wahrheitstafeln . . . . . . . . . . . . . . . . . . . . . . . . . . . P–59 

c○ MMI Joachim u. Marion Lammarsch, Rothenberg (toc) II–ii


4.4.2 Bitweise Operatoren . . . . . . . . . . . . . . . . . . . . . . . . P–62 

4.4.3 Verkürzte logische Operatoren . . . . . . . . . . . . . . . . . . . P–76 

5 Verzweigungen P–77 

5.1 Entscheidungen . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . P–77 

5.1.1 if-Anweisung . . . . . . . . . . . . . . . . . . . . . . . . . . . P–78 

5.1.2 if...else-Anweisung . . . . . . . . . . . . . . . . . . . . . P–81 

5.1.3 Bedingte Ausdrücke . . . . . . . . . . . . . . . . . . . . . . . . P–88 

5.1.4 Geschachtelte if- oder if...else-Anweisungen . . . . . . . P–91 

5.1.5 switch-Anweisung . . . . . . . . . . . . . . . . . . . . . . . . . P–94 

5.2 Wiederholungen (Schleifen) . . . . . . . . . . . . . . . . . . . . . . . . P–105 

5.2.1 while-Schleife . . . . . . . . . . . . . . . . . . . . . . . . . . P–106 

5.2.2 Geschachtelte while-Schleifen . . . . . . . . . . . . . . . . . . P–111 

5.2.3 do...while-Schleife . . . . . . . . . . . . . . . . . . . . . . P–113 

5.2.4 Geschachtelte do...while-Schleifen . . . . . . . . . . . . . . P–119 

5.2.5 for-Schleife . . . . . . . . . . . . . . . . . . . . . . . . . . . . P–122 

5.2.6 Geschachtelte for-Schleifen . . . . . . . . . . . . . . . . . . . P–131 

5.2.7 Weitere Anwendungen für Schleifen . . . . . . . . . . . . . . . . P–135 

5.2.8 Die Anweisung break . . . . . . . . . . . . . . . . . . . . . . . P–143 

5.2.9 Die Anweisung continue . . . . . . . . . . . . . . . . . . . . P–147 

5.2.10 Benannte Schleifen . . . . . . . . . . . . . . . . . . . . . . . . . P–150 

c○ MMI Joachim u. Marion Lammarsch, Rothenberg (toc) II–iii


6 Felder (Arrays oder Vektoren) P–155 

6.1 Anlegen eines Feldes . . . . . . . . . . . . . . . . . . . . . . . . . . . . P–158 

6.1.1 Deklaration eines Feldes . . . . . . . . . . . . . . . . . . . . . . P–158 

6.1.2 Allokierung eines Feldes . . . . . . . . . . . . . . . . . . . . . . P–159 

6.1.3 Initialisierung eines Feldes . . . . . . . . . . . . . . . . . . . . . P–160 

6.1.4 Gleichzeitiges Deklarieren, Allokieren und Initialisieren . . . . . P–161 

6.2 Schleifen und Felder . . . . . . . . . . . . . . . . . . . . . . . . . . . . P–165 

6.2.1 Beispiel: Sieb des Eratosthenes . . . . . . . . . . . . . . . . . . P–167 

6.2.2 Zeitmessung: Sieb des Eratosthenes . . . . . . . . . . . . . . . . P–181 

6.3 Schleifen und mehrdimensionale Felder . . . . . . . . . . . . . . . . . . P–186 

7 Exkurs P–191 

7.1 Oft gemachte Fehler . . . . . . . . . . . . . . . . . . . . . . . . . . . . P–191 

7.1.1 Semikolon am Ende . . . . . . . . . . . . . . . . . . . . . . . . P–191 

7.1.2 Semikolon in der Mitte . . . . . . . . . . . . . . . . . . . . . . . P–192 

7.1.3 Dezimalkomma statt Dezimalpunkt . . . . . . . . . . . . . . . . P–193 

7.1.4 Gleichheitsoperator . . . . . . . . . . . . . . . . . . . . . . . . . P–194 

7.1.5 if-Anweisung . . . . . . . . . . . . . . . . . . . . . . . . . . . . P–194 

7.1.6 Mehrere Bedingungen . . . . . . . . . . . . . . . . . . . . . . . P–195 

7.1.7 break in der switch-Anweisung . . . . . . . . . . . . . . . . . . P–196 

7.1.8 for-Schleife . . . . . . . . . . . . . . . . . . . . . . . . . . . . . P–197 

7.1.9 Blockklammern . . . . . . . . . . . . . . . . . . . . . . . . . . . P–197 

c○ MMI Joachim u. Marion Lammarsch, Rothenberg (toc) II–iv


7.1.10 Geschachtelte if-Anweisungen . . . . . . . . . . . . . . . . . . . P–199 

7.1.11 Ganzzahlige Division . . . . . . . . . . . . . . . . . . . . . . . . P–200 

7.1.12 Nebeneffekte in logischen Ausdrücken . . . . . . . . . . . . . . P–201 

7.1.13 Feld-Überlauf . . . . . . . . . . . . . . . . . . . . . . . . . . . . P–203 

7.1.14 Tippfehler bei Konstanten . . . . . . . . . . . . . . . . . . . . . P–204 

7.1.15 Wirkungsloses break . . . . . . . . . . . . . . . . . . . . . . . . P–205 

7.2 Namenskonventionen . . . . . . . . . . . . . . . . . . . . . . . . . . . . P–207 

c○ MMI Joachim u. Marion Lammarsch, Rothenberg (toc) II–v

Teil I Prozedurale Programmierung mit Java - Urz

Sie wollen auch ein ePaper? Erhöhen Sie die Reichweite Ihrer Titel.

Template löschen?

Als Template speichern?