Programmierung,
Datenstrukturen und
Algorithmen
Dr. Christian Schönberg
Java
Lernziele
▪ Eigenschaften, Terminologie und Arbeitsweise von Java
▪ Variablendeklaration, Wertzuweisung
▪ Blöcke
▪ Bedingungen (if)
▪ Schleifen (while)
▪ Kommentare
▪ Typische Fehler
3
Was ist Java?
▪ Imperative, objekt-orientierte Programmiersprache
▪ Sammlung von Entwicklungswerkzeugen
▪ Klassenbibliothek
▪ Begriffe
▪ Java SE/EE: Standard Edition/Enterprise Edition
▪ JRE: Java Runtime Environment (zum Ausführen)
▪ JDK: Java Development Kit (für Entwickler)
▪ JVM: Java Virtual Machine (siehe Compiler/Interpreter)
4
Funktionsweise
Java Programm
(*.java)
Java
Compiler
Java Bytecode
(*.class)
JVM für JVM für JVM für
…
Windows Linux OSX
Windows Linux OSX
Programm- Programm- Programm-
…
ausführung ausführung ausführung
5
Eigenschaften von Java
▪ einfach ▪ verteilt
▪ objekt-orientiert ▪ parallel
▪ plattformunabhängig ▪ dynamisch
▪ robust ▪ statische Typprüfung
▪ sicher ▪ weit verbreitet
▪ schnell ▪ kostenlos
6
Programm-Vorlage
public class <KLASSEN-NAME> {
public static void main(String[] args) {
<CODE>
…
}
→ speichern als <KLASSEN-NAME>.java
7
Beispielprogramm
public class Factorial {
public static void main(String[] args) {
int number = 5;
int result = 1;
while (number > 0) {
result = result * number;
number = number - 1;
}
System.out.println(result);
}
8
Beispielprogramm: Struktur
Klasse public class Factorial {
Main-Methode public static void main(String[] args) {
int number = 5;
int result = 1;
while (number > 0) {
result = result * number;
number = number - 1;
}
System.out.println(result);
}
9
Ausführung des Beispielprogramms
Factorial.java
public class Factorial {
public static void main(String[] args) {
int number = 5;
int result = 1;
Java Programm while (number > 0) {
result = result * number;
number = number - 1;
(*.java) }
}
System.out.println(result);
Java
Compiler console> javac Factorial.java
Java Bytecode Factorial.class
(*.class) 0010110100101001110010110101101001101011100010100001110100
1110100011100100001111001001110000110001010011000100101001
JVM für
<…> console> java Factorial
Programm-
ausführung 120
10
Entwicklungsumgebungen
11
Variablen und
Anweisungen
Variablen
▪ Platzhalter für Werte
▪ Funktionsweise (anders als in der Mathematik):
▪ Variable deklarieren (Name und Typ festlegen)
▪ int number (die Variable mit Namen „number“ kann Zahlenwerte aufnehmen)
▪ Wert zuweisen
▪ number = 5 (die Variable hält jetzt den Wert 5)
▪ Wert abfragen (mehrfach)
▪ number > 0 (ist der Wert der Variablen größer als 0?)
▪ neuen Wert zuweisen
▪ number = number - 1 (die Variable hält jetzt den Wert 4)
▪ Benennung
▪ Kleinbuchstabe gefolgt von beliebig vielen Buchstaben/Ziffern (vgl. Identifier)
▪ keine Schlüsselwörter
13
Beispielprogramm (2)
public class Factorial {
public static void main(String[] args) {
int number = 5;
int result = 1;
while (number > 0) {
result = result * number;
number = number - 1;
}
System.out.println(result);
}
14
Beispielprogramm (2)
public class Factorial {
public static void main(String[] args) {
int number = 5;
Variablendeklaration
int result = 1;
while (number > 0) {
result = result * number;
number = number - 1;
}
System.out.println(result);
}
15
Beispielprogramm (2)
public class Factorial {
public static void main(String[] args) {
int number = 5;
Wertzuweisung
int result = 1;
while (number > 0) {
Alte Werte auslesen und result = result * number;
neue Werte zuweisen number = number - 1;
}
System.out.println(result);
}
16
Beispielprogramm (2)
public class Factorial {
public static void main(String[] args) {
int number = 5;
int result = 1;
while (number > 0) {
result = result * number;
number = number - 1;
}
Ausgabe des aktuellen
System.out.println(result);
Werts der Variablen auf
}
der Konsole
}
17
Grammatik: Variablendeklaration
VariableDeclaration = DataType , Identifier , [ "=" , Value ] , ";" ;
18
Einfache Arithmetische Operationen
▪ Addition, Subtraktion, Multiplikation und ganzzahlige Division
▪ von Zahlen (Konstanten) und Variablen
▪ „Punkt vor Strich“
▪ Klammerausdrücke
int x = 5 + 4;
int y = 9 - 3 * 2;
int z = x / (y - 1);
System.out.println(z);
4
19
Grammatik: Arithmetik
Value = ConstantValue ;
Value = Value , ( "+" | "-" | "*" | "/" | "%" ) , Value ;
Value = "(" , Value , ")" ;
Value = Identifier ;
20
Anweisung
▪ Vollständiger „Befehl“ in Java
▪ Beispielsweise eine einfache Variablendeklaration oder eine
Berechnung
int x = 7;
int y = 5 * x;
▪ Wird immer mit einem ; abgeschlossen
21
Struktur: Blöcke
▪ Sequenz von Anweisungen
▪ Eingeschlossen in { }
▪ Anweisungen im Block werden sequentiell ausgeführt
{
int number = 5;
int result = 1;
{
result = result * number;
number = number - 1;
}
System.out.println(result);
}
▪ Durch Blöcke können Anweisungen gruppiert werden
▪ Können überall verwendet werden, wo eine Anweisung stehen kann
22
Grammatik: Anweisungen und Blöcke
Statement = VariableDeclaration | VariableAssignment | … ;
VariableAssignment = Identifier , "=" , Value , ";" ;
Block = "{" , { Statement } , "}" ;
23
Gültigkeitsbereich von Variablen
▪ Variablen sind gültig (sichtbar) in dem Block, in dem sie
definiert sind
▪ Sie sind ebenfalls gültig in allen darin verschachtelten
Unterblöcken
{
int x = 5;
{
int y = x + 3;
int z = 7;
}
x = z - 2;
}
24
Bedingte und
wiederholte
Anweisungen
Bedingte Anweisungen (if)
▪ Ein Block von Anweisungen wird nur ausgeführt, wenn eine
bestimmte Bedingung erfüllt ist
int x = ...;
if (x == 3) {
System.out.println(x);
}
▪ Wenn eine Bedingung nicht erfüllt ist, kann ein anderer Block
ausgeführt werden
int x = ...;
if (x == 0) {
System.out.println(0);
} else {
System.out.println(100 / x);
}
26
Bedingte Anweisungen (if) (2)
27
Bedingte Anweisungen (if) (3)
int x = ...;
if (x == 0) {
System.out.println(0);
} else if (x > 10) {
System.out.println(100 / x);
} else if (x > 0) {
System.out.println(10 / x);
} else {
System.out.println(-1 * x);
}
28
Einfache Bedingungen
int x = ...;
if (x == 0) { gleich
System.out.println(x);
}
if (x > 10) { größer
System.out.println(x);
}
if (x < 10) { kleiner
System.out.println(x);
}
if (x != 0) { ungleich
System.out.println(x);
}
Auswertung if (x >= 5 && x <= 10) { größer/gleich und kleiner/gleich
▪ von links nach rechts System.out.println(x);
▪ lazy }
if (x <= 5 || x >= 10) { kleiner/gleich oder größer/gleich
System.out.println(x);
}
29
Grammatik: Bedingte Anweisungen
IfStatement = "if" , "(" , BooleanValue ")" , Block ;
BooleanValue = BooleanConstant | Identifier | Comparison ;
BooleanConstant = "true" | "false" ;
Comparison = Value , ( "<" | ">" | "==" | "<=" | ">=" | "!=" ) , Value ;
30
Schleifen (while)
▪ Schleifen wiederholen die Ausführung einer Anweisung/eines
Blocks von Anweisungen so lange, wie eine Bedingung erfüllt
ist
int x = 0;
while (x < 3) {
x = x + 1;
System.out.println(x);
}
31
Schleifen (while)
▪ Schleifen wiederholen die Ausführung einer Anweisung/eines
Blocks von Anweisungen so lange, wie eine Bedingung erfüllt
ist
int x = 0; Speicher Ausgabe
while (x < 3) { x = 0
x = x + 1;
System.out.println(x);
}
32
Schleifen (while)
▪ Schleifen wiederholen die Ausführung einer Anweisung/eines
Blocks von Anweisungen so lange, wie eine Bedingung erfüllt
ist
int x = 0; Speicher Ausgabe
while (x < 3) { x = 0
x = x + 1;
System.out.println(x);
}
33
Schleifen (while)
▪ Schleifen wiederholen die Ausführung einer Anweisung/eines
Blocks von Anweisungen so lange, wie eine Bedingung erfüllt
ist
int x = 0; Speicher Ausgabe
while (x < 3) { x = 1
x = x + 1;
System.out.println(x);
}
34
Schleifen (while)
▪ Schleifen wiederholen die Ausführung einer Anweisung/eines
Blocks von Anweisungen so lange, wie eine Bedingung erfüllt
ist
int x = 0; Speicher Ausgabe
while (x < 3) { x = 1 1
x = x + 1;
System.out.println(x);
}
35
Schleifen (while)
▪ Schleifen wiederholen die Ausführung einer Anweisung/eines
Blocks von Anweisungen so lange, wie eine Bedingung erfüllt
ist
int x = 0; Speicher Ausgabe
while (x < 3) { x = 1 1
x = x + 1;
System.out.println(x);
}
36
Schleifen (while)
▪ Schleifen wiederholen die Ausführung einer Anweisung/eines
Blocks von Anweisungen so lange, wie eine Bedingung erfüllt
ist
int x = 0; Speicher Ausgabe
while (x < 3) { x = 2 1
x = x + 1;
System.out.println(x);
}
37
Schleifen (while)
▪ Schleifen wiederholen die Ausführung einer Anweisung/eines
Blocks von Anweisungen so lange, wie eine Bedingung erfüllt
ist
int x = 0; Speicher Ausgabe
while (x < 3) { x = 2 1
x = x + 1; 2
System.out.println(x);
}
38
Schleifen (while)
▪ Schleifen wiederholen die Ausführung einer Anweisung/eines
Blocks von Anweisungen so lange, wie eine Bedingung erfüllt
ist
int x = 0; Speicher Ausgabe
while (x < 3) { x = 2 1
x = x + 1; 2
System.out.println(x);
}
39
Schleifen (while)
▪ Schleifen wiederholen die Ausführung einer Anweisung/eines
Blocks von Anweisungen so lange, wie eine Bedingung erfüllt
ist
int x = 0; Speicher Ausgabe
while (x < 3) { x = 3 1
x = x + 1; 2
System.out.println(x);
}
40
Schleifen (while)
▪ Schleifen wiederholen die Ausführung einer Anweisung/eines
Blocks von Anweisungen so lange, wie eine Bedingung erfüllt
ist
int x = 0; Speicher Ausgabe
while (x < 3) { x = 3 1
x = x + 1; 2
System.out.println(x); 3
}
41
Schleifen (while)
▪ Schleifen wiederholen die Ausführung einer Anweisung/eines
Blocks von Anweisungen so lange, wie eine Bedingung erfüllt
ist
int x = 0; Speicher Ausgabe
while (x < 3) { x = 3 1
x = x + 1; 2
System.out.println(x); 3
}
42
Schleifen (while)
▪ Schleifen wiederholen die Ausführung einer Anweisung/eines
Blocks von Anweisungen so lange, wie eine Bedingung erfüllt
ist
int x = 0; Speicher Ausgabe
while (x < 3) { x = 3 1
x = x + 1; 2
System.out.println(x); 3
}
43
Schleifen (while) (2)
44
Grammatik: Schleifen
WhileStatement = "while" , "(" , BooleanValue ")" , Block ;
45
Beispiel: while-Schleife
public class Factorial {
public static void main(String[] args) {
int number = 5;
int result = 1;
While-Schleife while (number > 0) {
result = result * number;
number = number - 1;
}
System.out.println(result);
}
46
Beispielprogramm
public class Factorial {
public static void main(String[] args) {
int number = 5;
int result = 1;
while (number > 0) {
result = result * number;
number = number - 1;
}
System.out.println(result);
}
47
Lesbarkeit
Kommentare
▪ Kommentare sind Text im Programmcode, der nicht
interpretiert wird
▪ Sie erhöhen die Lesbarkeit des Codes, indem sie erklären
▪ welche Funktion ein Codeabschnitt erfüllt (was)
▪ wie ein Codeabschnitt funktioniert (wie)
▪ was für Bedingungen gelten müssen, damit ein Codeabschnitt wie
erwartet funktioniert (Vorbedingungen)
▪ was für Bedingungen nach der Ausführung eines Codeabschnitts
erfüllt sind (Nachbedingungen)
▪ Kommentare gehören zur guten Programmierpraxis
▪ Unterscheidung zwischen Zeilenkommentaren und
Mehrzeilenkommentaren
49
Beispiel: Kommentare
public static void main(String[] args) {
/*
* Calculate the factorial of a given number
* using an iterative approach. The given
* number must be greater than zero.
* The result will be printed to the console.
*/
int number = 5; // set the number to an arbitrary positive value
int result = 1; // initialize the result
while (number > 0) { // termination condition
result = result * number; // update result
// decrement number to work towards termination condition
number = number - 1;
}
System.out.println(result); // print result
}
50
Lesbarkeit: Code Conventions
▪ Eine Anweisung in einer Zeile
▪ Zeilenumbruch nach {, eigene Zeile für } if (x == 3) {
▪ Leerzeichen (_) …
▪ vor öffnenden und nach schließenden Klammern }
▪ um Operatoren (+, *, =, ==, >, …)
▪ Namen
▪ Keine Umlaute und andere Sonderzeichen (ö, ß, &, …)
▪ Klassen beginnen mit Großbuchstaben Factorial
▪ Variablen beginnen mit Kleinbuchstaben number
▪ CamelCase FactorialCalculator,
resultNumber
▪ aussagekräftige Namen tmp316, b, rnsTf
51
Typische Fehler
▪ Syntaxfehler
While (i = 8) while (i == 8) {
i + 1; i = i + 1;
} }
▪ Fehlende Initialisierung
int x; int x = 0; int x;
x = x + 1; x = x + 1; x = 0;
x = x + 1;
▪ Laufzeitfehler if (y != 0) {
int x = 3 / y;
int x = 3 / y; // y == 0 }
▪ Unendliche Schleifen
int x = 0; int x = 0; int x = 0; int x = 0;
int y = 0; while (x < 3) { int y = 0; while (x < 3) {
while (x < 3) { x = x - 1; while (x < 3) { x = x + 1;
y = y + 1; } x = x + 1; }
} } 52
Lernziele
▪ Eigenschaften, Terminologie und Arbeitsweise von Java
▪ Variablendeklaration, Wertzuweisung
▪ Blöcke
▪ Bedingungen (if)
▪ Schleifen (while)
▪ Kommentare
▪ Typische Fehler
53
Installation
Java installieren
1. Java OpenJDK herunterladen
▪ https://openjdk.java.net/
▪ direkter Download für JDK 23: https://jdk.java.net/23/
2. Datei in ein Zielverzeichnis entpacken
▪ Beispiel: "C:\Programme\Java" / "/usr/bin/java"
3. Erweitere die Pfad-Variable um das "bin"-Unterverzeichnis
▪ Beispiel: erweitere die Umgebungsvariable PATH um
"C:\Programme\Java\jdk-23\bin" / "/usr/bin/java/jdk-23/bin"
4. Setze die JAVA_HOME-Variable auf das JDK-Verzeichnis
▪ Beispiel: setze die Umgebungsvariable JAVA_HOME auf
"C:\Programme\Java\jdk-23" / "/usr/bin/java/jdk-23"
55
Eclipse installieren
1. Eclipse herunterladen
▪ https://www.eclipse.org/downloads/
2. Installer ausführen
▪ Eclipse IDE for Java Developers
3. Eclipse ausführen
4. Einen neuen Workspace anlegen
5. Ein neues Java-Projekt anlegen oder bestehende Projekte
importieren
56
Eclipse
Eclipse IDE
58
Neues Java-Projekt
59
Neues Java-Projekt (2)
60
Neue Java-Klasse
61
Neue Java-Klasse (2)
62
Neue Java-Klasse (3)
63
Java-Klasse ausführen
64
Java-Klasse ausführen (2)
65
