Zurück   Weiter

2 Grundlagen des Programmierens mit Java

2.1 Allgemeine Grundlagen

Damit ein Prozessor ein Programm ausführen kann, muss es im Binärcode vorliegen. Dieser besteht aus einer Aneinanderreihung von hexadezimalen Ziffern und ist nur sehr schwer zu schreiben oder zu lesen. Aus diesem Grunde wurde Assembler und danach die heutigen Programmiersprachen entwickelt. Um diese in Binärcode zu übersetzen benötigt man die Compiler. Der Compiler wandelt die einzelnen Dateien eines Programmcodes in Objekcodemodule um, welcher Hinweise auf die Verknüpfungen der Module untereinander enthält. Erst der Linker verknüpft diese Module tatsächlich miteinander und erzeugt aus den Modulen ein ausführbares Programm. Bei der Programmierung mit Java wird der Source-Code vom Compiler in Byte-Code umgewandelt. Das Linken wird erst zur Laufzeit von der virtuellen Maschine ausgeführt.

2.2 Das Java Software Development Kit

Für Software Entwickler wird von der Firma Sun Microsystems das Java Software Development Kit (Java SDK) bereitgestellt. Es kann von der Java Homepage der Firma Sun kostenlos heruntergeladen werden. Dieses Java SDK enthält alle Programme, welche benötigt werden um mit Java Applikationen zu entwickeln. Es handelt sich dabei um Kommandozeilen-Programme, d.h. Programme welche von einer Textkonsole aus gestartet werden. Ein Editor zum Bearbeiten des Source-Codes ist im Java-SDK nicht enthalten. Es gibt auf dem Markt allerdings ein grosse Anzahl von Integrierten Entwicklungsumgebungen (IDE), welche das Arbeiten mit diesen Tools und das Entwickeln von Programmen erleichtern.

2.2.1 Installation unter Windows

Die Installation unter Windows gestaltet sich sehr einfach. Nach einem Doppelklick auf die Datei j2sdk1_3_0-win.exe wird das Installationsprogramm gestartet.

jdkInstall01

Der nach dem Entpacken der Dateien erscheinende Dialog

jdkInstall02

kann mit Next quittiert werden. Die danach erscheinende Lizenzvereinbarung

jdkInstall03

muss mit Yes akzeptiert werden. Im nächsten Dialog

jdkInstall04

kann das Installationsverzeichnis gewählt werden. Am Besten ist es das Installationsverzeichnis zu akzeptieren und den Dialog mit Next zu quittieren. Im darauf folgende Dialog

jdkInstall05

werden die zu installierenden Komponenten ausgewählt. Sinnvoll ist es die Komponenten Program Files, Native Interface Headers und Demos auszuwählen. Wer sich den Sourcecode der JDK-Klassen einmal anschauen möchte, kann auch noch die Java Sources anwählen. Man sollte dazu aber schon etwas Erfahrung in Java gesammelt haben. Nach Bestätigen dieses Dialogs mit Next wird die Installation gestartet.

jdkInstall06

Nach Beenden der Installation werden noch einige Einstellungen im System für das Java Runtime Environment (JRE) vorgenommen.

jdkInstall07

Aus diesem Grund sollte auch im abschliessenden Dialog

jdkInstall08

die Option Yes, I want to restart my computer now. angewählt werden, bevor die Installation mit Finish beendet wird. Nun muss noch sichergestellt werden, dass sich das Verzeichnis bin-Verzeichnis des JDK im ausführbaren Pfad befindet. Bei Windows NT erfordert dies einen Eintrag für den Parameter PATH in den Systemeinstellungen.

jdkInstall09

Bei Windows95/98 sollte in der Datei c:\autoexec.bat der Eintrag

PATH=%PATH%;c:\jdk1.3\bin
eingefügt werden. Ansonsten muss dieser Aufruf jedesmal nach Öffnen eines DOS-Fensters neu ausgeführt werden. Nach dem Eintragen in die Datei autoexec.bat ist ein Neustart des PC's erforderlich, damit die Änderung wirksam wird.
Als letzte Einstellung muss noch die CLASSPATH-Umgebungsvariable angepasst werden. Bei Windows NT wird dies wieder in den Systemeinstellungen eingetragen.

jdk classpath

Für den CLASSPATH muss der Eintrag ".;%CLASSPATH%" vorgenommen werden.
Bei Windows95/98 muss in der Datei c:\autoexec.bat der Eintrag
set CLASSPATH=.;%CLASSPATH%;
eingefügt werden.

2.2.2 javac

Dem Java-Compiler wird die zu compilierende Datei als Argument übergeben. Dabei muss auf Gross- und Kleinschreibung geachtet werden und die Extension ".java" des Sourcefiles mit angegeben werden. Der Compiler erzeugt Files mit den Namen aller in den Sourcefiles enthaltenen Klassen mit der Extension ".class". Dem Compiler können auch noch einige Optionen übergeben werden, von denen ein paar hier angegeben werden:


Der Aufruf des Compilers könnte so aussehen:

javac -classpath ./MyClasses.jar -d ./classes MyFirstJavaProgram.java

2.2.3 java/javaw

java/javaw sind die virtuellen Maschinen, mit denen eine Java-Aplikation gestartet werden kann. javaw steht nur auf den Windows-Plattformen zur Verfügung und startet die Applikation ohne darür eine DOS-Konsole zu öffnen. Als Argument wird der virtuellen Maschine der Name der Klasse übergeben, die das Programm startet. Die Endung ".class" darf nicht mit angegeben werden. Ohne eine explicite Angabe führt die JVM den Bytecode mit einem Just-In-Time Compiler (JIT) aus. Der JIT übersetzt die Klassen die geladen werden in Maschinencode des zugrunde liegenden Betriebssystems. Dadurch werden zum Teil erhebliche Performance Steigerungen erreicht. Der JIT kann über die Systemvariable JAVA_COMPILER gewählt oder ausgeschaltet werden. Dem Java-Interpreter können Optionen mitgegeben werden. Die wichtigsten sind hier aufgezählt.


Der Aufruf der JVM könnte folgendermassen aussehen:

java -cp ./MyClasses.jar;. -DJAVA_COMPILER=NONE MyFirstJavaProgram
java -DJAVA_COMPILER=NONE -jar MyFirstJar.jar

2.2.4 appletviewer

Mit dem Appletviewer können Applets getestet werden. Dem Appletviewer wird als Argument das html-File übergeben, welches den oder die Applet-Tags enthält. Sind in einem html-File mehrere Applet-Tags vorhanden, so wird für jedes Applet ein eigenes Fenster geöffnet.
Aufruf:

appletviewer MyFirstJavaApplet.html

2.2.5 javadoc

2.3 Die Sprachsyntax von Java

2.3.1 Kommentar

Um das Lesen des Programmcodes zu erleichtern, ist es sinnvoll an wichtigen Stellen Kommentar einzufügen.

2.3.2 Dokumentation

Für die Dokumentation ist in Java ein weiterer Kommentar definiert. Dieser kann von dem im JDK enthaltenen Tool javadoc ausgewertet werden. Er beginnt mit /** und wird mit */ beendet. javadoc erzeugt daraus HTML-Files im Stile der im JDK mitgelieferten Dokumentation.

2.3.3 Das Javaprogramm

Auch ein Javaprogramm ist ein Objekt. Um also ein Javaprogramm schreiben zu können, muss man wissen, wie eine Klasse definiert wird.

  class KlassenName Anweisungsblock

Die Definition einer Klasse wird in Java mit dem Schlüsselwort class eingeleitet. Danach folgt der Name der Klasse. Dieser kann aus einer beliebigen zusammenhängenden Buchstaben-Ziffernkombination bestehen. Er darf aber nicht mit einer Ziffer beginnen. Leerzeichen sind in Namen nicht erlaubt. Ein Underscore(_) ist ein erlaubtes Sonderzeichen. Klassennamen beginnen in der Regel mit Grossbuchstaben. Ist ein Klassenname aus mehreren Worten zusammengesetzt, so wird der Anfangsbuchstabe jedes eigenständigen Wortes wieder gross geschrieben. Auf den Namen der Klasse folgt ein Anweisungsblock. Er beginnt mit einer geschweiften Klammer auf '{' und endet mit einer geschweiften Klammer zu '}'.

  class KlassenName {
    ...
    ...
  }

Alles was zur Klassendefinition dazu gehört, muss in diesem Anweisungsblock, d.h. innerhalb der geschweiften Klammern stehen.

class MyFirstJavaProgram {
}

2.3.4 Der Programmstart

Damit die JVM erkennen kann ob eine Klasse ein ausführbares Programm enthält und wo sie mit dem Programmablauf beginnen soll, muss ein Einstiegspunkt definiert sein. Dieser Einstiegspunkt wird in einer Klassendefinition mit der Methode public static void main(String[] args) realisiert. Diese Methodendefinition steht innerhalb des Anweisungsblocks der Klassendefinition und erhält ebenfalls einen Anweisungsblock.

  class KlassenName {
    public static void main(String[] args) {
      ...
    }
    ...
    ...
  }

Auf die einzelnen Teile der Methodendefinition möchte ich jetzt nicht eingehen. Die Angabe dieser Methode dient lediglich dazu ein Programm starten zu können.

class MyFirstJavaProgram {
  public static void main(String[] args) {
  }
}

2.3.5 Der Standardoutput

Um Informationen über den Programmablauf an den Benutzer weiterzugeben, benötigt man eine Ausgabemöglichkeit. Die einfachste ist die Console(Fenster), von der aus das Programm gestartet wurde. Dies ist das Standardout. In Integrierten Entwicklungsumgebungen ist meist ein eigenes Fenster für den Output definiert. Mit dem Aufruf von

  System.out.println("beliebiger Text");

kann man in Standardout schreiben. Die genaue Funktion dieser Methode wird später erklärt. Der Aufruf der Methode muss mit einem Semikolon abgeschlossen werden.

class MyFirstJavaProgram {
  public static void main(String[] args) {
    System.out.println("Dies ist mein erstes kleines Javaprogramm.");
  }
}

Dies ist nun ein erstes lauffähiges kleines Javaprogramm. Um diese Programm ausprobieren zu können, Legst du auf deinem Computer am Besten ein Verzeichnis an, in das du alle Dateien dieses Kurses ablegen kannst (z.B. c:\javakurs). Schreibe den Sourcecode des Programms in eine Datei mit dem Namen MyFirstJavaprogramm.java und öffne eine Console (unter Windows ein Dos-Fenster). wechsle in das Verzeichnis, in welches du die Datei kopiert hast. Nun kannst du das Programm mit dem Aufruf

javac MyFirstJavaProgram.java + Return-Taste

compilieren und mit dem Aufruf

java MyFirstJavaProgram + Return-Taste

ausführen. Auf dem Bildschirm erscheint:
Dies ist mein erstes kleines Javaprogramm.

Sourcefile

Aufgabe 1

2.3.6 Anweisungen

Ein Schritt, welcher von einem Programm ausgeführt werden soll, wird eine Anweisung genannt. In der Regel verwendet man für jede Anweisung eine eigene Programmzeile. Jede Anweisung muss mit einem Semikolon ';' abgeschlossen werden. Umgekehrt bedeutet dies: Jedes Semikolon beendet eine Anweisung. In unserem ersten kleinen Programm haben wir bereits eine solche Anweisung verwendet:

  System.out.println("Dies ist mein erstes kleines Javaprogramm");

Mit dieser Anweisung wird eine Methode aufgerufen. Wir werden im Laufe des Kurses noch einige andere Anweisungen kennenlernen.

2.3.7 Anweisungsblöcke

Anweisungsblöcke beginnen, wie wir es schon kennengelernt haben, mit einer geschweiften Klammer auf '{' und enden mit einer geschweiften Klammer zu '}'. Anweisungsblöcke werden dazu verwendet um kleinere Einheiten innerhalb von Programm-, Klassen- und Methodendefinitionen zusammenzufassen. Ein Anweisungsblock kann Anweisungen, Klassendefinitionen, Methodendefinitionen oder andere in Anweisungsblöcke zusammengefasste Programmteile enthalten. In der Regel schreibt man die geschweifte Klammer auf an das Ende der Zeile, der dazugehörenden Definition. Das Ende der Zeile wird in eine eigene Zeile auf den Beginn der Definition positioniert. Innerhalb eines Anweisungsblocks wird der Sourcecode um einige Position nach rechts eingerückt. So lässt sich leichter überprüfen, ob auch keine schliessende Klammer vergessen wurde.

  class KlassenName {
    //Anweisungsblock 1
    Anweisung1;
    Anweisung2;

    public static void main(String[] args) {
      //Anweisungsblock 2
      Anweisung3;
      Anweisung4;
    }
  }

2.3.8 Variablen Vereinbarung

Variablen werden benötigt um Daten während des Programmablaufs zu speichern. Um mit Variablen arbeiten zu können, wird für sie ein Name definiert. Mit diesem Namen kann nach der Vereinbarung auf den Wert der Variablen zugegriffen werden. Die Variaben können innerhalb eines beliebigen Anweisungsblocks definiert werden. Eine Variablen Vereinbarung ist eine Anweisung und hat die Form:

  variablenTyp variablenName;

Der Variablentyp kann ein primitiver Datentyp(Primitive Datentypen) oder eine Klasse sein. Der Name der Variablen kann aus alphanumerischen Zeichen und dem Zeichen '_' bestehen. Er darf allerdings nicht mit einer Ziffer beginnen. Die Länge des Namens ist beliebig wählbar. Nach Namenskonvention werden Variablennamen grundsätzlich klein geschrieben. Wichtig ist, zu beachten, das in jedem Anweisungsblock ein Variablenname nur einmal verwendet werden darf, da sonst der Compiler keine eindeutige Zuweisung mehr vornehmen kann.

2.3.8.1 Wertzuweisung an Variablen

Wertzuweisungen an Variablen werden mit dem '='-Operator durchgeführt.

  variablenName = variablenWert;

Der variablenWert muss von dem Typ sein, der in der Variablen Vereinbarung für den variablenName festgelegt wurde. Die Wertzuweisung kann auch in einer Anweisung mit der Vereinbarung der Variablen durchgeführt werden.

  variablenTyp variablenName = variablenWert;

2.3.9 Primitive Datentypen

2.3.9.1 Der Typ boolean

Ein boolean Wert kann in Java nur zwei verschieden Werte annehmen: true und false. Eine Variablenvereinbarung eines boolean Wertes, kann mit folgender Anweisung implementiert werden:

  boolean wahrOderFalsch;
  boolean falschOderWahr = true;

Erweiterung der Verwendung von System.out.println:
Bei der Ausgabe mit System.out.println kann in Java mit Hilfe des '+' Operators der Ausgabetext aus mehreren Textteilen und auch Werten bestehen.

  class KlassenName {
    public static void main(String[] args) {
      variablenTyp variablenName = variablenWert;
      System.out.println("variablenName hat den Wert: " + variablenName);
    }
  }

Gibt man den Namen einer Variablen an, wird deren Wert in einen String umgewandelt und an den vorhergehenden Text angehängt.

class BooleanString {
  public static void main(String[] args) {
    boolean istDasWahr = false;
    System.out.println("istDasWahr hat den Wert: " + istDasWahr);
  }
}
Sourcefile

2.3.9.2 Die Ganzzahltypen

In Java haben alle Ganzzahltypen, egal auf welcher Plattform, immer die gleiche Länge. In C/C++ können die Längen der Ganzzahltypen je nach Plattform variieren, was zum Teil Probleme beim Datenaustausch hervorrufen kann. Alle Ganzzahltypen sind vorzeichenbehaftet. Es gibt vier Ganzzahltypen mit folgenden Wertebereichen:

Typ Wertebereich Länge
byte -128...127 8 Bit
short -32768...32767 16 Bit
int -2147483648...2147483647 32 Bit
long -9223372036854775808...9223372036854775807 64 Bit
class IntegerProgram {
  public static void main(String[] args) {
    int ersterInteger;
    ersterInteger = 5;
    System.out.println("ersterInteger = " + ersterInteger);
    int zweiterInteger = 10;
    System.out.println("zweiterInteger = " + zweiterInteger);
  }
}
Sourcefile

Aufgabe 2

Versucht man einem Typ einen Wert ausserhalb des Wertebereichs zuzuweisen, so verlangt der Compiler eine explizite Typumwandlung(cast). Diese Typumwandlung geschieht, indem man vor den eigentlichen Wert den gewünschten Typ in Klammern angibt. Man muss aber darauf achten, das eine solche Typumwandlung immer mit einem Genauigkeitsverlust verbunden ist.

class ByteCast {
  public static void main(String[] args) {
    // byte b = 1234;   Diese Zeile würde einen Compiler-Fehler verursachen
    byte b = (byte)1234;
    /*
     * Diese Zeile ist syntaktisch korrekt,
     * b hat aber den Wert -46
     */
     System.out.println("b = " + b);
  }
}
Sourcefile

2.3.9.3 Die Gleitkommatypen

In Java gibt es die beiden Gleitkommatypen double und float. Der Typ double hat doppelte Genauigkeit des Types float und eine Länge von 64 Bit, float hat eine Länge von 32 Bit. Als Default-Vereinbarung ist ein Gleitkommawert immer ein double-Wert. Das bedeutet, dass bei der Zuweisung eines Gleitkommawertes an eine float Variable immer ein "f" an den Wert angehängt oder eine Typumwandlung durchgeführt werden muss.

double x = 1.234; // korrekt
float x = 1.234;  // Compiler-Fehler
float x = 1.234f; // korrekt
float x = (float)1.234; // korrekt

Ein Gleitkommawert kann durch eine Typumwandlung auch in einen Ganzahlwert umgewandelt werden. Die Nachkommastellen werden dabei ignoriert.

class Double2Int {
  public static void main(String[] args) {
    double d1 = 1.234;
    int i1 = (int)d1;
    System.out.println("d1 = " + d1);
    System.out.println("i1 = " + i1);
    double d2 = 1.987;
    int i2 = (int)d2;
    System.out.println("d2 = " + d2);
    System.out.println("i2 = " + i2);
  }
}
Sourcefile

2.3.9.4 Der Typ char

Der Typ char bezeichnet ein einzelnes Zeichen aus dem Unicode Zeichensatz. Ein Character hat in Java die Länge 16 Bit. Einer Character Variablen kann auf drei Arten ein Wert zugewiesen werden:

class CharAssignment {
  public static void main(String[] args) {
    char c = 'a';
    System.out.println(c);
    c = 97;
    System.out.println(c);
    c = '\u0061';
    System.out.println(c);
  }
}
Sourcefile

2.4 Mathematische Operatoren

2.4.1 Arithmetische Operatoren

Die Operatoren +, -, *, /, % führen arithmetische Operationen durch. Dabei gilt: Multiplikation und Division wird vor Addition oder Subtraktion ausgeführt. Die Operationen sind dabei immer rechtsseitige Argumente.

richtig: c = a + b;
falsch: a + b = c;

Die Operatoren können mit "=" kombiniert werden. Dabei wird das rechtsseitige Argument mit Hilfe des Operators mit dem linkseitigen verknüpft und danach dem linksseitigen zugewiesen.

class MathOperators {
  public static void main(String[] args) {
    int a = 1;
    int b = 2;
    int c = 3;
    int x = a + b * c;
    System.out.println("a + b * c = " + x);
    x = (a + b) * c;
    System.out.println("(a + b) * c = " + x);
    a = a + 2;
    System.out.println("a = a + 2; --> a = " + a);
    a = 1;
    a += 2;
    System.out.println("a += 2; --> a = " + a);
  }
}
Sourcefile

Die arithmetischen Operatoren können auf alle numerischen Elemente angewandt werden. Eine Ausnahme bietet der "+"-Operator, welcher auch auf String Elemente angewandt werden kann(Strings).

2.4.1.1 Der Operator +

Führt eine Addition durch.

2.4.1.2 Der Operator -

Führt eine Subtraktion durch.

2.4.1.3 Der Operator *

Führt eine Multiplikation durch.

2.4.1.4 Der Operator /

Führt eine Division durch. Bei der Division durch zweier ganzzahliger Werte ist das Ergebnis ebenfalls ein ganzzahliger Wert, auch wenn er einem Gleitkommawert zugewiesen wird. Beim Ergebnis einer ganzzahligen Division werden die Nachkommastellen abgeschnitten.

class Divisor_1 {
  public static void main(String[] args) {
    int a = 5;
    int b = 2;
    double c = a / b;
    // c erhält den Wert 2
    System.out.println("c = " + c);
  }
}
Sourcefile

Will man einen Gleitkommawert erhalten, so muss man einen der beiden Integerwerte in einen Gleitkommawert umwandeln.

class Divisor_2 {
  public static void main(String[] args) {
    int a = 5;
    int b = 2;
    double c = a / (double)b; // oder double c = (double)a / b;
    // c erhält den Wert 2.5
    System.out.println("c = " + c);
  }
}
Sourcefile

2.4.1.5 Der Operator %

Der Operator % wird modulo-Operator genannt. Er führt eine Division durch und liefert als Ergebnis den Restwert zum grössten ganzzahligen Vielfachen des Divisors.

class Modulo {
  public static void main(String[] args) {
    int a = 5;
    int b = 2;
    int c = a % b;
    System.out.println("a % b = " + c);
  }
}
Sourcefile

2.4.2 Increment und Decrement

Java bietet, wie z.B. auch C, eine einfache Möglichkeit zum Incrementieren oder Decrementieren von numerischen Werten. Ein doppeltes Plus- oder Minuszeichen vor oder hinter dem Argument erhöht, bzw. erniedrigt das Argument um 1.

class IncrementDecrement {
  public static void main(String[] args) {
    int i = 0;
    System.out.println("i = 0; --> i = " + i);
    i = i + 1;
    System.out.println("i = i + 1; --> i = " + i);
    i += 1;
    System.out.println("i += 1; --> i = " + i);
    i++;
    System.out.println("i++; --> i = " + i);
    ++i;
    System.out.println("++i; --> i = " + i);
    i = i - 1;
    System.out.println("i = i - 1; --> i = " + i);
    i -= 1;
    System.out.println("i -= 1; --> i = " + i);
    i--;
    System.out.println("i--; --> i = " + i);
    --i;
    System.out.println("--i; --> i = " + i);
  }
}
Sourcefile

2.5 Logische Operatoren

Logische Operatoren werden auf boolean Werte angewandt oder liefern als Ergebnis boolean Werte zurück.

2.5.1 Der Negationsoperator "!"

Der Negationsoperator kann auf einen boolean Typ angewendet werden. Der vorhanden Wert wird negiert, dies bedeutet aus true wird false und umgekehrt.

class Negation {
  public static void main(String[] args) {
    boolean b1 = true;
    System.out.println("b1 = " + b1);
    boolean b2 = !b1;
    System.out.println("b2 = !b1 = " + b2);
    boolean b3 = !b2;
    System.out.println("b3 = !b2 = " + b3);
  }
}
Sourcefile

2.5.2 Vergleichsoperatoren

Vergleichsoperatoren liefern als Ergebnis einen boolean Wert zurück.

2.5.2.1 Der Vergleichsoperator ==

Liefert true wenn das linksseitige Argument gleich dem rechtsseitigen Argument ist, sonst false. Der Vergleichsoperator '==' kann auf alle primitiven Datentypen, sowie auch auf Objekte angewendet werden.

class Equal {
  public static void main(String[] args) {
    System.out.println("(true == true) = " + (true == true));
    System.out.println("(true == false) = " + (true == false));
    System.out.println("(3 == 3) = " + (3 == 3));
    System.out.println("(3 == 5) = " + (3 == 5));
  }
}
Sourcefile

2.5.2.2 Der Vergleichsoperator !=

Liefert true wenn das linksseitige Argument ungleich dem rechtsseitigen Argument ist, sonst false. Der Vergleichsoperator '!=' kann auf alle primitiven Datentypen, sowie auch auf Objekte angewendet werden.

class NotEqual {
  public static void main(String[] args) {
    System.out.println("(true != true) = " + (true != true));
    System.out.println("(true != false) = " + (true != false));
    System.out.println("(3 != 3) = " + (3 != 3));
    System.out.println("(3 != 5) = " + (3 != 5));
  }
}
Sourcefile

2.5.2.3 Der Vergleichsoperator <

Liefert true wenn das linksseitige Argument kleiner dem rechtsseitigen Argument ist, sonst false. Dieser Operator ist nur auf die numerischen primitiven Datentypen anwendbar.

class Lower {
  public static void main(String[] args) {
    System.out.println("(1 < 5) = " + (1 < 5));
    System.out.println("(5 < 5) = " + (5 < 5));
    System.out.println("(5 < 3) = " + (5 < 3));
  }
}
Sourcefile

2.5.2.4 Der Vergleichsoperator <=

Liefert true wenn das linksseitige Argument kleiner oder gleich dem rechtsseitigen Argument ist, sonst false. Dieser Operator ist nur auf die numerischen primitiven Datentypen anwendbar.

class LowerEqual {
  public static void main(String[] args) {
    System.out.println("(1 <= 5) = " + (1 <= 5));
    System.out.println("(5 <= 5) = " + (5 <= 5));
    System.out.println("(5 <= 3) = " + (5 <= 3));
  }
}
Sourcefile

2.5.2.5 Der Vergleichsoperator >

Liefert true wenn das linksseitige Argument grösser dem rechtsseitigen Argument ist, sonst false. Dieser Operator ist nur auf die numerischen primitiven Datentypen anwendbar.

class Greater {
  public static void main(String[] args) {
    System.out.println("(1 > 5) = " + (1 > 5));
    System.out.println("(5 > 5) = " + (5 > 5));
    System.out.println("(5 > 3) = " + (5 > 3));
  }
}
Sourcefile

2.5.2.5 Der Vergleichsoperator >=

Liefert true wenn das linksseitige Argument grösser oder gleich dem rechtsseitigen Argument ist, sonst false. Dieser Operator ist nur auf die numerischen primitiven Datentypen anwendbar.

class GreaterEqual {
  public static void main(String[] args) {
    System.out.println("(1 >= 5) = " + (1 >= 5));
    System.out.println("(5 >= 5) = " + (5 >= 5));
    System.out.println("(5 >= 3) = " + (5 >= 3));
  }
}
Sourcefile

2.5.3 Bedingungs-Operatoren

Mit Bedingungs-Operatoren werden mehrere boolean-Werte verknüpft. Das Ergebnis einer solchen Verknüpfung ist ebenfalls vom Typ boolean.

2.5.3.1 Die Operatoren && und &

Das logische "und". Das Ergebnis dieser Verknüpfung ist nur dann true, wenn beide Argumente true sind.

class LogicAnd_1 {
  public static void main(String[] args) {
    System.out.println("(false && false) = " + (false && false));
    System.out.println("(false && true) = " + (false && true));
    System.out.println("(true && false) = " + (true && false));
    System.out.println("(true && true) = " + (true && true));
  }
}
Sourcefile

Setzt man in diesem Beispiel an Stelle des '&&'-Operators den '&'-Operator ein, so erhält man das gleiche Ergebnis. Nur der Programmablauf ändert sich. Beim '&&'-Operator wird die Überprüfung abgebrochen sobald das Ergebnis eindeutig ist. Bei der Auswertung des '&'-Operators werden auf jeden Fall alle Bedingungen überprüft. Um dies in einem weiteren Beispiel zu verdeutlichen, muss ich zwei Methoden definieren. Auf die Methodendefinition möchte ich hier nicht eingehen. Wichtig ist es hier zu wissen, das ein Aufruf einer solchen Methode genauso eingesetzt werden kann wie eine Variable. Der Unterschied besteht darin, das zuerst die Anweisungen der Methode ausgeführt werden, bevor der Wert übernommen wird.

class LogicAnd_2 {
  public static void main(String[] args) {
    System.out.println("(getFalse() && getFalse()) = " + (getFalse() && getFalse()));
    System.out.println("(getFalse() & getFalse()) = " + (getFalse() & getFalse()));
    System.out.println("(getFalse() && getTrue()) = " + (getFalse() && getTrue()));
    System.out.println("(getFalse() & getTrue()) = " + (getFalse() & getTrue()));
    System.out.println("(getTrue() && getFalse()) = " + (getTrue() && getFalse()));
    System.out.println("(getTrue() & getFalse()) = " + (getTrue() & getFalse()));
    System.out.println("(getTrue() && getTrue()) = " + (getTrue() && getTrue()));
    System.out.println("(getTrue() & getTrue()) = " + (getTrue() & getTrue()));
  }

  static boolean getFalse() {
    System.out.println("entering getFalse");
    return false;
  }

  static boolean getTrue() {
    System.out.println("entering getTrue");
    return true;
  }
}
Sourcefile

2.5.3.2 Die Operatoren || und |

Das logische "oder". Das Ergebnis dieser Verknüpfung ist true, wenn eines der beiden Argumente true ist.

class LogicOr_1 {
  public static void main(String[] args) {
    System.out.println("(false || false) = " + (false || false));
    System.out.println("(false || true) = " + (false || true));
    System.out.println("(true || false) = " + (true || false));
    System.out.println("(true || true) = " + (true || true));
  }
}
Sourcefile

Der Unterschied zwischen dem ||-Operator und dem |-Operator ist entsprechend dem Unterschied bei der Verwendung der &- und &&-Operatoren.

class LogicOr_2 {
  public static void main(String[] args) {
    System.out.println("(getFalse() || getFalse()) = " + (getFalse() || getFalse()));
    System.out.println("(getFalse() | getFalse()) = " + (getFalse() | getFalse()));
    System.out.println("(getFalse() || getTrue()) = " + (getFalse() || getTrue()));
    System.out.println("(getFalse() | getTrue()) = " + (getFalse() | getTrue()));
    System.out.println("(getTrue() || getFalse()) = " + (getTrue() || getFalse()));
    System.out.println("(getTrue() | getFalse()) = " + (getTrue() | getFalse()));
    System.out.println("(getTrue() || getTrue()) = " + (getTrue() || getTrue()));
    System.out.println("(getTrue() | getTrue()) = " + (getTrue() | getTrue()));
  }

  static boolean getFalse() {
    System.out.println("entering getFalse");
    return false;
  }

  static boolean getTrue() {
    System.out.println("entering getTrue");
    return true;
  }
}
Sourcefile

2.5.3.3 Der Operator ^

Das logische "exklusiv oder". Das Ergebnis dieser Verknüpfung ist true, wenn beide Argumente unterschiedliche Werte besitzen.

class LogicExOr {
  public static void main(String[] args) {
    System.out.println("(false ^ false) = " + (false ^ false));
    System.out.println("(false ^ true) = " + (false ^ true));
    System.out.println("(true ^ false) = " + (true ^ false));
    System.out.println("(true ^ true) = " + (true ^ true));
  }
}
Sourcefile

2.6 Bitmanipulierende Operatoren

Diese Operatoren setzen die Kenntnis des Rechnens mit Dualzahlen voraus. Eine kurze Einführung hierzu befindet sich in der Datei DualZahlen.html. Diese Datei enthält ebenso eine ausführlichere Beschreibung der Funktionen, die mit den Operatoren. durchgeführt werden. Die Argumente müssen alle einen Integertyp besitzen. Die bitmanipulierenden Operatoren können mit dem Zuweisungsoperator "=" kombiniert werden. Die in den Beispielprogrammen verwendete Methode toBinaryString der Klasse Integer, möchte ich hier nicht näher erklären, da sie nur dazu verwendet wird eine binäre Stringdarstellung der verwendeten Zahlen zu erzeugen.

2.6.1 Der Operator "&"

Verknüpft die rechtsseitigen Argumente bitweise mit dem logischen "und".

class BitAnd {
  public static void main(String[] args) {
    int x = 743;
    int y = 324;
    System.out.println("x =     " + Integer.toBinaryString(x));
    System.out.println("y =      " + Integer.toBinaryString(y));
    System.out.println("x & y =    " + Integer.toBinaryString(x & y));
  }
}
Sourcefile

2.6.2 Der Operator "|"

Verknüpft die rechtsseitigen Argumente bitweise mit dem logischen "oder".

class BitOr {
  public static void main(String[] args) {
    int x = 743;
    int y = 324;
    System.out.println("x =     " + Integer.toBinaryString(x));
    System.out.println("y =      " + Integer.toBinaryString(y));
    System.out.println("x | y = " + Integer.toBinaryString(x | y));
  }
}
Sourcefile

2.6.3 Der Operator "^"

Verknüpft die rechtsseitigen Argumente bitweise mit dem logischen "exklusiv oder".

class BitExOr {
  public static void main(String[] args) {
    int x = 743;
    int y = 324;
    System.out.println("x =     " + Integer.toBinaryString(x));
    System.out.println("y =      " + Integer.toBinaryString(y));
    System.out.println("x ^ y = " + Integer.toBinaryString(x ^ y));
  }
}
Sourcefile

2.6.4 Der Operator "<<"

Die Bits von b werden um n-Stellen nach links veschoben. Die auffüllenden Bits besitzen den Wert 0. Diese Operation entspricht der Multiplikation mit 2n.

class ShiftLeft {
  public static void main(String[] args) {
    int x = -72;
    int y = 3;
    System.out.println("Verschieben um " + y + " Stellen nach links");
    System.out.println("x =      " + Integer.toBinaryString(x));
    System.out.println("x << y = " + Integer.toBinaryString(x << y));
    System.out.println("x << y = " + (x << y));
  }
}
Sourcefile

2.6.5 Der Operator ">>"

Die Bits von b werden um n-Stellen nach rechts veschoben. Die auffüllenden Bits besitzen den Wert des Vorzeichenbits. Diese Operation entspricht der Division durch 2n.

class ShiftRight_1 {
  public static void main(String[] args) {
    int x = -72;
    int y = 3;
    System.out.println("Verschiebung um " + y + " Stellen nach rechts");
    System.out.println("x =      " + Integer.toBinaryString(x));
    System.out.println("x >> y = " + Integer.toBinaryString(x >> y));
    System.out.println("x >> y = " + (x >> y));
  }
}
Sourcefile

2.6.6 Der Operator ">>>"

Die Bits von b werden um n-Stellen nach rechts veschoben. Die auffüllenden Bits besitzen den Wert 0. Diese Operation entspricht der Division durch 2n bei positiven Zahlen.

class ShiftRight_2 {
  public static void main(String[] args) {
    int x = -72;
    int y = 3;
    System.out.println("Verschiebung um " + y + " Stellen nach rechts");
    System.out.println("x =       " + Integer.toBinaryString(x));
    System.out.println("x >>> y =    " + Integer.toBinaryString(x >>> y));
    System.out.println("x >>> 8 = " + (x >>> 8));
  }
}
Sourcefile

2.7 Bedingte Anweisungen

2.7.1 if-else

Die if-Anweisung führt eine Anweisung oder einen Anweisungsblock in Abhängigkeit von einer logischen Bedingung aus. Diese Bedingung muss den Ergebnistyp boolean besitzen.

  class KlassenName {
    public static void main(String[] args) {
      if(Bedingung1) Anweisung1;
      if(Bedingung2) {
        //Bedingung2 == true
        Anweisung2;
        Anweisung3;
        ...
      }
      ...
    }
    ...
    ...
  }

Die Bedingung kann auch einen optionalen else-Zweig besitzen, der ausgeführt wird wenn die Bedingung das Ergebnis false hat.

  class KlassenName {
    public static void main(String[] args) {
      if(Bedingung1) Anweisung1;
      else Anweisung2;
      if(Bedingung2) {
        //Bedingung2 == true
        Anweisung3;
        Anweisung4;
        ...
      } else {
        //Bedingung2 == false
        Anweisung5;
        Anweisung6;
        ...
      }
      ...
    }
    ...
    ...
  }

Ein else-Zweig wird immer dem direkt vorangestellten if zugeordnet. Dies kann dazu führen, dass man bei verschachtelten bedingten Anweisungen else-Zweige mit leeren Anweisungen einfügen muss.

  if(Bedingung1)
    if(Bedingung2) Anweisung2;
    else;
  else Anweisung3;

Man kann dies umgehen, in dem man nach dem ersten if einen Anweisungsblock einfügt.

  if(Bedingung1) {
    if(Bedingung2) Anweisung1;
  } else Anweisung2;

Grundsätzlich wird der Programmcode übersichtlicher, wenn man für jeden if- oder else-Zweig einen eigenen Anweisungsblock verwendet.

  if(Bedingung1) {
    if(Bedingung2) {
      Anweisung1;
    }
  } else {
    Anweisung2;
  }

Wird im else-Zweig eine weitere Bedingung benötigt, so kann diese direkt nach else eingegeben werden.

  if(Bedingung1) {
    Anweisung1;
    ...
  } else if(Bedingung2) {
    Anweisung2;
    ...
  }

Um ein kleines Beispiel angeben zu können, verwende ich im folgenden die Methode Math.random(), welche ich einer double-Variablen zuweisen kann. Die Methode Math.random() liefert einen Wert >= 0 und < 1.

class Random {
  public static void main(String[] args) {
    double myDouble = Math.random();
    System.out.println("Der berechnete Wert ist " + myDouble);
    if(myDouble < 0.5) {
      System.out.println("Der Wert ist kleiner als 0.5");
    } else {
      System.out.println("Der Wert ist grösser oder gleich 0.5");
    }
  }
}
Sourcefile

Aufgabe 3

2.7.2 switch-case

Die switch-Anweisung dient dazu, verschiedene Anweisungsblöcke in Abhängigkeit vom Wert eines Ausdrucks auszuführen. Der Ausdruck wird Selektor genannt.

  switch(selektor) {
    ...
    ...
  }

Der Selektor muss ein Ganzzahltyp sein, der einem int zuweisungskompatibel ist, d.h. ein char, byte, short oder int. Zur Verzweigung werden innerhalb der switch-Anweisung eine oder mehrere Marken gesetzt. Diese Marken beginnen mit dem Schlüsselwort case, gefolgt von einem konstanten Wert und einem Doppelpunkt. Hierbei darf es keine zwei Marken geben, die mit dem selben konstanten Wert verbunden sind.

  int selektor = intWert;
  switch(selektor) {
    case constant1:
      Anweisung11;
      ...
      Anweisung1m;
    case constant2:
      Anweisung21;
      ...
      Anweisung2m;
    case constant3:
      Anweisung31;
      ...
      Anweisung3l;
    ...
    ...
    ...
    case constantn:
      Anweisungn1;
      ...
      Anweisungnk;
  }

Stimmt der Wert des Selektors mit dem Wert einer case-Konstanten überein, so werden von dieser Position an alle im switch-Anweisungblock vorhandenen Anweisungen ausgeführt. Auch die Anweisungen der eventuell noch folgenden case-Marken werden ausgeführt.

class Switch_1 {
  public static void main(String[] args) {
    int x = 1;
    switch(x) {
      case 0:
        System.out.println("x = 0");
      case 1:
        System.out.println("x = 1");
      case 2:
        System.out.println("x = 2");
    }
  }
}
Sourcefile

Auf der Konsole erzeugt dieses Programm den Output:

x = 1
x = 2

Möchte man die Ausführung der Anweisungen des switch-Anweisungsblockes vorzeitig beenden, so muss das Schlüsselwort break eingefügt werden.

  int selektor = intWert;
  switch(selektor) {
    case constant1:
      Anweisung11;
      ...
      Anweisung1m;
    case constant2:
      Anweisung21;
      ...
      Anweisung2m;
    break;
    case constant3:
      Anweisung31;
      ...
      Anweisung3l;
    break;
    ...
    ...
    ...
    case constantn:
      Anweisungn1;
      ...
      Anweisungnk;
  }

Für den Fall, dass der Wert des Selektors mit keiner der case-Konstanten übereinstimmt, kann eine Marke default eingerichtet werden.

  int selektor = intWert;
  switch(selektor) {
    case constant1:
      Anweisung11;
      ...
      Anweisung1m;
    case constant2:
      Anweisung21;
      ...
      Anweisung2m;
    break;
    case constant3:
      Anweisung31;
      ...
      Anweisung3l;
    break;
    ...
    ...
    ...
    case constantn:
      Anweisungn1;
      ...
      Anweisungnk;
    break;
    default:
      AnweisungDefault1;
      ...
      AnweisungDefaultj;
  }
class Switch_2 {
  public static void main(String[] args) {
    int x = 1;
    switch(x) {
      case 0:
        System.out.println("x = 0");
      break;
      case 1:
        System.out.println("x = 1");
      break;
      case 2:
        System.out.println("x = 2");
      break;
      default:
        System.out.println("x ist weder 0 noch 1 noch 2");
    }
  }
}
Sourcefile

In diesem Fall erscheint auf der Konsole lediglich die Ausgabe x = 1.
Aufgabe 4

2.8 Schleifen

2.8.1 for

Mit der for-Schleife kann ein Anweisungsblock mit einer bestimmten Anzahl von Durchgängen wiederholt werden.

  for(int schleifenZähler = anfangsWert; schleifenBedingung; schleifenZählerAnweisung) {
      Anweisung1;
      ...
      AnweisungN;
  }

Im Kopf der for-Schleife wird zunächst eine Schleifenzählvariable definiert und ihr ein Anfangswert zugewiesen. Danach wird die Schleifenbedingung überprüft. In der Regel wird hier geprüft ob ein Schleifenendwert schon erreicht wurde.

  for(int schleifenZähler = anfangsWert; schleifenZähler < schleifenEndWert; schleifenZählerAnweisung) {
      Anweisung1;
      ...
      AnweisungN;
  }

Liefert die Bedingung der Wert true, so werden die Anweisungen des folgenden Anweisungsblocks ausgeführt. Nach Durchlaufen des Anweisungsblocks wird die Schleifenzähleranweisung ausgeführt. In den meisten Fällen wird hier die Zählvariable erhöht oder erniedrigt.

  for(int schleifenZähler = anfangsWert; schleifenZähler < schleifenEndWert; schleifenZähler++) {
      Anweisung1;
      ...
      AnweisungN;
  }

Danach wird die Schleifenbedingung erneut überprüft und wenn sie noch erfüllt ist, der Anweisungsblock ein weiteres Mal ausgeführt. Nach Abarbeiten der Anweisungen wird wieder die Schleifenzähleranweisung ausgeführt und mit der Schleifenbedingung erneut überprüft, ob der Anweisungsblock nochmals ausgeführt werden muss. Dies passiert solange, bis die Schleifenbedingung nicht mehr erfüllt ist.

class ForLoop_1 {
  public static void main(String[] args) {
    for(int i = 0; i < 10; i++) {
      System.out.println("i = " + i);
    }
  }
}
Sourcefile

Die Definition des Schleifenzählers muss nicht zwingend im Kopf der for-Schleife stehen. Es kann auch eine int-Variable verwendet werden, die schon vorher definiert wurde.

  int schleifenZähler;
  for(schleifenZähler = anfangsWert; schleifenBedingung; schleifenZählerAnweisung) {
      Anweisung1;
      ...
      AnweisungN;
  }

Auch die Zuweisung des Anfangswertes muss nicht im Kopf der Schleife vorgenommen werden.

  int schleifenZähler = anfangsWert;
  for(; schleifenBedingung; schleifenZählerAnweisung) {
      Anweisung1;
      ...
      AnweisungN;
  }

Es ist ausreichend eine leere Anweisung anzugeben. Ich würde aber wegen der besseren Übersichtlichkeit die Anfangswertzuweisung immer in den Kopf der for-Schleife schreiben. Auch die Schleifenbedingung und die Schleifenzähleranweisung können weggelassen werden. Die Bedingung wird in diesem Fall immer als erfüllt angenommen. Somit erhalten wir eine Endlosschleife, die mit einer break-Anweisung abgebrochen werden muss. Auf die Verwendung von break im Zusammenhang mit Schleifen wird später in diesem Kapitel eingegangen.
Im Kopf einer for-Schleife können auch mehrere Schleifenzähler gleichzeitig mit Anfangswerten belegt werden. Ebenso können für mehrere Schleifenzähler Anweisungen angegeben werden. Allerdings kann es nur eine Bedingung geben. Gibt es mehrere Abbruchbedingungen, so müssen diese geeignet verknüpft werden.

class ForLoop_2 {
  public static void main(String[] args) {
    int k;
    int l;
    for(k = 100, l = 0; l < 20 && k > 0; k -= 5, l++) {
      System.out.println("k = " + k);
      System.out.println("l = " + l);
    }
  }
}
Sourcefile

Aufgabe 5

2.8.2 while

Die while-Schleife dient dem Wiederholen von Anweisungen, solange eine Bedingung erfüllt ist.

  while(bedingung) {
      Anweisung1;
      ...
      AnweisungN;
  }
class WhileLoop {
  public static void main(String[] args) {
    double number = Math.random();
    while(number < 0.5) {
      System.out.println("number = " + number);
      number = Math.random();
    }
  }
}
Sourcefile

Setzt man für die Bedingung den Wert true ein, so erhält man eine Endlosschleife, die wie auch die Endlos-for-Schleife mit einer break-Anweisung abgebrochen werden muss.

  while(true) {
      ...
  }

Aufgabe 6

2.8.3 do-while

Für Fälle, in denen eine Schleife mit einer Austrittsbedingung statt mit einer Eintrittsbedingung benötigt wird, gibt es die do/while-Schleife. Bei dieser Form der Schleife werden die Anweisungen im Anweisungsblock mindestens einmal ausgeführt.

  do {
      Anweisung1;
      ...
      AnweisungN;
  } while(bedingung);
class DoWhileLoop {
  public static void main(String[] args) {
    double number;
    do {
      number = Math.random();
      System.out.println("number = " + number);
    } while(number < 0.5);
  }
}
Sourcefile

Auch in diesem Fall erhält man eine Endlosschleife, wenn für die Bedingung der Wert true eingefügt wird.

  do {
      ...
  } while(true);

Aufgabe 7

2.8.4 break

Mit der break-Anweisung kann die Ausführung von for-, while- und do- Schleifen vorzeitig abgebrochen werden oder eine Endlosschleife beendet werden. Meistens werden Endlosschleifen abgebrochen, nachdem erwartete oder nicht erwartete Zustände eingetreten sind.

  ...
  for(;;) {
    Anweisung1;
    ...
    AnweisungM;
    if(bedingung) {
      break;
    }
    ...
    AnweisungN;
  }
  ...

Ist die Bedingung erfüllt, wird das Programm am Ende des Anweisungsblockes der Schleife fortgeführt.

class BreakLoop {
  public static void main(String[] args) {
    while(true) {
      int number = (int)(Math.random() * 100);
      if((number % 11) == 0) {
        System.out.println("Der berechnet Wert ist " + number);
        break;
      }
    }
  }
}
Sourcefile

Aufgabe 8

Der Aufruf von break unterbricht nur die Schleife, in welcher der Aufruf stattfindet. Will man aus mehreren ineinander geschachtelten Schleifen direkt von einer inneren Schleife die äusserste beenden, so benötigt man:

2.8.4.1 break mit Marke

Mit der break-Anweisung ist es auch möglich, die Ausführung nach dem Abbruch hinter einem übergeordneten Programmblock fortzusetzen. Hierzu muss dem betreffenden Programmblock eine Marke vorangestellt werden, die bei einer break-Anweisung angegeben werden kann.

  ...
  sprungMarke: {
    ...
    while(true) {
      ...
      for(int schleifenZähler; schleifenZähler < endWert; schleifenZähler++) {
        ...
        if(bedingung) {
          break sprungMarke;
        }
        ...
      }
      ...
    }
    ...
  }
  ...

Wird der Aufruf von break in der for-Schleife erreicht, so wird das Programm nachdem Ende des Anweisungsblocks der Sprungmarke weiter ausgeführt.

class BreakMarkForLoop {
  public static void main(String[] args) {
    myBreakMark: {
      int counter = 0;
      int dummy = 0;
      for(int i = 0; i < 30; i++) {
        for(int j = 0; j < 20; j++) {
          int eyes = 1 + (int)(Math.random() * 6);
          dummy++;
          if(eyes == 6) {
            counter++;
            if(counter == 100) {
              System.out.println("Nach " + ((i * 20) + j + 1) + " Versuchen wurde 100 mal die 6 gewürfelt");
              break myBreakMark;
            }
          }
        }
      }
      System.out.println("Es wurde mit 600 Versuchen nicht 100 mal die 6 gewürfelt.");
    }
    System.out.println("Das Ende der Sprungmarke ist erreicht.");
}
Sourcefile

2.8.5 continue

Die Anweisung continue darf nur innerhalb einer Schleife benutzt werden. Sie bewirkt, dass die nachfolgenden Anweisungen im Schleifenrumpf übersprungen werden und der nächste Schleifendurchgang eingeleitet wird.

  for(int schleifenZähler; schleifenZähler < endWert; schleifenZähler++) {
    Anweisung1;
    ...
    AnweisungM;
    if(bedingung) {
      continue;
    }
    AnweisungM+1;
    ...
    AnweisungN;
  }

Wenn die Bedingung innerhalb der for-Schleife erfüllt ist, so werden die Anweisungen (AnweisungM+1 bis AnweisungN) bis zum Ende der for-Schleife nicht mehr ausgeführt sondern mit dem nächsten Schleifendurchlauf begonnen. Das bedeutet in diesem Fall, dass der Schleifenzähler um eins erhöht wird, danach die Schleifenbedingung überprüft wird und eventuell der Anweisungsblock wieder ausgeführt wird.

class ContinueWhileLoop {
  public static void main(String[] args) {
    int counter = 0;
    int counter6 = 0;
    while(counter < 20) {
      int eyes = 1 + (int)(Math.random() * 6);
      counter6++;
      if(eyes < 6) {
        continue;
      }
      counter++;
    }
    System.out.println("Es wurden " + counter6 + " Versuche benötigt um 20 mal die 6 zu würfeln.");
  }
}
Sourcefile

2.8.5.1 continue mit Marke

Auch mit continue ist es möglich aus einer inneren Schleife heraus an eine Marke zu springen.

  ...
  sprungMarke:
  ...
  while(true) {
    ...
    for(int schleifenZähler; schleifenZähler < endWert; schleifenZähler++) {
      ...
      if(bedingung) {
        continue sprungMarke;
      }
      ...
    }
    ...
  }
  ...
class ContinueMarkWhileLoop {
  public static void main(String[] args) {
    int i = 0;
    myContinueMark:
      while(i < 5) { 
        int j = 0; 
        i = i + 1;
        while(j < 5) {
          System.out.println("j = " + j);
          if(i == 2) continue myContinueMark;
          j = j + 1;
        }
        System.out.println("i = " + i);
      }
  }
}
Sourcefile

Aufgabe 9

Created with Vim Zurück   Weiter