[[PageOutline(1-2)]]

= Aufbau des Java Skripts =
Im Skript wird im Wesentlichen nur auf die grundlegenden Java Konstruktionen und die in der Vorlesung vorgestellten Programmcodes mit kurzen Erläuterungen eingegangen.

Darüber hinaus beachten Sie bitte die [[Skript/1. Einführung/Literaturempfehlungen|Literaturempfehlungen]]. Insbesondere verweise ich bei den einzelnen Kapiteln immer wieder auf das online verfügbare Buch [[http://openbook.rheinwerk-verlag.de/javainsel/|Java ist auch eine Insel]], derzeit in Version 10, von Christian Ullenboom.

= Java Version =
In der Lehrveranstaltung Strukturierte und objektorientierte Programmierung wird derzeit Java in Version 8 verwendet. Darauf bezieht sich auch dieses Skript. Externe Verlinkungen zur API oder zu Downloads führen ebenfalls zur Java Version 8. Für die Teilnahme an der Lehrveranstaltung ist mindestens die Version 7 erforderlich, falls für Ihre Plattform Version 8 nicht verfügbar sein sollte.

Im Skript finden Sie weitere Hinweise zur Einrichtung Ihrer [[Skript/1. Einführung/Arbeitsumgebung|Arbeitsumgebung]].

= Algorithmen und Programme =
Computer führen Programme aus, die aus Anweisungen und Strukturelementen zusammengebaut werden. Solche Sammlungen von Anweisungen und Strukturelementen nennt man Algorithmen:

 Algorithmus:: Ein Algorithmus ist eine endliche Folge von Einzelanweisungen.

Aus der realen Welt sind uns eine Vielzahl von Algorithmen bekannt. Tatsächlich sind die allermeisten Vorgänge des täglichen Lebens Algorithmen, wobei nach bestimmten, oft zuvor festgelegten Regeln, wiederkehrende Aktivitäten ausgeführt werden. Beispiele dafür sind Rezepte in Kochbüchern, das Autofahren, die Montage von Möbeln oder Verwaltungsvorgänge.

Ein Beispiel für einen einfachen, informatiknahen Algorithmus, der aber eine hohe Dynamik aufweist, ist die [[https://de.wikipedia.org/wiki/Collatz-Problem|Collatz-Funktion]]:

{{{
 1: Lies x ein
 2: Setze z auf Null
 3:
 4: Solange x ungleich Eins ist führe aus:
 5:     
 6:     Falls x gerade ist führe aus:
 7:         Halbiere x
 8:
 9:     Sonst (falls x nicht gerade ist) führe aus:
10:         Verdreifache x und erhöhe es um Eins
11:
12:     Erhöhe z um Eins
13:
14: Gib z aus
}}}

Für einen solchen Algorithmus lässt sich ein Trace angeben, das ist das Protokoll eines kompletten Durchlaufs durch den Algorithmus für einen bestimmten Eingabewert. Dabei wird jede Änderung von Werten, die in Variablen gespeichert sind, in einer Zeile erfasst. Wird beispielsweise am Anfang der Wert 3 in die Variable x eingelesen, ergibt sich für die Collatz-Funktion der folgende Trace:

||= Zeile =||= Wert von x =||= Wert von z =||
|| Anfang  ||  undefiniert || undefiniert  ||
||        1||             3|| undefiniert  ||
||        2||             3||             0||
||       10||            10||             0||
||       12||            10||             1||
||        7||             5||             1||
||       12||             5||             2||
||       10||            16||             2||
||       12||            16||             3||
||        7||             8||             3||
||       12||             8||             4||
||        7||             4||             4||
||       12||             4||             5||
||        7||             2||             5||
||       12||             2||             6||
||        7||             1||             6||
||       12||             1||             7||
||   Ende  ||             1||             7||

Aus den Überlegungen zu Algorithmen lässt sich die Definition eines Programms ableiten:

 Programm:: Ein Programm ist ein Algorithmus, der von einem Computer ausgeführt werden kann.

= Grundstruktur eines Java-Programms =

== Schlüsselworte ==
Die Sprache Java besteht aus einem begrenzten Satz von Worten, die man Schlüsselworte nennt. Aus diesem Wortschatz lassen sich alle Programme aufbauen. Die Schlüsselworte sind sogenannte **reservierte Worte** mit fester Bedeutung. Sie dürfen nicht als Namen (Bezeichner) für [[Skript/2. Java/ 2. Anweisungen, Variable und Datentypen|Variable]], [[Skript/2. Java/ 8. Objektorientierte Programmierung|Klassen]], [[Skript/2. Java/ 5. Methoden|Methoden]] usw. verwendet werden. Die vollständige Liste der Schlüsselworte findet sich in der [[https://docs.oracle.com/javase/specs/jls/se8/html/jls-3.html#jls-3.9|Java Sprachspezifikation]].

== `HelloWorld`==

Java-Programme bestehen aus mindestens einer [[Skript/2. Java/ 8. Objektorientierte Programmierung|Klasse]], die eine [[Skript/2. Java/ 5. Methoden|Methode]] namens `main` enthält. Das folgende Programm `HelloWorld` ist das einfachste denkbare Java-Programm. Es hat keinerlei Funktion (es tut nichts):

{{{
#!java
public class HelloWorld {

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

}
}}}

Später werden wir die Details und Strukturelemente vertieft betrachten, hier nur kurz zur Erläuterung:

* `public`: Schlüsselwort, das festlegt, dass das Strukturelement öffentlich ist, ohne Einschränkung im Rest des Java-Programms verwendet werden kann.
* `class`: Schlüsselwort, das festlegt, dass das Strukturelement eine Klasse ist
* `HelloWorld`: Name der Klasse und damit in diesem Fall auch Name des Programms.
* `static`: Schlüsselwort, das festlegt, dass das Strukturelement (hier die Methode `main`) statisch zur Klasse `HelloWorld` gehört. Die Methode kann dadurch [[Skript/2. Java/ 8. Objektorientierte Programmierung#attribute|Attribute]] der Klasse nicht verändern.
* `String[] args`: definiert ein [[Skript/2. Java/ 6. Arrays|Array]] von Zeichenketten (Strings) unter dem Namen `args`, das die Kommandozeilenparameter des Java-Programms enthält, falls es mit Parametern von der Kommandozeile gestartet wurde.

== Dateinamen ==
Eine Java Klasse muss in einer Datei liegen, die denselben Namen wie die Klasse mit der Dateiendung `.java` trägt. Die Klasse `HelloWorld` muss also in der Datei `HelloWorld.java` liegen.

== Ausgaben auf der Konsole ==
Ausgaben auf die Konsole können mit den [[Skript/2. Java/ 5. Methoden|Methoden]] [[https://docs.oracle.com/javase/8/docs/api/java/io/PrintStream.html#print-java.lang.String-|print]] und [[https://docs.oracle.com/javase/8/docs/api/java/io/PrintStream.html#println-java.lang.String-|println]] der Standardausgabe ([[https://docs.oracle.com/javase/8/docs/api/java/lang/System.html#out|System.out]]) erfolgen. Das folgende Programm gibt die Zeichenkette ''Hello World'' auf der Kommandozeile aus:

{{{
#!java
public class HelloWorld {

  public static void main(String[] args) {
    System.out.println("Hello World");
  }

}
}}}

`System.out.println` erzeugt nach der Ausgabe noch einen Zeilenumbruch, bei der Verwendung von `System.out.print` wird der Zeilenumbruch weggelassen.

== Eingaben von der Tastatur ==

Für Eingaben von der Tastatur verwenden wir ein Objekt der Klasse `Scanner`. Die Klasse [[https://docs.oracle.com/javase/8/docs/api/index.html?java/util/Scanner.html|Scanner]] gehört zum Lieferumfang der Java-Programmierschnittstelle ([[https://docs.oracle.com/javase/8/docs/api/index.html?overview-summary.html|Java API]]) und liegt dort im Paket [[https://docs.oracle.com/javase/8/docs/api/index.html?java/util/package-summary.html|java.util]]. Das folgende Programm gibt eine Meldung aus, nimmt dann eine `Integer`zahl von der Tastatur entgegen und gibt diese Zahl auf der Konsole aus:

{{{
#!java
// Klasse Scanner importieren
import java.util.Scanner;

// Klasse HelloWorld definieren
public class HelloWorld {

  public static void main(String[] args) {

    // Scanner initialisieren
    Scanner scan = new Scanner(System.in);

    // Meldung ausgeben
    System.out.print("Bitte geben Sie eine Zahl ein: ");

    // Variable für die Zahl deklarieren
    int zahl;

    // Zahl von der Tastatur einlesen
    zahl = scan.nextInt();

    // Zahl wieder ausgeben
    System.out.println(zahl);
  }
}
}}}

Weitere Möglichkeiten, mit der Klasse Scanner Daten einzulesen, finden Sie im Kapitel [[Skript/2. Java/ 2. Anweisungen, Variable und Datentypen#primitiveDatentypen|Anweisungen, Variable und Datentypen]].