Objektorientierte Programmierung OOP

Das innere einer Schleife wird auch als Schleifenrumpf bezeichnet.

Es gilt die 4-Leerzeichen-Regel für Einrückungen. Falls eine expression getrennt werden muss, sollten Sie 8 Leerzeichen verwenden, da die 4-LeerzeichenEinrückung die Erkennung des Anweisungsrumpfs erschwert:

while ((condition1 && condition2)

        || (condition3 && condition4) {

    statement;

}

Die do-Schleife (engl. do loop) hat die folgende Syntax:  do

statement

while (expression);

Bei dieser Schleifenart wird während der Laufzeit zuerst die Anweisung statement ausgeführt. Dann wird der Bedingungsausdruck expression überprüft. Falls das Ergebnis true liefert, wird die Schleife so lange wiederholt, bis expression das Ergebnis false liefert. [JLS: § 14.13] Dieser Sachverhalt ist in Abb. 14.1-3 veranschaulicht.

Im Gegensatz zur while-Schleife, bei der die Schleifenanweisung unter Umständen nie ausgeführt wird, wird bei einer do-Schleife die Schleifenanweisung immer mindestens einmal ausgeführt.

Schleifen, bei denen der Rumpf möglicherweise nie ausgeführt wird, nennen wir abweisende Schleifen. Wird der Rumpf immer mindestens einmal ausgeführt, so sprechen wir von nicht abweisenden Schleifen.

Eine for-Schleife hat folgende Form:

for (forInit; booleanExpr; forUpdate)

statement

wobei

• der optionale Ausdruck forInit im Normalfall eine Liste aus einer oder mehreren Variablendeklarationen und Initialbelegungen enthält, die durch Kommata voneinander getrennt werden; die neu eingeführten Schleifenvariablen müssen alle vom gleichen Typ sein; sie sind außerhalb der for-Schleife nicht sichtbar; der Ausdruck forInit wird genau einmal zu Beginn der Ausführung der Schleife evaluiert;

• booleanExpr ein optionaler Vergleichsausdruck vom Typ boolean ist; er bestimmt den Endwert und wird vor jedem Wiederholungszyklus der Schleife überprüft; sobald die Auswertung false liefert, wird die Schleife beendet;

• forUpdate eine optionale, durch Kommata getrennte Folge von einer oder mehreren Anweisungen ist, die im Normalfall die Schleifenvariablen verändern; der Ausdruck wird in jedem Schleifendurchlauf nach der Ausführung von statement ausgewertet;

• statement eine Anweisung ist. [JLS: § 14.14.1]

Dieser Sachverhalt ist in der Abbildung veranschaulicht.

  Das folgende Beispiel:

for (int i = 0; i < 5 ; i++) {

System.out.println(i);

}

wird auf Ihrem Computerbildschirm folgendes ausgeben:

0

1

2

3

4

Das Programmstück:

for (char c = ’f’; c >= ’a’; c--) {

System.out.println(c); }

erzeugt auf dem Bildschirm folgende Ausgabe:

f

e

d

c

b

a

Bei der Vergabe von Namen für Schleifenvariablen darf von der Regel, Namen beschreibend und selbsterklärend zu wählen, abgewichen werden. Schleifenvariablen werden oft durch einzelne Buchstaben dargestellt, weil ihre Funktion meist aus dem Kontext heraus klar ist.

Ist keine booleanExpr vorhanden, so verhält sich die Schleife genauso, als wäre der Ausdruck zu true evaluiert worden.

break-Anweisung In allen Schleifen bewirkt die Ausführung einer break-Anweisung ohne Sprungmarke, dass die innerste Schleife, in der die break-Anweisung auftritt, sofort verlassen wird, ohne die restlichen Anweisungen im jeweiligen Block auszuführen. Die Programmausführung wird nach dem betroffenen Schleifenblock fortgesetzt. Die break-Anweisung ohne Sprungziel kann auch in MehrfachFallunterscheidungen verwendet werden, um die Ausführung der auf den ausgewählten Fall folgenden Anweisungen zu unterbinden. [JLS: § 14.15]

  Das folgende Programmstück illustriert den Gebrauch der break-Anweisung in einer switch-Anweisung:

int weekdays;

...

switch (weekdays) {

case 1: System.out.println("Monday");

break;

case 2: System.out.println("Tuesday");

break;

case 3: System.out.println("Wednesday");

break;

case 4: System.out.println("Thursday");

break;

case 5: System.out.println("Friday");

break;

case 6: System.out.println("Saturday");

break;

case 7: System.out.println("Sunday");

break;

default: System.out.println("there are no more weekdays");

}

Welcher Fall aus 1 bis 7 auch immer bei der Ausführung dieser Fallunterscheidung zutrifft: das Programm wird immer nur den zugehörigen Wochentag auf Ihrem Bildschirm ausgegeben, da die break-Anweisungen verhindern, dass der Kontrollfluss über die nachfolgenden Anweisungen fließt.

  Gegeben seien die folgenden Anweisungen:

int x = 317;

do {

if (x % 17 == 0) {

break;

}

x++;

} while (true);

System.out.println(x);

Bei der Ausführung erscheint die Ausgabe 323 auf dem Bildschirm, da die Schleife auf Grund der break-Anweisung genau dann verlassen wird, wenn x durch 17 teilbar ist. Der Kontrollfluss ist in Abb. 14.3-1 dargestellt.

continue-Anweisung Die Anweisung continue stoppt die Ausführung der Wiederholungsanweisung, in der sie vorkommt, springt zum Anfang der Schleifenanweisung und startet unverzüglich den nächsten Schleifendurchlauf. [JLS: § 14.16]

Die Anweisung continue stoppt die Ausführung der Wiederholungsanweisung, in der sie vorkommt, springt zum Anfang der Schleifenanweisung und startet unverzüglich den nächsten Schleifendurchlauf. [JLS: § 14.16]

Gegeben seien die folgenden Anweisungen:

for (int i = 0; i < 10; i++) {

    if (i == 5) {

        i = i + 2; continue;

    }

    System.out.println(i);

}

Bei der Ausführung erscheint die folgende Ausgabe auf dem Bildschirm: 0 1 2 3 4 8 9 Wenn i den Wert 5 annimmt, wird i zuerst um 2 erhöht und anschließend direkt die Anweisung forUpdate (i++) ausgeführt. Somit ist in i der Wert 8 gespeichert und die Schleife wird fortgesetzt. Der Kontrollfluss ist in der Abbildung veranschaulicht.

Eine while-Schleife mit break- und continue-Anweisung ist in der unten stehenden Anweisungssequenz dargestellt:

int summe = 0;

while (summe < 100) {

    summe += 1;

   if (summe == 20) {

      System.out.println("Schluss!");

      break;

   }

   if (summe < 16) {

      summe += 3; continue;

   }

   System.out.println(summe);

}

Der Gültigkeitsbereich (engl. scope) einer Variablendeklaration ist der Rest des Blocks, inklusive aller inneren Blöcke, in dem sie sich befindet. [JLS: § 14.4.2]

Jeder Block, inklusive all seiner enthaltenen Blöcke, ist ein eigener Sichtbarkeitsbereich.

Innerhalb eines Sichtbarkeitsbereichs können Variablennamen nicht erneut in Deklarationen benutzt werden. Deklarationen mit identischen Variablennamen in getrennten Sichtbarkeitsbereichen sind zulässig

Die Abbildung veranschaulicht das Konzept des Gültigkeitsbereiches und der Sichtbarkeit von Variablennamen für das Beispiel in Programm 15-1. Obgleich kein guter Programmierstil, darf in Programm 15-1 der Name i in den Blöcken S1 und S3 wiederverwendet werden, weil sich die Blöcke nicht überschneiden. Hätten wir aber anstelle von temp den Namen i, treffer, summe oder gefunden in Block F2 gewählt, wäre das Programm illegal geworden.

elementare und einfache Datentypen

-byte; -2hoch7, ..., 0, ..., 2hoch7-1; -128, ..., 127

-short; -2hoch15, ..., 0, ..., 2hoch15-1; -32768, ..., 32767

-int; -2hoch31, ..., 0, ..., 2hoch31-1; -2147483648, ...,2147483647  

-long -2hoch63, ..., 0, ..., 2hoch63-1; -9223372036854775808L,..., 9223372036854775807L

Literale (engl. literal) sind Folgen von Zeichen, die Werte symbolisieren. [JLS: § 3.10]

  Diese Kennzeichnungen wurden bei Java eingeführt, um eine eindeutige Interpretation von Literalen zu gewährleisten. Anderenfalls könnte z. B. das Literal 123 nicht nur für den Dezimalwert 123, sondern auch für den Dezimalwert 83 stehen, wenn 123 als Oktalzahl aufgefasst wird, oder den Dezimalwert 291 darstellen, wenn 123 als Hexadezimalzahl aufgefasst wird.

  Die Tabelle stellt jeweils denselben Wert als dezimale, oktale bzw. eine hexadezimale ganze Zahl dar

• Gleitkommazahlen mit einfacher Genauigkeit vom Typ float   

• Gleitkommazahlen mit doppelter Genauigkeit vom Typ double

  Die Präzision von Gleitkommazahlen ist beschränkt. Bei float-Zahlen beträgt die Genauigkeit ungefähr sieben Dezimalstellen, bei double-Zahlen ungefähr 15 Dezimalstellen. Operationen auf Gleitkommazahlen können die Genauigkeit weiter reduzieren. Betrachten Sie daher Gleitkommazahlen stets als Näherungen.

Das Ergebnis der Division 10000000000.0 / 3.0 ist 3.3333333333333335E9.

Das Ergebnis der Multiplikation 100.0 * 4.35 ist 434.99999999999994.

  Ein Operator führt eine Funktion (wie Negation, Addition, Subtraktion, Multiplikation usw.) auf seinem oder seinen Operanden aus und liefert einen Wert zurück. Der Typ des Ergebniswerts wird durch den oder die Typen der Operanden bestimmt. Der Ergebniswert hängt vom Operator und von den Werten seiner Operanden ab. Die einstelligen Operatoren + und - bestimmen den positiven bzw. negativen Wert eines arithmetischen Ausdrucks. Die zweistelligen arithmetischen Operatoren: +, -, *, /, % stellen die Addition, Subtraktion, Multiplikation, ganzzahlige Division bzw. Restwertdivision (engl. modulo division) für zweistellige Operatoren dar. Diese Operatoren und ihre Bedeutungen sind zusammen mit einem Beispiel in Tab. 9.3-1 angegeben. [JLS: § 3.12, § 4.2.2, § 4.2.4]

Neben Literalen werden wir im Laufe des Kurses noch weitere Alternativen für Operanden in Ausdrücken kennen lernen. Operatoren, die auf mehr als einen Typen anwendbar sind, nennen wir überladen (engl. overloaded).

Ein arithmetischer Ausdruck (engl. arithmetic expression) wird gemäß folgender Regeln gebildet [JLS: § 15]: • Jede Variable eines numerischen Typs und jedes Literal eines numerischen Typs ist ein arithmetischer Ausdruck. • Wenn x ein arithmetischer Ausdruck ist, dann ist auch (x) ein arithmetischer Ausdruck. • Wenn x ein arithmetischer Ausdruck und eop ein einstelliger arithmetischer Operator ist, der vor dem Operanden steht, dann ist auch eop x ein arithmetischer Ausdruck. • Wenn x ein arithmetischer Ausdruck und eop ein einstelliger arithmetischer Operator ist, der nach dem Operanden steht, dann ist auch x eop ein arithmetischer Ausdruck. • Wenn x und y arithmetische Ausdrücke sind, und zop ein zweistelliger arithmetischer Operator, dann ist auch x zop y ein arithmetischer Ausdruck.

Wenn in einem Ausdruck mehrere Operatoren auftreten, wendet der Java- Übersetzer Präzedenzregeln an, um den Ausdruck auftretenden Operatoren auszuwerten, es sei denn, dass durch Klammern eine andere Reihenfolge vorgegeben wurde. Die Präzedenzregeln sind in Tab. 9.4-1 angegeben. (Die Tabelle enthält auch einige Operatoren, die wir erst in einem späteren Abschnitt besprechen werden.) Die Operatoren in der ersten Zeile haben den höchsten Rang, die in der letzten den niedrigsten. Operatoren gleichen Rangs werden von links nach rechts ausgewertet.

Ein arithmetischer Ausdruck wird in einer strikten Reihenfolge gemäß folgender Regeln berechnet [JLS: § 15.7]:

• Ausdrücke, die in Klammern eingeschlossen sind, werden zuerst berechnet; im Falle von Verschachtelungen von innen nach außen. Klammerausdrücke erhalten somit die höchste Priorität bei der Auswertung.

• Zweistellige Operatoren werden von links nach rechts ausgewertet.

• Einstellige Operatoren werden von rechts nach links ausgewertet.

• Anschließend werden die Operatoren ihrem Vorrang entsprechend (s. Tab. 9.4- 1) ausgewertet.

• Wenn ein Ausdruck mehrere Operatoren des gleichen Vorranges enthält, werden die Operatoren von links nach rechts berechnet.

Unter Berücksichtigung der Regeln in Definition wird der Ausdruck 17 * 2 % - (4 - 11) / (-3 + 5) in folgender Reihenfolge berechnet (gelesen von oben nach unten, der als Nächstes auszuwertende Unterausdruck ist unterstrichen): Auswertungsreihenfolge |Regel Auswertungsrichtung

17 * 2 % - (4 - 11) / (-3 + 5) | () von links nach rechts

-> 17 * 2 % - (- 7) / (-3 + 5) | () von links nach rechts

-> 17 * 2 % - (- 7) / 2 | - von rechts nach links

-> 17 * 2 % 7 / 2 | * von links nach rechts

-> 34 % 7 / 2 | % von links nach rechts

-> 6 / 2 | / von links nach rechts

-> 3 |

==, !=, >, >=, <, <=, um zwei Werte gleichen oder verträglichen Typs miteinander zu vergleichen. Syntax und Bedeutung dieser Operatoren sind in Tab. 9.4-2 angegeben. [JLS: § 15.20, § 15.21]

Der Datentyp boolean umfasst die beiden Literaletrue und false sowie die folgenden booleschen Operatoren:

• den einstelligen Präfixoperator!, der eine logische Negation beschreibt,

• fünf zweistellige Operatoren &&, ||, &, | und ^, um logische Ausdrücke aufzubauen und

• zwei zweistellige Vergleichsoperatoren == und !=, die die logische Gleichheit bzw. Ungleichheit beschreiben. Alle Operatoren vom Typ boolean sind mit ihrer Bedeutung und Anwendungsbeispielen in Tab. 9.5-1 angegeben. [JLS: § 3.10.3, § 4.2.5, § 15.22.2, § 15.23, § 15.24]

Java bietet den einfachen Datentyp char an, der alle Unicode-Zeichen umfasst und seine Werte vorzeichenlos speichert. Unicode ist ein internationales Codiersystem für Zeichen, das es ermöglicht, mehr als 65000 Zeichen darzustellen. UnicodeZeichen umfassen:

• Groß- und Kleinbuchstaben,

• Ziffern,

• Interpunktionszeichen,

• Sonderzeichen für Operatoren,

• Sonderzeichen und -buchstaben, die in verschiedenen Sprachen benutzt werden, und

• Steuerzeichen, die es ermöglichen, Aufteilung und Umbruch einer Computerausgabe zu bestimmen.

Zeichen erscheinen zwischen einzelnen Anführungszeichen (’) wie: ’a’, ’B’, ’§’, oder ’-’. Steuerzeichen beginnen mit dem Rückwärts-Schrägstrich (engl. backslash) „\“. [JLS: § 3.10.4]

Steuerzeichen Die Zeichen ’\n’, ’\t’ und ’\b’ stehen zum Beispiel für die Steuerzeichen „neue Zeile“, „Tabulatorsprung“ bzw. „Rücktaste“.