Diese Übersicht fasst die (für das Abitur in NRW) wichtigsten Java-Befehle und -Konstrukte auf einer Seite zusammen.

Eine vollständige Liste aller Java-Befehle kann in der Java API Dokumentation nachgeschlagen werden.

Gezieltere Informationen gibt es hier im Wiki, zum Beispiel im Lernpfad Objektorientierte Programmierung mit Java.

Das Inhaltsverzeichnis und die Suchfunktion in eurem Browser helfen euch beim Auffinden von Informationen. Drückt dazu Strg+F und gebt einen Suchbegriff ein (z.B. "Zufall").

Die Syntax der Sprachelemente ist zum Teil als Syntaxdiagramm dargestellt.

Kommentare🔖

Zeilen, die mit // beginnen werden vom Programm ignoriert. Sie dienen dazu, den Quelltext mit Kommentaren zu versehen, die das Verständnis erleichtern.

// Ich werde nicht ausgeführt
// System.out.println("Ich auch nicht");
System.out.println("Ich aber"); // Ab hier wird wieder ignoriert

Um größere Teile des Quelltextes zu ignorieren, können die Symbole /* und */ benutzt werden.

/*
Ich werde nicht ausgeführt
 
 
System.out.println("Ich auch nicht");
*/
System.out.println("Ich aber");

JavaDoc Kommentare🔖

JavaDoc ist eine besondere Form von Kommentaren, die dazu genutzt werden, Klassenelemente zu dokumentieren. Da sie eine vorgegebene Struktur haben, können sie automatisch verarbeitet werden und zum Beispiel als Website ausgegeben werden. Die Java-API Dokumentation ist zum Beispiel so entstanden.

Ein JavaDoc Kommentar hat diese Form:

/**
 * Kurze Beschreibung der Methode
 *
 * Ggf. ausführliche Beschreibung.
 * @param a Erster Summand
 * @param b Zweiter Summand
 * @return Summe der Parameter
 */
public int summe( int a, int b ) {
    return a+b;
}

Weiter Beispiele und Beschreibungen finden sich im Wikibook Java Standard.

BlueJ kann die JavaDoc-Dokumentation direkt anzeigen, indem man oben rechts im Editor von "Quelltext" auf "Dokumentation" wechselt.

Datentypen🔖

Eine vollständige Liste ist im Lernpfad Objektorientierte Programmierung mit Java zu finden.

Strings (Texte)🔖

Strings bestehen aus einer Kette von chars, sie gehören aber nicht zu den primitiven Datentypen, sondern sind Objekte. Daher gelten für Strings einige Besonderheiten:

1. Strings besitzen Methoden, um mit den enthaltenen Zeichenketten zu arbeiten:

   1. java.lang.String.length() - Ermittelt die Länge der Zeichenkette.
   2. java.lang.String.toUpperCase() - Erstellt eine Kopie der Zeichenkette, die nur aus Großbuchstaben besteht.
   3. Und noch viele mehr ...

2. Strings müssen mit der equals(Object)-Methode verglichen werden, nicht mit ==:

   String hallo = "Hallo, Welt!";
   if( hallo.equals("Hallo und Tschüß!") ) {
       System.out.println("Die Strings passen nicht!");
   }

Typumwandlungen🔖

Datentypen können ineinander umgewandelt werden (Typecasting). Dazu wird der Zieltyp in runden Klammern dem Wert voran gestellt.

int zahl = (int) 4.563;
boolean wahrheit = (boolean) zahl;

Je nachdem, welche Typen vorkommen, wird ein anderes Vorgeben beim Umwandeln benutzt. Zum Beispiel werden beim double Wert 4.563 im Beispiel oben einfach die Nachkommastellen abgeschnitten, um daraus den int Wert 4 zu machen. (Es wird also nicht gerundet!)

Operatoren🔖

Rechenoperatoren🔖

Vergleichsoperatoren🔖

Logische Verknüpfungen🔖

Allgemeine Programmkonstrukte🔖

Variablen🔖

Lokale Hilfsvariablen🔖

Objektvariablen🔖

Parametervariablen🔖

Rückgabevariablen🔖

Methoden🔖

Programmkonstrukte zur Ablaufsteuerung🔖

Bedingte Anweisungen🔖

• if-Anweisung (Bedingte Anweisung)

  

  if( i > 5 ) {
  System.out.println('i ist grösser als 5');
  }

• if-else-Anweisung (Alternative)

  

  if( i > 5 ) {
      System.out.println('i ist grösser als 5');
  } else {
      System.out.println('i ist kleiner oder gleich 5');
  }

• if-elseif-Anweisung

  

  if( i > 5 ) {
      System.out.println('i ist grösser als 5');
  } elseif( i < 3 ) {
      System.out.println('i ist kleiner als 3');
  } else {
      System.out.println('i ist 3, 4 oder 5');
  }

|- | if-elseif-Anweisung

|- | switch-Anweisung

Kurzschreibweise für viele if-elseif-Anweisungen hintereinander. Die switch-Anweisung funktioniert nur mit primitiven Datentypen. (Also z.B. mit char, aber nicht mit String.) |

|}
 
### Schleifen
{| {{prettytable}}
! Beschreibung
! Syntax
! Beispiel
|-
| **while-Schleife**
 
(Kopfgesteuerte Schleife, Bedingte Schleife)
| ![](/images/Java-Syntax-While.png)
| ```java
int i = 0;
while( i < 10 ) {
	System.out.println("i ist jetzt " + i);
	i += 1;
}

|- | do-while-Schleife

(Fußgesteuerte Schleife) |

|-
| **for-Schleife**
 
(Zählschleife)
| ![](/images/Java-Syntax-For.png)
| ```java
for( int i = 0; i < 100; i++ ) {
	System.out.println("i ist jetzt " + i);
}

|}

Fehlerbehandlung🔖

{| {{prettytable}} ! Beschreibung ! Syntax

! Beispiel
try-catch-Anweisung
```java
try {

// Anweisungen die ggf. einen Fehler (Exception) produzieren
// Sobald ein Fehler produziert wurde, wird in den catch-Teil gesprungen

} catch( Exception e1 ) { System.err.println("Ein Fehler ist aufgetreten!"); }

|-
| **try-catch-finally-Anweisung**
| ![](/images/Java-Syntax-Trycatch.png)
| ```java
try {
	// Anweisungen die ggf. einen Fehler (Exception) produzieren
	// Sobald ein Fehler produziert wurde, wird in den catch-Teil gesprungen
} catch( Exception e1 ) {
	System.err.println("Ein Fehler ist aufgetreten!");
} finally {
	System.err.println("Diese Anweisung wird auf jeden Fall ausgeführt.");
}

|}

Statt Exception können auch konkrete Fehler abgefangen werden. Dien Liste der Standard-Exceptions findet sich unter {{Java API|java.lang.Exception}}. (Es können aber auch eigene Exceptions erstellt werden.) Es ist auch erlaubt mehrere catch-Blöcke anzugeben:

try {
	// Anweisungen die ggf. mehrere Fehler (Exceptions) produzieren
	// z.B. InputMismatchException oder NoSuchElementException
    // in Scanner#nextInt().
} catch( InputMismatchException e1 ) {
	System.err.println("Eingabe kann nicht in Zahl umgewandelt werden!");
} catch( NoSuchElementException e2 ) {
	System.err.println("Keine weitere Eingabe vorhanden!");
}

Klassen aus der Java-API🔖

Ausgaben🔖

{| {{prettytable}} ! Beschreibung

|-
| Ausgabe von Text mit Zeilenumbruch in der Konsole
| ```java
System.out.println("Hallo, Welt!");

|- | Ausgabe von Text mit Formatierungen in der Konsole | ```java System.out.printf("%s, %s!\n", "Hallo", "Welt");

|-
| Ausgabe von Text in der Fehlerkonsole
| ```java
System.err.println("Hallo, Welt!");

|}

{{Java API|java.lang.Math}}🔖

Sammlung von mathematischen Hilfsfunktionen (Runden, Wurzel, Logarithmus, ...). Ein vollständige Übersicht findet ihr in der [[java8:java/lang/Math|Java API Dokumentation]].

{| {{prettytable}} ! Beschreibung ! Signatur

|-
| Zufallszahlen zwischen 0 und 1 erzeugen. (1 wird nie erzeugt.)
| {{Java API|java.lang.Math|random--|long Math.random()}}
| ```java
double zufall = Math.random();

|- | Quadratwurzel berechnen. | {{Java API|java.lang.Math|sqrt-double-|double Math.sqrt(double radikant)}} | ```java double wurzel = Math.sqrt(2); // 1.41

 
|}
 
### {{Java API|java.util.Random}}
 
Hilfsklasse, um Zufallswerte verschiedener Typen zu erzeugen.
 
{{Hinweis|Die Klasse muss zuerst _importiert_ werden. Schreibe in Zeile 1:<br/>
`import java.util.Random;`}}
 
{| {{prettytable}}
! Beschreibung
! Signatur
! Beispiel
|-
| Zufällige ganze Zahl von `0` bis `max-1` erzeugen.
| {{Java API|java.util.Random|nextInt-int-|int nextInt(int max)}}
| ```java
Random rand = new Random();
// Zufallszahl von 0 bis 99
int zufall = rand.nextInt(100);
// Zufallszahl von 50 bis 69
int zufall2 = rand.nextInt(20)+50;

|- | Zufälligen Wahrheitswert erzeugen. | {{Java API|java.util.Random|nextBoolean--|boolean nextBoolean()}} | ```java Random rand = new Random(); boolean zufall = rand.nextBoolean();

|-
| Zufällige Zahl zwischen 0 und 1 erzeugen, wobei 1 niemals erzeugt wird (exklusive).
| {{Java API|java.util.Random|nextDouble--|double nextDouble()}}
| ```java
Random rand = new Random();
double zufall = rand.nextDouble();

|}

{{Java API|java.util.Scanner}}🔖

[[java8:java/util/Scanner|Die Klasse Scanner]] ist eine Hifsklasse, die das Einlesen von Benutzereingaben in der Konsole erleichtert. Zunächst muss ein Objekt der Klasse mit dem Parameter System.in erstellt werden: javaScanner konsole = new Scanner(System.in);.

{{Hinweis|Die Klasse muss zuerst importiert werden. Schreibe in Zeile 1:
import java.util.Scanner;}}

{| {{prettytable}} ! Beschreibung ! Signatur

|-
| Einlesen einer Textzeile. Die Eingabe muss mit {{Button|ENTER}} abgeschlossen werden.
| {{Java API|java.util.Scanner|nextLine--|String nextLine()}}
| ```java
Scanner konsole = new Scanner(System.in);
String eingabe = konsole.nextLine();

|}

Datentyp-Klassen🔖

{{Java API|java.lang.String}}🔖

{| {{prettytable}} ! Beschreibung ! Signatur

|-
| Gibt das Zeichen an Index `i` zurück. Das erste Zeichen hat den Index `0`.
| {{Java API|java.lang.String|charAt-int-|char charAt( int i )}}
| ```java
char firstChar = "Hallo, Welt!".charAt(0); // 'H'
char fourthChar = "Hallo, Welt!".charAt(3); // 'l'

|- | Wandelt alle Zeichen in Großbuchstaben um. | {{Java API|java.lang.String|toUpperCase--|String toUpperCase()}} | ```java String text = "Hallo, Welt!"; String upper = text.toUpperCase(); // HALLO, WELT!

|-
| Wandelt alle Zeichen in Kleinbuchstaben um.
| {{Java API|java.lang.String|toLowerCase--|String toLowerCase()}}
| ```java
String text = "Hallo, Welt!";
String upper = text.toLowerCase(); // hallo, welt!

|- | Findet die Position im String, an der der Text suchen zum ersten Mal vorkommt. Kommt der Text gar nicht vor, dann wird -1 zurück gegeben. Das erste Zeichen hat den Index 0. | {{Java API|java.lang.String|indexOf-java.lang.String-|int indexOf( String suchen )}} | ```java String text = "Hallo, Welt!"; int position = text.indexOf(","); // 5 text.indexOf("Foo"); // -1

|-
| Ersetzt das erste vorkommen von `suche` mit `ersatz`.
| {{Java API|java.lang.String|replaceFirst-java.lang.String-java.lang.String-|String replaceFirst(String suche, String ersatz)}}
| ```java
String text = "Hallo, Welt!";
text.replaceFirst("Welt", "Wald"); // Hallo, Wald!

|}

{{Java API|java.lang.Integer}}🔖

{| {{prettytable}} ! Beschreibung ! Signatur

|-
| Konvertiert eine Zahl in einen String.
| {{Java API|java.lang.Integer|toString-int-|String Integer.toString(int zahl)}}
| ```java
int zahl = 5;
String alsText = Integer.toString(zahl);

|}

Zu allen primitiven Datentypen gibt es eigene Datentyp-Klassen (sog. Wrapper-Klassen):

• {{Java API|java.lang.Character}}
• {{Java API|java.lang.Byte}}
• {{Java API|java.lang.Short}}
• {{Java API|java.lang.Long}}
• {{Java API|java.lang.Double}}
• {{Java API|java.lang.Float}}
• {{Java API|java.lang.Boolean}}

[[Kategorie:Befehlsreferenz]][[Kategorie:Java]]