E3 – Grundlagen der Programmierung

A) Allgemeine Einordnung

Programmierung gehört in der Einführungsphase zu den zentralen Primärerfahrungen der Informatik. Lernende entwickeln dabei vor allem Modellierungs- und Problemlösekompetenz, indem sie schrittweise von einer Idee zu einer überprüfbaren Umsetzung gelangen.

Java wird als objektorientierte Sprache genutzt. In E3 stehen jedoch imperative Grundlagen innerhalb einer objektorientierten Sprache im Vordergrund: Datentypen, Ausdrücke, Kontrollstrukturen, Datenstrukturen und Methoden.

B) Inhalte des Themenfelds E.3

• Grundaufbau von Programmen, Syntax und elementare Anweisungen → Kapitel 1
• Variablen, Zuweisungen, elementare Datentypen, Typkonvertierungen, Scanner-Eingaben und EVA → Kapitel 2
• Operatoren, Vergleiche und logische Ausdrücke → Kapitel 3
• Kontrollstrukturen: bedingte Anweisungen, Verzweigungen und Struktogramm-Notation → Kapitel 4
• Schleifen als kontrollierte Wiederholung mit Bedingung, Zustandsänderung und Laufspur → Kapitel 5
• Datenstrukturen mit Arrays und Strings als Anwendungs- und Vertiefungsfeld für Kontrollstrukturen → Kapitel 6
• Methoden, Schnittstellen und wiederverwendbare Verarbeitung → Kapitel 7
• Einstieg in GUI und ereignisgesteuerte Anwendungen als ereignisgesteuertes EVA-System → Kapitel 8
• Modellierung und Implementierung einfacher Algorithmen, Ausführung und Diagnose → Kapitel 9

C) Bedeutung für diese Kursseite

E3 modelliert und implementiert bereits einfache, endliche Lösungsverfahren. Q1.2 grenzt davon konkrete Such- und Sortierverfahren, ihren Vergleich sowie Laufzeit und Effizienz ab; Q1.3 vertieft rekursive Problemstrukturen.

Quelle

Hessisches Ministerium für Kultus, Bildung und Chancen (2024): Kerncurriculum gymnasiale Oberstufe Informatik, Themenfeld E.3, S. 30–31.

1. Konzeptklärung: Programm, Quelltext und Syntax

2. Strukturelle Einordnung: Übersetzung und Laufzeit

Java-Programme durchlaufen zwei klar getrennte Schritte. Zunächst übersetzt der Compiler den Quelltext in Bytecode (.class), anschließend führt die Java Virtual Machine (JVM) diesen Bytecode aus. Die Trennung von Übersetzung und Ausführung macht nachvollziehbar, warum Übersetzungsfehler und Laufzeitfehler unterschiedliche Ursachen haben.

3. Formale Umsetzung: Klasse, main-Methode und Anweisung

Eine ausführbare Java-Anwendung besitzt mindestens eine Klasse mit einer main-Methode als Startpunkt. Die Anweisungen innerhalb von main werden in der notierten Reihenfolge ausgeführt. Jede einzelne Anweisung muss syntaktisch abgeschlossen werden; bei einfachen Java-Anweisungen übernimmt das Semikolon diese Rolle.

Im E3-Kontext dient die Klasse zunächst vor allem als notwendiger Java-Rahmen für ein lauffähiges Programm. Der systematische Objekt- und Klassenbegriff wird später in Q1.1 ausgearbeitet.

4. Beispiel: Minimales, vollständiges Java-Programm

public class HalloWelt {
    public static void main(String[] args) {
        System.out.println("Hallo Welt");
    }
}

Die äußeren geschweiften Klammern umschließen die Klasse. Die inneren geschweiften Klammern umschließen die main-Methode. Anweisungen innerhalb von main werden in der notierten Reihenfolge ausgeführt. System.out.println("Hallo Welt"); ist eine solche Anweisung; das Semikolon gehört zu ihr und markiert ihren Abschluss.

Hallo Welt

';' expected

Das Beispiel enthält genau eine Klasse, genau eine Startmethode und genau eine auszuführende Anweisung. Damit ist die grundlegende Programmstruktur vollständig sichtbar, ohne zusätzliche Sprachelemente vorwegzunehmen.

Dieses Minimalbeispiel zeigt nur die Ausgabe und den Java-Rahmen. Im nächsten Schritt werden zunächst feste Werte direkt zugewiesen; erst danach kommt Scanner als Eingabeschnittstelle hinzu.

5. Typische Fehlvorstellungen

Häufig wird angenommen, die Datei werde „Zeile für Zeile“ ohne Struktur ausgeführt. Tatsächlich startet die Ausführung an der main-Methode, nicht am Anfang der Datei.

Ebenfalls verbreitet ist die Gleichsetzung von Quelltext und lauffähigem Programm. Der Quelltext muss zuerst erfolgreich übersetzt werden; erst der erzeugte Bytecode ist ausführbar.

Für ein tragfähiges Grundverständnis ist die klare Unterscheidung der Ebenen entscheidend: Konzept (Programm als Anweisungsfolge), formale Syntax (Klasse, main-Methode, Klammern und Semikolon) und technischer Prozess (Compiler/JVM). Der Programmrahmen zeigt, wo ausführbare Anweisungen stehen. Im nächsten Schritt geht es darum, was solche Anweisungen mit Werten tun können: Werte speichern, ausgeben und später ersetzen.

Nach der Programmgrundstruktur rückt der Inhalt einzelner Anweisungen in den Mittelpunkt: Werte können gespeichert, ausgegeben und später durch neue Werte ersetzt werden.

1. Konzeptklärung: Variable als Speicherort

Eine Variable verbindet einen Bezeichner mit einem deklarierten Datentyp und einem aktuellen Wert beziehungsweise Zustand. Über ihren Bezeichner wird der aktuelle Wert im Quelltext gelesen oder verändert; der Datentyp begrenzt Wertebereich und zulässige Operationen.

Variablen machen Programmzustände sichtbar und veränderbar. Während ein Programm läuft, können Werte gespeichert, ausgegeben und später durch neue Werte ersetzt werden. Der Bezeichner und der Datentyp bleiben dabei gleich; der gespeicherte Wert kann sich ändern.

2. Deklaration, Initialisierung und Neuzuweisung

public class VariablenDemo {
    public static void main(String[] args) {
        int kontoStand;          // Deklaration
        kontoStand = 100;        // Initialisierung

        int alter = 16;          // Deklaration + Initialisierung

        System.out.println("Konto:");
        System.out.println(kontoStand);

        System.out.println("Alter:");
        System.out.println(alter);

        kontoStand = 250;        // Neuzuweisung

        System.out.println("Neuer Kontostand:");
        System.out.println(kontoStand);
    }
}

Zunächst werden Werte direkt im Programm zugewiesen, damit Speicherort, Datentyp und Wertänderung sichtbar werden. Feste Werte sind hier ein bewusst reduziertes Lernmodell: Sie machen sichtbar, welcher Wert gerade in einer Variable gespeichert ist und wie eine Zuweisung diesen Zustand verändert.

EVA als frühes Grundmodell: Eingabe, Verarbeitung, Ausgabe

Nach dieser Sicherung wird Scanner als Eingabeschnittstelle eingeführt. Werte kommen nun nicht mehr nur als feste Startwerte aus dem Quelltext, sondern von außen ins Programm. Sie werden gespeichert, verarbeitet und anschließend wieder sichtbar gemacht.

Datentypen werden dadurch funktional wichtig: Die Art der Eingabe entscheidet mit, welcher Datentyp passt. Ab den folgenden Aufgaben werden Eingaben aktiv über Scanner modelliert.

• Eingabe: Werte gelangen über eine Schnittstelle ins Programm, im Konsolenprogramm zum Beispiel über scanner.nextLine(), scanner.nextInt() oder scanner.nextDouble().
• Verarbeitung: Werte werden gespeichert, verändert, berechnet, verglichen oder später über Bedingungen zur Ablaufsteuerung genutzt.
• Ausgabe: Zustände, Ergebnisse oder Entscheidungen werden mit System.out.println(...) sichtbar gemacht.

Die Grundbewegung lautet deshalb: Eingabe → Speicherung → Verarbeitung → Ausgabe. Modellierung ist die Tätigkeit, mit der dieser Ablauf vor der Ausführung entworfen wird, kein zusätzlicher Laufzeitschritt in EVA.

Dieser Gedanke bereitet die spätere GUI-Programmierung vor: Dort liefern Komponenten Eingabezustände, ein Ereignis startet die Verarbeitung und Labels oder Felder zeigen die Ausgabe.

import java.util.Scanner;

public class BegruessungEVA {
    public static void main(String[] args) {
        Scanner scanner = new Scanner(System.in);

        System.out.print("Name: ");
        String name = scanner.nextLine();

        String begruessung = "Hallo, " + name;

        System.out.println(begruessung);
    }
}

• Eingabe: scanner.nextLine() liest den Namen.
• Verarbeitung: Aus dem Namen wird ein Begrüßungstext gebildet.
• Ausgabe: System.out.println(begruessung) zeigt das Ergebnis.

4. Datentypen als Modellierungsentscheidung

Nach Deklaration, Initialisierung und Neuzuweisung stellt sich die nächste Modellierungsfrage: Welche Art von Wert soll eine Variable speichern? Eine Anzahl ist etwas anderes als ein Messwert, ein Wahrheitswert, ein einzelnes Kennzeichen oder ein Text. Java verlangt deshalb, dass der Datentyp einer Variablen festgelegt wird.

Der Datentyp ist nicht nur eine Beschriftung. Er legt fest, welche Werte gespeichert werden dürfen, welche Operationen sinnvoll sind und welche Fehler der Compiler bereits vor der Ausführung erkennen kann. Für zählbare Werte eignet sich häufig int, für Messwerte mit Nachkommastellen double, für Ja/Nein-Informationen boolean und für einzelne Zeichen oder Kennzeichen char.

Texte werden in Java mit String gespeichert. String ist jedoch kein primitiver Datentyp, sondern ein Referenztyp. Für den Einstieg reicht zunächst: Texte können ausgegeben und gespeichert werden; die genauere Arbeit mit Strings folgt später im Datenstrukturkapitel.

import java.util.Scanner;

public class KontoDatentypenDemo {
    public static void main(String[] args) {
        Scanner scanner = new Scanner(System.in);

        System.out.print("Kontoinhaber: ");
        String inhaber = scanner.nextLine();

        System.out.print("Kontostand in Cent: ");
        int kontoStandCent = scanner.nextInt();

        System.out.print("Zinssatz in Prozent: ");
        double zinssatzProzent = scanner.nextDouble();

        boolean positivesGuthaben = kontoStandCent > 0;

        System.out.println("Konto:");
        System.out.println(inhaber);

        System.out.println("Kontostand in Cent:");
        System.out.println(kontoStandCent);

        System.out.println("Zinssatz:");
        System.out.println(zinssatzProzent);

        System.out.println("Positives Guthaben:");
        System.out.println(positivesGuthaben);
    }
}

Das Beispiel zeigt: Datentypen entstehen nicht zufällig, sondern aus der Bedeutung der Daten. Wer ein Konto modelliert, muss entscheiden, welche Informationen eingegeben, in Variablen gespeichert, durch Operatoren oder Vergleiche verarbeitet und über println ausgegeben werden.

3. Typkonvertierungen: numerisch umwandeln und Text parsen

Typkonvertierung behandelt Werte in verschiedenen numerischen Typen; beim Parsen wird eine Zeichenkette als Zahl gelesen. Beides ist in E3 wichtig, weil Eingaben häufig zunächst als Text vorliegen.

int summe = 17;
int anzahl = 2;
double durchschnitt = (double) summe / anzahl; // numerische Umwandlung: 8.5

String textEingabe = "12.5";
double messwert = Double.parseDouble(textEingabe); // Parsen: Text → Zahl

Das Casting (double) sorgt hier dafür, dass die Division einen double-Wert liefert. Double.parseDouble(...) erwartet dagegen einen Text, der als Zahl geschrieben ist; eine ungültige Eingabe ist ein späterer Diagnose- und Validierungsfall.

4. Primitive Datentypen und Objekte sauber unterscheiden

Primitive Typen speichern unmittelbare Einzelwerte (z. B. Zahl, Zeichen, Wahrheitswert). Bei Referenztypen verweist eine Variable dagegen auf ein Objekt, das intern mehrere Daten und ggf. Methodenbezug zusammenfasst.

int punkte = 42;                  // primitiver Wert liegt direkt vor
int[] messwerte = {3, 5, 8};      // Variable speichert Referenz auf ein Array-Objekt
String name = "Lea";              // Referenz auf ein String-Objekt

Diese Unterscheidung ist für spätere Kapitel zentral: Arrays und andere Datenstrukturen arbeiten mit Referenzen auf Objekte, während numerische Berechnungen häufig auf primitiven Typen stattfinden.

int anzahl = 7;
double alsDouble = anzahl; // int -> double
float alsFloat = anzahl;   // int -> float

byte a = 10;
short b = 20;
int summe = a + b; // byte/short werden in Ausdrücken zu int

double preis = 19.99;
int euro = (int) preis;   // 19, Nachkommastellen fallen weg

long gross = 4_000_000_000L;
int klein = (int) gross;  // Überlauf möglich

float note = 2.7f;
int ganzzahl = (int) note; // 2

5. Typische Fehlvorstellungen

Der Operator = wird oft als mathematische Gleichheit interpretiert. In Java bedeutet er Zuweisung: Der rechte Ausdruck wird ausgewertet und sein Ergebnis links gespeichert.

• Ein Datentyp ist keine Dekoration: Er legt zulässige Werte, sinnvolle Operationen und mögliche Compilerfehler mit fest.
• int ist für Zählwerte geeignet, aber nicht automatisch für Messwerte mit Nachkommastellen.
• Geldbeträge können bewusst als Centwerte mit int modelliert werden, um Nachkommastellenprobleme zu vermeiden.
• String ist Text, aber kein primitiver Datentyp.
• Typumwandlung löst nicht jedes Modellierungsproblem; besser ist oft, den passenden Datentyp von Anfang an zu wählen.

Damit wird der nächste Schritt vorbereitet: Operatoren verarbeiten typisierte Werte. Ob eine Operation sinnvoll ist und welches Ergebnis entsteht, hängt vom Datentyp der beteiligten Werte ab.

1. Konzeptklärung: Ausdruck als auswertbare Struktur

Variablen und Datentypen liefern die Wertebasis. Operatoren verarbeiten diese Werte: arithmetische Operatoren berechnen neue Zahlenwerte, Vergleichsoperatoren prüfen Beziehungen zwischen Werten, und logische Operatoren verbinden oder negieren Wahrheitswerte.

Im EVA-Modell gehören Operatoren zur Verarbeitungsschicht. Sie verarbeiten Werte, die zuvor eingelesen oder in Variablen gespeichert wurden. Feste Beispielwerte dienen in diesem Kapitel vor allem der nachvollziehbaren Auswertungsspur.

Für Java ist die genaue Schreibweise entscheidend. Einige Zeichen sehen ähnlich aus wie in der Mathematik, haben aber im Programm eine genau festgelegte Rolle: = weist einen Wert zu, == vergleicht zwei Werte.

Ein Ausdruck kombiniert Werte, Variablen, Konstanten und Operatoren zu einer auswertbaren Einheit. Das Ergebnis eines Ausdrucks hat einen Datentyp, zum Beispiel numerisch oder boolesch. Operatoren sind damit nicht nur Rechenzeichen, sondern zentrale Bausteine zur Formulierung von Berechnungen und Vergleichen.

2. Rechnen mit Zahlen und Rechnen mit Variablen

Beim Rechnen mit Zahlen stehen die Werte direkt im Ausdruck: 8 + 3 kann sofort zu 11 ausgewertet werden. Solche direkt notierten Werte nennt man Literalwerte.

Beim Rechnen mit Variablen stehen im Ausdruck dagegen Namen von Speicherorten: In a + b rechnet Java nicht mit den Buchstaben a und b, sondern liest zuerst die aktuell gespeicherten Werte dieser Variablen. Erst danach wird der Ausdruck ausgewertet.

Eine Zuweisung speichert immer das Ergebnis der aktuellen Auswertung. int summe = a + b; speichert also nicht dauerhaft die Formel a + b, sondern den Wert, der in diesem Moment aus den aktuellen Variablenwerten entsteht.

public class RechnenMitVariablen {
    public static void main(String[] args) {
        int a = 8;
        int b = 3;

        int summeMitZahlen = 8 + 3;
        int summeMitVariablen = a + b;

        a = 10;

        int neueSumme = a + b;

        System.out.println(summeMitZahlen);
        System.out.println(summeMitVariablen);
        System.out.println(neueSumme);
    }
}

Erst wenn klar ist, welche Werte in einem Ausdruck gelesen werden, wird die genaue Operatoren-Notation wichtig.

2. Kanonisches Beispiel: Ausdrücke auswerten

public class OperatorenDemo {
    public static void main(String[] args) {
        int a = 8;
        int b = 3;

        int ohneKlammern = a + b * 2;
        int mitKlammern = (a + b) * 2;
        int ganzzahlQuotient = a / b;
        int rest = a % b;

        boolean groesserAlsZehn = ohneKlammern > 10;
        boolean gleich = a == b;
        boolean ungleich = a != b;
        boolean beidePositiv = a > 0 && b > 0;
        boolean mindestensEinWertGross = a > 10 || b > 10;
        boolean nichtGleich = !(a == b);

        System.out.println(ohneKlammern);
        System.out.println(mitKlammern);
        System.out.println(ganzzahlQuotient);
        System.out.println(rest);
        System.out.println(groesserAlsZehn);
        System.out.println(gleich);
        System.out.println(ungleich);
        System.out.println(beidePositiv);
        System.out.println(mindestensEinWertGross);
        System.out.println(nichtGleich);
    }
}

Die festen Werte dienen hier als Beispiel-Eingaben für die Laufspur. In einem interaktiven Konsolenprogramm würden sie mit Scanner eingelesen.

import java.util.Scanner;

public class PunktebilanzMitScanner {
    public static void main(String[] args) {
        Scanner scanner = new Scanner(System.in);

        System.out.print("Basispunkte: ");
        int basisPunkte = scanner.nextInt();

        System.out.print("Bonuspunkte: ");
        int bonusPunkte = scanner.nextInt();

        System.out.print("Mindestpunkte: ");
        int mindestPunkte = scanner.nextInt();

        int gesamtPunkte = basisPunkte + bonusPunkte;
        int differenzZumZiel = mindestPunkte - gesamtPunkte;

        boolean zielErreicht = gesamtPunkte >= mindestPunkte;

        System.out.println("Gesamtpunkte:");
        System.out.println(gesamtPunkte);

        System.out.println("Differenz zum Ziel:");
        System.out.println(differenzZumZiel);

        System.out.println("Ziel erreicht:");
        System.out.println(zielErreicht);
    }
}

Bei einer Zuweisung wird zuerst der Ausdruck rechts vom Zuweisungsoperator = ausgewertet. Erst danach wird das Ergebnis in der linken Variable gespeichert. Deshalb prüft = in Java keine Gleichheit; der Gleichheitsvergleich wird mit == geschrieben.

Arithmetische Ausdrücke folgen Auswertungsregeln: Multiplikation und Division werden vor Addition und Subtraktion ausgewertet. Klammern können diese Reihenfolge verändern. Vergleichsausdrücke berechnen dagegen keine Zahl, sondern prüfen eine Aussage und liefern true oder false.

Wichtig ist die Trennung von Java-Notation und mathematischer Bedeutung: = weist einen Wert zu, == prüft Gleichheit, != prüft Ungleichheit, <= bedeutet kleiner oder gleich und >= bedeutet größer oder gleich. Bei int / int entsteht eine ganzzahlige Division; % liefert den Rest dieser Division.

3. Auswertungsspur: Rechen-, Vergleichs- und Logikergebnisse

Die Auswertungsspur macht sichtbar, dass Ausdrücke nicht auf einmal magisch entstehen. Java wertet Teilausdrücke nach festen Regeln aus. Das Ergebnis eines arithmetischen Ausdrucks kann wieder gespeichert werden; das Ergebnis eines Vergleichsausdrucks ist ein Wahrheitswert.

14
22
2
2
true
false
true
true
false
true

public class KurzschreibweiseDemo {
    public static void main(String[] args) {
        int punktzahl = 10;

        punktzahl += 5;  // entspricht: punktzahl = punktzahl + 5;
        punktzahl *= 2;  // entspricht: punktzahl = punktzahl * 2;
        punktzahl -= 4;  // entspricht: punktzahl = punktzahl - 4;
        punktzahl /= 2;  // entspricht: punktzahl = punktzahl / 2;
        punktzahl %= 5;  // entspricht: punktzahl = punktzahl % 5;

        System.out.println(punktzahl);
    }
}

Numerische Ausdrücke können in Zahlenvariablen gespeichert werden; Vergleichs- und logische Ausdrücke liefern Wahrheitswerte und bilden so den direkten Übergang zu Bedingungen.

a + b * 2, (a + b) * 2, a / b und a % b liefern numerische Werte. Die Ergebnisse können in Variablen vom Typ int gespeichert oder direkt ausgegeben werden. ohneKlammern > 10, a == b und a != b liefern dagegen Wahrheitswerte. Die ergänzenden Vergleichsausdrücke a <= b und a >= b zeigen dieselbe Ergebnisklasse.

Übergang zu Bedingungen: Ein Vergleich oder eine logische Verknüpfung liefert true oder false. Kontrollstrukturen verwenden diesen Wahrheitswert im nächsten Kapitel zur Ablaufsteuerung.

1. Bedingungen auswerten

Eine Bedingung ist ein Ausdruck, dessen Ergebnis true oder false ist. Solche Ausdrücke sind aus dem Operatorenkapitel bekannt: Sie lesen aktuelle Werte, vergleichen sie und liefern einen Wahrheitswert.

Der Wahrheitswert ist zunächst nur ein Ergebnis der Verarbeitung. Erst eine bedingte Anweisung nutzt dieses Ergebnis zur Ablaufsteuerung: Bei true kann ein bedingter Block ausgeführt werden, bei false wird er übersprungen.

2. Bedingte Anweisung mit if

Die einfachste Form ist eine einseitige bedingte Anweisung. Ein optional ausgeführter Block läuft nur dann, wenn die Bedingung true ergibt. Bei false wird dieser Block übersprungen, und die Fortsetzung läuft hinter dem if-Block weiter.

public class AkkuWarnungDemo {
    public static void main(String[] args) {
        int akkuProzent = 17;
        boolean akkuNiedrig = akkuProzent < 20;

        if (akkuNiedrig) {
            System.out.println("Akku bald laden.");
        }

        System.out.println("Statusprüfung beendet.");
    }
}

akkuProzent repräsentiert einen aktuellen Zustand. akkuNiedrig ist das Ergebnis der Verarbeitung: Der Vergleichsausdruck akkuProzent < 20 liefert einen Wahrheitswert. Die bedingte Anweisung nutzt diesen Wahrheitswert zur Ablaufsteuerung.

• Der if-Block ist eine bedingte Ausgabe.
• Bei true wird der Warnhinweis ausgegeben.
• Bei false wird diese Ausgabe übersprungen.
• Die Abschlussausgabe läuft unabhängig von der Bedingung.

Eingabe/Zustand: akkuProzent = 17
Verarbeitung: akkuProzent < 20 wird zu true ausgewertet
Bedingte Ausgabe: Warnhinweis wird nur bei true ausgegeben
Fortsetzung: Statusprüfung beendet läuft immer

Die bedingte Anweisung verbindet einen aktuellen Zustand mit einer zustandsabhängigen Reaktion.

• Die Bedingung steht in runden Klammern.
• Der bedingte Block steht in geschweiften Klammern.
• Bei false wird der Block übersprungen.
• Danach läuft das Programm weiter.
• Das ist noch keine zweiseitige Verzweigung.

3. Verzweigung mit if-else

Eine Verzweigung ergänzt zur Bedingung eine Alternative. Dadurch wird nicht nur entschieden, ob ein Block ausgeführt wird, sondern welcher von zwei Blöcken ausgeführt wird.

public class VerzweigungDemo {
    public static void main(String[] args) {
        int punkte = 42;

        if (punkte >= 50) {
            System.out.println("Bestanden.");
        } else {
            System.out.println("Nicht bestanden.");
        }

        System.out.println("Pruefung beendet.");
    }
}

Eine Verzweigung mit if-else beschreibt zwei alternative Pfade. Ist die Bedingung true, wird der if-Block ausgeführt. Ist die Bedingung false, wird der else-Block ausgeführt. Bei if-else wird genau einer der beiden Blöcke ausgeführt.

public class GeraeteStatusDemo {
    public static void main(String[] args) {
        boolean geraetAktiv = true;
        int akkuProzent = 12;

        if (geraetAktiv) {
            System.out.println("Gerät ist aktiv.");

            if (akkuProzent < 20) {
                System.out.println("Akku bald laden.");
            } else {
                System.out.println("Akkustand ausreichend.");
            }
        } else {
            System.out.println("Gerät ist nicht aktiv.");
        }

        System.out.println("Statusprüfung beendet.");
    }
}

if (geraetAktiv) {
    System.out.println("Gerät ist aktiv.");
}

if (akkuProzent < 20) {
    System.out.println("Akku bald laden.");
}

if (geraetAktiv) {
    System.out.println("Gerät ist aktiv.");

    if (akkuProzent < 20) {
        System.out.println("Akku bald laden.");
    }
}

4. Laufspur: Bedingung, Zweig und Fortsetzung

Die Laufspur zeigt, wie Java das if-else-Beispiel Schritt für Schritt auswertet. Im Beispiel ist punkte gleich 42.

Die Laufspur zeigt: Eine Verzweigung unterbricht den Ablauf nicht dauerhaft. Sie wählt genau einen passenden Block aus. Danach läuft das Programm hinter der Verzweigung weiter.

5. Struktogramme: sprachunabhängige Ablaufstruktur

Ein Struktogramm stellt einen Algorithmus unabhängig von einer konkreten Programmiersprache durch Strukturblöcke für Sequenz, Auswahl, Wiederholung und Block- beziehungsweise Methodenaufruf dar.

Die Ablaufstruktur ist also sprachunabhängig. Java-nahe Variablendeklarationen in den E3-Struktogrammen dienen nur als Brücke zwischen Code und Modell; sie sind kein notwendiger Bestandteil der allgemeinen Struktogrammnotation.

Die sichtbaren Beispiele behalten einzelne Java-nahe Beschriftungen, damit sich die gewohnte Schreibweise gezielt auf die Modellstruktur beziehen lässt.

Beide Struktogramme zeigen dieselbe Grundidee: Zuerst entsteht ein Programmzustand durch eine Variablenfestlegung. Danach wird eine Bedingung mit diesem aktuellen Wert ausgewertet. Erst aus dieser Auswertung ergibt sich, ob ein Block übersprungen wird oder welcher Zweig ausgeführt wird.

Damit wird sichtbar, dass die Bedingung nicht isoliert funktioniert. Sie bezieht sich auf zuvor gespeicherte Werte und steuert auf dieser Grundlage den weiteren Ablauf.

switch (note) {
    case 1: text = "sehr gut"; break;
    case 2: text = "gut"; break;
    default: text = "weitere";
}

Bedingte Anweisungen und Verzweigungen steuern, welcher Block ausgeführt wird. Schleifen nutzen Bedingungen anders: Sie entscheiden, ob ein Block erneut ausgeführt wird. Deshalb werden Schleifen im nächsten Abschnitt als eigene Form von Kontrollstruktur betrachtet; im GUI-Kapitel werden dieselben Bedingungen nach einem Ereignis zur zustandsabhängigen Reaktion genutzt.

Schleifen bauen auf Bedingungen auf. Der Unterschied zur Verzweigung liegt darin, dass der Schleifenkörper nach einer Ausführung erneut zur Bedingung zurückkehrt.

Zur Analyse einer terminierenden Schleife werden Startzustand, Fortsetzungsbedingung, Schleifenkörper und zustandsverändernder Schritt untersucht. Eine Schleife gehört zu einem Algorithmus, wenn Wiederholung und Abbruch eindeutig beschrieben sind; unbeabsichtigtes Nichtterminieren verletzt die erwartete Endlichkeit.

While-Schleife

Die while-Schleife ist eine Bedingungsschleife. Sie arbeitet ähnlich wie eine bedingte Anweisung mit einer Bedingung, nutzt diese Bedingung aber anders: Bei if wird ein Block einmalig ausgeführt oder übersprungen. Bei while wird die Bedingung wiederholt geprüft.

Die Bedingung im Schleifenkopf ist deshalb eine Fortsetzungsbedingung. Solange diese Bedingung true ergibt, kann der Schleifenkörper ausgeführt werden. Nach jedem Durchlauf springt der Ablauf zurück zur Bedingung. Erst wenn die Bedingung false ergibt, wird die Schleife verlassen.

Wichtig ist dabei die Erreichbarkeit des Abbruchs. Der Zustand, der in der Schleifenbedingung geprüft wird, muss sich im Ablauf verändern können. Wenn die Bedingung dauerhaft true bleibt und kein anderer Abbruch vorgesehen ist, entsteht eine Endlosschleife. Eine Endlosschleife kann bewusst gewünscht sein, etwa wenn ein späterer Abbruch über break geplant ist. Sie darf aber nicht unbemerkt entstehen.

Grundstruktur: Startzustand, Fortsetzungsbedingung, Körper und Schritt

Das erste Beispiel zeigt die elementare Struktur einer while-Schleife an einem einfachen Ladefortschritt. Der Kontext ist bewusst klein gehalten: Ein Startwert wird gesetzt, die Bedingung wird vor jedem Durchlauf geprüft, der Schleifenkörper gibt den aktuellen Zustand aus und verändert anschließend den geprüften Wert.

int ladeProzent = 0; // Startzustand: Die Variable steuert die Schleife.

// Schleifenkopf: while + Fortsetzungsbedingung
// Der Schleifenkörper wird ausgeführt, solange ladeProzent < 100 true ist.
while (ladeProzent < 100) {
    // Schleifenkörper:
    System.out.println("Ladestand: " + ladeProzent + "%");

    // Zustandsänderung:
    // Der geprüfte Wert verändert sich, damit die Schleife enden kann.
    ladeProzent = ladeProzent + 25;
}

// Anweisung nach der Schleife:
// Sie wird erst ausgeführt, wenn die Bedingung false ist.
System.out.println("Ladevorgang vollständig.");

Die Schleife läuft nicht, weil Java „weiß“, wie oft wiederholt werden soll. Sie läuft, weil die Bedingung vor jedem Durchlauf erneut ausgewertet wird. Erst die Zustandsänderung im Schleifenkörper sorgt dafür, dass die Bedingung später false werden kann.

Leselogik: Das Struktogramm zeigt zuerst den Startzustand int ladeProzent = 0. Danach wird die Bedingung ladeProzent < 100 vor jedem möglichen Durchlauf geprüft. Ist sie wahr, werden die Ausgabe und die Zustandsänderung im Schleifenkörper ausgeführt. Danach führt der Ablauf zurück zur Bedingung. Ist sie falsch, wird die Schleife verlassen und die Anweisung nach der Schleife ausgeführt.

Ladestand: 0%
Ladestand: 25%
Ladestand: 50%
Ladestand: 75%
Ladevorgang vollständig.

int temperatur = 18; // Startwert
int anstieg = 4;     // Veränderung pro Durchlauf
int stunde = 1;      // Zähler für die Durchläufe

while (stunde <= 4) {
    System.out.println("Stunde: " + stunde);
    System.out.println("Temperatur: " + temperatur);

    // Bedingte Anweisung im Schleifenkörper:
    // Pro Durchlauf wird zusätzlich entschieden, welche Ausgabe passt.
    if (temperatur >= 26) {
        System.out.println("Kühlung prüfen.");
    } else {
        System.out.println("Temperatur im normalen Bereich.");
    }

    // Zustandsänderungen:
    temperatur = temperatur + anstieg;
    stunde = stunde + 1;
}

System.out.println("Messung beendet.");

Scanner sc = new Scanner(System.in);

int paketGroesse = sc.nextInt();

while (paketGroesse != 0) {
    if (paketGroesse < 0) {
        System.out.println("Fehler: negative Paketgröße.");
        break;
    }

    System.out.println("Paket verarbeitet: " + paketGroesse);
    paketGroesse = sc.nextInt();
}

System.out.println("Import beendet.");

import java.util.Random;

Random zufall = new Random();

int wuerfel = zufall.nextInt(6) + 1;     // 1 bis 6
int prozent = zufall.nextInt(101);       // 0 bis 100
int beliebigeZahl = zufall.nextInt();    // beliebiger int-Wert
double anteil = zufall.nextDouble();     // 0.0 bis kleiner als 1.0

System.out.println("Würfel: " + wuerfel);
System.out.println("Prozent: " + prozent);
System.out.println("Anteil: " + anteil);

import java.util.Random;

Random zufall = new Random();

int minute = 1;

while (minute <= 3) {
    int messwert = zufall.nextInt(5) + 20; // 20 bis 24
    System.out.println("Minute " + minute + ": " + messwert);

    minute = minute + 1;
}

For-Schleife

Die for-Schleife ist die typische Zählschleife. Sie eignet sich besonders dann, wenn ein Programm einen Bereich systematisch durchlaufen soll: eine bekannte Anzahl von Etiketten, feste Kontrollzeitpunkte, Countdown-Werte, Teststufen oder Plätze in einem Saal. Im Unterschied zur while-Schleife werden Startwert, Fortsetzungsbedingung und Veränderung der Zählvariable direkt im Schleifenkopf gebündelt.

Der Schleifenkopf besitzt drei Teile. Die Initialisierung legt den Startzustand der Zählvariable fest. Die Fortsetzungsbedingung wird vor jedem möglichen Durchlauf geprüft. Das Inkrement oder Dekrement verändert die Zählvariable nach jedem Durchlauf. Der Schleifenkörper enthält die Anweisungen, die pro gezähltem Schritt ausgeführt werden.

Der Ablauf ist deshalb immer gleich: Initialisierung ausführen → Bedingung prüfen → Schleifenkörper ausführen → Zählvariable verändern → erneut prüfen. Wird die Bedingung false, läuft das Programm hinter der for-Schleife weiter.

Grundstruktur: Zählvariable und Inkrement

Das erste Beispiel modelliert einen kleinen Paketversand: Für eine bekannte Anzahl von Etiketten soll jeweils eine Druckausgabe erzeugt werden. Die Zählvariable i steht dabei für das gerade bearbeitete Etikett.

int anzahlEtiketten = 5;

for (int i = 1; i <= anzahlEtiketten; i++) {
    System.out.println("Etikett " + i + " drucken.");
}

System.out.println("Alle Etiketten wurden gedruckt.");

Die Schleife zählt von 1 bis 5. In jedem Durchlauf wird die aktuelle Nummer ausgegeben. Nach dem Schleifenkörper erhöht i++ die Zählvariable um 1. Danach prüft Java wieder, ob i <= anzahlEtiketten noch gilt.

Etikett 1 drucken.
Etikett 2 drucken.
Etikett 3 drucken.
Etikett 4 drucken.
Etikett 5 drucken.
Alle Etiketten wurden gedruckt.

int startGroesse = 10;
int maxGroesse = 50;
int schritt = 10;

for (int paketGroesse = startGroesse; paketGroesse <= maxGroesse; paketGroesse += schritt) {
    System.out.println("Teste Paketgroesse: " + paketGroesse + " MB");
}

System.out.println("Lineare Paketgroessenpruefung beendet.");

int maxVersuche = 3;

for (int versuch = maxVersuche; versuch >= 1; versuch--) {
    System.out.println("Verbleibende Versuche: " + versuch);
}

System.out.println("Versuchszaehlung beendet.");

for (int datenrate = 1; datenrate <= 32; datenrate *= 2) {
    System.out.println("Teste Datenrate: " + datenrate + " Mbit/s");
}

System.out.println("Datenratentest beendet.");

for (int wartezeit = 32; wartezeit >= 1; wartezeit /= 2) {
    System.out.println("Wartezeit: " + wartezeit + " Sekunden");
}

System.out.println("Wartezeittest beendet.");

int reihen = 3;
int plaetzeProReihe = 4;

for (int reihe = 1; reihe <= reihen; reihe++) {
    System.out.println("Reihe " + reihe + " pruefen.");

    for (int platz = 1; platz <= plaetzeProReihe; platz++) {
        System.out.println("  Platz " + platz + " pruefen.");
    }

    System.out.println("Reihe " + reihe + " abgeschlossen.");
}

System.out.println("Saalpruefung beendet.");

int versuche = 0;
do {
    versuche++;
} while (versuche < 1);

Schleifen auswählen

0. Einstieg: Von Wiederholung zu strukturierter Datenarbeit

Bisher wurden einzelne Werte gespeichert, berechnet, verglichen und mit Kontrollstrukturen verarbeitet. Einzelne Variablen reichen aus, wenn ein Programm nur einen einzelnen Wert benötigt. Viele Aufgaben arbeiten aber mit mehreren zusammengehörigen Werten: Messwerte einer Wetterstation, Akkustände, Kontrollzeiten oder die Zeichen eines Textes. Mit Datenstrukturen werden aus Einzelwerten geordnete Sammlungen.

Der Index verbindet Datenstruktur und Schleife. Eine Schleife besucht systematisch alle gültigen Positionen. Bedingungen prüfen die besuchten Werte, Zähler erfassen passende Fälle und Akkumulatoren fassen Werte über mehrere Durchläufe zusammen. Dadurch werden Schleifen zum Bearbeitungswerkzeug für strukturierte Daten.

A. Arrays

A1. Arrays: Syntax, Regeln und Fachbegriffe

Ein Array speichert mehrere Werte gleichen Typs unter einem Namen. Die Array-Variable verweist auf diese Sammlung. Ein Array-Element ist ein einzelner Wert an einer bestimmten Position. Die Länge eines Arrays wird bei der Erzeugung festgelegt und bleibt danach unverändert.

Indizes beginnen bei 0. Der letzte gültige Index ist deshalb array.length - 1. array.length ist ein Attribut, keine Methode. Ein neues int[], das ohne Startwerte erzeugt wird, enthält zunächst Standardwerte: bei int also 0.

int[] festeMesswerte = {18, 21, 19, 24}; // Startwerte

int anzahlMessungen = 4;
int[] messwerte = new int[anzahlMessungen];  // Länge festlegen

int ersterMesswert = festeMesswerte[0];      // Element lesen
festeMesswerte[0] = 20;                      // Element verändern

A2. Arrays mit Schleifen bearbeiten

Arrays machen die For-Schleife besonders nützlich: Die Schleife zählt gültige Indizes, und der Arrayzugriff liest oder verändert den Wert an der jeweiligen Position.

int[] messwerte = {18, 21, 19, 24};

for (int i = 0; i < messwerte.length; i++) {
    System.out.println("Messwert: " + messwerte[i]);
}

i ist der Index, nicht der Messwert. messwerte[i] liest den Wert an Position i. i = 0 startet beim ersten gültigen Index, i < messwerte.length endet vor dem ersten ungültigen Index, und i++ geht zur nächsten Position. So besucht die Schleife jeden gültigen Index genau einmal.

for (int i = 0; i < messwerte.length; i++) {
    System.out.println(messwerte[i]);
}

for (int i = 0; i < messwerte.length; i++) {
    messwerte[i] = sc.nextInt();
}

int summe = 0;
for (int i = 0; i < messwerte.length; i++) {
    summe += messwerte[i];
}
double durchschnitt = summe / (double) messwerte.length;

int niedrigsterWert = messwerte[0];
for (int i = 1; i < messwerte.length; i++) {
    if (messwerte[i] < niedrigsterWert) {
        niedrigsterWert = messwerte[i];
    }
}

int kritischeWerte = 0;
for (int i = 0; i < messwerte.length; i++) {
    if (messwerte[i] >= 30) {
        kritischeWerte++;
    }
}

int i = 0;
while (i < messwerte.length) {
    int messwert = sc.nextInt();

    if (messwert < -50 || messwert > 60) {
        System.out.println("Ungültiger Messwert");
    } else {
        messwerte[i] = messwert;
        i++;
    }
}

B. Strings

B1. Strings: Syntax, Regeln und Fachbegriffe

String ist als Textwert aus früheren Kapiteln bekannt. Neu ist die Strukturperspektive: Ein String ist eine geordnete Zeichenfolge. Jedes Zeichen hat eine Position, und auch hier beginnen die Indizes bei 0. text.length() liefert die Anzahl der Zeichen; der letzte gültige Index ist text.length() - 1. Einzelne Zeichen werden mit text.charAt(i) gelesen.

Strings sind Objekte und Referenztypen. Außerdem sind sie unveränderlich: Methoden liefern neue Strings, sie verändern den ursprünglichen String nicht automatisch.

String kurs = "Informatik";

int laenge = kurs.length();
char erstesZeichen = kurs.charAt(0);
char fuenftesZeichen = kurs.charAt(4);

String dateiname = "messwerte.csv";

int punkt = dateiname.indexOf(".");
String name = dateiname.substring(0, punkt);
String endung = dateiname.substring(punkt + 1);

String endungGross = endung.toUpperCase();

System.out.println("Name: " + name);
System.out.println("Endung: " + endungGross);

String eingabe = " Start Messung ";
										String kommando = eingabe.trim().toLowerCase().replace(" ", "_");

System.out.println("Kommando: " + kommando);

if (kommando.length() >= 5) {
    System.out.println("Länge ok");
} else {
    System.out.println("Länge zu kurz");
}

if (kommando.contains(".")) {
    System.out.println("Punkt gefunden");
} else {
    System.out.println("Kein Punkt enthalten");
}

String kommando = "START";
kommando.toLowerCase();              // Ergebnis wird verworfen
kommando = kommando.toLowerCase();   // Ergebnis wird gespeichert

int punkt = dateiname.indexOf(".");

if (punkt == -1) {
    System.out.println("Punkt fehlt");
} else {
    System.out.println("Punkt gefunden");
}

C. Arrays und Strings vergleichen

Arrays und Strings sind keine identischen Strukturen, aber sie teilen die Idee geordneter Positionen. Der Indexzugriff ist jeweils die Brücke zur Verarbeitung mit Schleifen.

D. Übergang zu Methoden und Q1.2

Daten werden eingegeben oder bereitgestellt, in Arrays oder Strings strukturiert und anschließend mit Schleifen, Bedingungen, Zählern und Akkumulatoren verarbeitet. Das EVA-Modell ordnet diesen Ablauf als Eingabe, Verarbeitung und Ausgabe. Methoden kapseln wiederkehrende Verarbeitung, damit Programme lesbarer und gezielter prüfbar werden. Die Aufgaben übertragen diese Muster anschließend auf konkrete Anwendungskontexte.

Für den Blick nach vorne bleiben die Qualifikationsphasen ein Ausblick: Objektstrukturen in Q1.1, algorithmische Verfahren wie Suchen und Sortieren in Q1.2, vertiefte Datenstrukturen in Q1.4 und Datenmodelle in Q2.1. Der direkte E3-Anschluss liegt jetzt bei Methoden: Wiederkehrende Verarbeitung von Einzelwerten, Arrays und Strings wird benannt, gekapselt und wiederverwendbar gemacht.

Bisher wurden Werte gespeichert, Ausdrücke ausgewertet, Bedingungen geprüft, Schleifen formuliert und Arrays oder Strings durchlaufen. Dadurch entstehen Programme, die fachlich schon viel leisten, aber schnell unübersichtlich werden. Methoden lösen dieses Strukturproblem: Eine wiederkehrende oder fachlich abgeschlossene Verarbeitung erhält einen Namen, eine Schnittstelle und einen eigenen Rumpf.

Warum jetzt Methoden?

Nach Datenstrukturen wird besonders sichtbar, dass dieselben Grundmuster immer wiederkehren: Werte werden berechnet, geprüft, gezählt, gesucht, umgeformt oder ausgegeben. Methoden stehen deshalb nicht neben den bisherigen Konzepten, sondern bündeln sie zu benannten Verarbeitungsroutinen. Die Übersicht wird im ausklappbaren Abschnitt zu Methodenarten an Beispielen konkretisiert.

1. Methode als benannte Teilaufgabe

Eine Methode ist eine benannte, abgegrenzte Verarbeitungsroutine innerhalb einer Klasse. Sie wird nicht automatisch ausgeführt, sondern erst durch einen Methodenaufruf gestartet. Der volle objektorientierte Methodenbegriff als Verhalten von Objekten wird in Q1.1 systematisch entwickelt.

Eine Methode ist nicht automatisch ein Algorithmus. Sie kann einen Algorithmus, einen Teilschritt, eine Prüfung, eine Transformation oder eine reine Aktion implementieren.

• Der Methodenkopf beschreibt die Schnittstelle nach außen.
• Der Methodenrumpf enthält die eigentliche Verarbeitung.
• main ist auch eine Methode, aber eine besondere Startmethode.
• Eigene Methoden stehen innerhalb der Klasse, aber außerhalb von main.

2. Allgemeine Syntax: Methodenkopf, Parameterliste und Methodenrumpf

Eine Methodendeklaration besteht aus Methodenkopf, Parameterliste und Methodenrumpf. Das folgende Beispiel bleibt bewusst neutral:

public static int berechneDifferenz(int startwert, int endwert) {
    int differenz = endwert - startwert;
    return differenz;
}

public static ist hier eine E3-Arbeitskonvention: Die Methode gehört zur Klasse und kann aus main direkt aufgerufen werden. Eine ausführliche Objektorientierungsdeutung folgt später in Q1.1.

3. Methodenaufruf, Argumente und Parameterbindung

Die Methodendeklaration legt fest, welche Eingabewerte erwartet werden. Der Methodenaufruf liefert konkrete Argumentwerte; sie werden beim Start der Methode den Parametern zugeordnet. Parameter sind lokale Variablen der Methode.

int wert = berechneDifferenz(12, 20);

Deutung: Argumente stehen beim Aufruf, Parameter stehen in der Methodendeklaration. Parameter sind lokale Variablen der Methode. Ein Rückgabewert muss an der Aufrufstelle genutzt oder gespeichert werden, wenn man ihn weiterverwenden möchte.

4. Rückgabetyp, Rückgabe und Rückgabewert unterscheiden

Der Rückgabetyp steht im Methodenkopf und legt fest, welche Art von Ergebnis die Methode liefern muss. Die Rückgabeanweisung return ...; beendet die Methode und sendet einen Wert an die Aufrufstelle zurück. Der Rückgabewert ist der konkrete Wert, der bei einem bestimmten Methodenaufruf entsteht.

public static int berechneAenderung(int startwert, int endwert) {
    return endwert - startwert;
}

Eine Methode mit Rückgabetyp muss auf jedem relevanten Ausführungspfad einen passenden Wert zurückgeben. Eine void-Methode hat keinen Rückgabewert.

public static void zeigeStartHinweis() {
    System.out.println("Messsystem wird gestartet.");
}

public static int berechneRestAkku(int startAkku, int verbrauch) {
    return startAkku - verbrauch;
}

public static boolean istAkkuKritisch(int akkuProzent) {
    return akkuProzent <= 20;
}

public static String normalisiereSensorcode(String code) {
    return code.toUpperCase().replace(" ", "-");
}

public static int bestimmeHoechstenWert(int[] werte) {
    int maximum = werte[0];

    for (int i = 1; i < werte.length; i++) {
        if (werte[i] > maximum) {
            maximum = werte[i];
        }
    }

    return maximum;
}

5. main als Steuerung, Methoden als Fachlogik

public class AkkuAuswertung {
    public static void main(String[] args) {
        int[] akkustaende = {80, 64, 25, 18};

        int niedrigsterAkku = bestimmeNiedrigstenAkku(akkustaende);
        int warnungen = zaehleAkkuWarnungen(akkustaende);

        System.out.println("Niedrigster Akku: " + niedrigsterAkku);
        System.out.println("Akkuwarnungen: " + warnungen);
    }

    public static int bestimmeNiedrigstenAkku(int[] werte) {
        int minimum = werte[0];

        for (int i = 1; i < werte.length; i++) {
            if (werte[i] < minimum) {
                minimum = werte[i];
            }
        }

        return minimum;
    }

    public static int zaehleAkkuWarnungen(int[] werte) {
        int anzahl = 0;

        for (int i = 0; i < werte.length; i++) {
            if (werte[i] <= 20) {
                anzahl++;
            }
        }

        return anzahl;
    }
}

• main zeigt den groben Ablauf.
• Methoden enthalten die Detailverarbeitung.
• Die Fachlogik wird dadurch benennbar und gezielt prüfbar.
• Das bereitet GUI vor: Event-Handler sollen später möglichst Methoden aufrufen statt Fachlogik unübersichtlich direkt im Handler zu enthalten.

public static int verdopple(int wert) {
    int ergebnis = wert * 2;
    return ergebnis;
}

public static void setzeErstenWert(int[] daten, int wert) {
    daten[0] = wert;
}

public static String klein(String text) {
    return text.toLowerCase();
}

6. Werkzeugarbeit: Methoden

7. Übergang zur GUI

In der GUI löst ein Button-Klick einen Event-Handler aus. Dieser liest Eingaben, ruft die Fachlogik als Methode auf und schreibt das Ergebnis zurück in eine Komponente.

Eine grafische Benutzeroberfläche verbindet sichtbare Eingabe, Aktion und Ausgabe. Im Anhalteweg-Beispiel bilden JFrame, JLabel, JTextField und Button den sichtbaren Arbeitsweg.

Die GUI ist Präsentations- und Interaktionsschicht: Komponenten zeigen Zustände und Ergebnisse. Der Event-Handler liest Eingaben und koordiniert die Reaktion; die Fachmethode berechnet oder prüft.

1. Oberfläche, Ereignissteuerung und Fachlogik

Eine einfache GUI-Anwendung lässt sich in drei Ebenen denken: Die Oberfläche nimmt Eingaben entgegen und zeigt Ergebnisse, die Ereignissteuerung reagiert auf Benutzeraktionen, und die Fachlogik führt Berechnungen und Prüfungen aus.

Der Event-Handler bildet die Vermittlungsschicht zwischen Oberfläche und Fachlogik: Er liest Zustände aus Komponenten, ruft eine passende Verarbeitungsmethode auf und schreibt das Ergebnis in die Oberfläche zurück.

2. Linearer Ablauf versus ereignisgesteuerter Ablauf

Das klassische EVA-Modell bleibt erhalten, aber der Programmablauf wird im GUI-Kontext durch Ereignisse gesteuert.

Wichtig: Ein Button ist keine direkte Dateneingabe. Er ist ein Auslöser, der ein Ereignis erzeugt und damit die Verarbeitung startet.

Vertiefung: EVA-Darstellung im GUI-Kontext

3. Sichtbare Basisbausteine

Aufbauschicht: Hauptfenster, Container und Komponenten

Ein JFrame ist das Hauptfenster einer Swing-Anwendung. Komponenten werden darin nicht frei schwebend platziert, sondern in eine Container-Struktur eingefügt. Ein Container kann weitere Komponenten enthalten und strukturieren. Das Fenster ist der oberste Container; ein JPanel kann als innerer Container Komponenten gruppieren. Sichtbare Komponenten sind z. B. JLabel, JTextField, JButton oder JCheckBox. Typisch ist die Reihenfolge: Objekt erzeugen → konfigurieren → anordnen/positionieren → hinzufügen → später auswerten oder verändern.

Informatikfachlich bedeutet das: Fenster, Panels, Buttons und Textfelder sind Objekte mit Eigenschaften, Methoden und internem Zustand. Container strukturieren diese Objekte und erzeugen gemeinsam eine hierarchische Objektstruktur der Oberfläche.

import javax.swing.*;

public class ContainerStrukturDemo {
    public static void main(String[] args) {
        JFrame fenster = new JFrame("Container-Struktur");
        fenster.setSize(360, 220);
        fenster.setDefaultCloseOperation(JFrame.EXIT_ON_CLOSE);
        fenster.setLayout(null);

        JPanel panel = new JPanel();
        panel.setLayout(null);
        panel.setBounds(20, 20, 300, 120);

        JLabel beschriftung = new JLabel("Panel als innerer Container");
        beschriftung.setBounds(20, 20, 220, 25);
        panel.add(beschriftung);

        JButton button = new JButton("Aktion");
        button.setBounds(20, 60, 100, 25);
        panel.add(button);

        fenster.add(panel);
        fenster.setVisible(true);
    }
}

• JFrame ist das Hauptfenster.
• JPanel ist ein innerer Container.
• JLabel und JButton werden dem Panel hinzugefügt.
• Das Panel wird anschließend dem Fenster hinzugefügt.
• Dadurch entsteht eine hierarchische Struktur aus Containern und Komponenten.

Bausteine einer einfachen Swing-GUI

Swing-Komponenten folgen einem gemeinsamen Muster: Der Konstruktor erzeugt ein Objekt, setBounds(...) beziehungsweise ein Layout-Manager bestimmt die Darstellung, und mit add(...) wird die Komponente in einen Container eingefügt.

Benötigte Importpakete für die Swing-Beispiele

import javax.swing.*;
import java.awt.event.ActionEvent;
import java.awt.event.ActionListener;

JFrame – Fenster erzeugen

JFrame fenster = new JFrame("Login");

JLabel – Text ausgeben

JLabel lblInfo = new JLabel("Bitte anmelden");

JTextField – Eingabe aufnehmen

JTextField txtUser = new JTextField();

JButton – Ereignis auslösen

JButton btnLogin = new JButton("Anmelden");

setLayout(null) – absolute Positionierung aktivieren

fenster.setLayout(null);

setBounds(...) – Position und Größe festlegen

btnLogin.setBounds(80, 90, 120, 25);

add(...) – Komponente einfügen

fenster.add(btnLogin);

setVisible(true) – Fenster anzeigen

fenster.setVisible(true);

Die Codeboxen sind bewusst isoliert dargestellt. In einem vollständigen Programm müssen diese Bausteine in sinnvoller Reihenfolge zusammengesetzt werden. Für die Einführungsphase wird zunächst mit setLayout(null) und setBounds(...) gearbeitet, weil dadurch der Zusammenhang zwischen Objekt, Position und Anzeige besonders sichtbar bleibt.

Warum Komponenten oft Attribute sind

Eine lokale Variable ist außerhalb ihres Blocks beziehungsweise ihrer Methode nicht zugreifbar. Wichtige GUI-Komponenten werden deshalb oft als Attribute, also als Felder der Klasse, gespeichert: Der Konstruktor erzeugt und ordnet sie, der Listener liest oder verändert später dieselben Komponenten.

Benötigte Importpakete

import javax.swing.*;
import java.awt.event.ActionEvent;
import java.awt.event.ActionListener;

1. Attribute deklarieren

private JTextField txtName;
private JLabel lblAusgabe;

2. Im Konstruktor erzeugen

public MeineGUI() {
    txtName = new JTextField(20);
    lblAusgabe = new JLabel("Noch keine Eingabe.");
}

3. Im Listener verwenden

public void actionPerformed(ActionEvent e) {
    String name = txtName.getText();
    lblAusgabe.setText("Hallo, " + name + "!");
}

Wenn Komponenten dauerhaft verfügbar sind, kann der Event-Handler mit ihnen arbeiten: Er liest Zustände aus, verarbeitet Werte und schreibt Ergebnisse zurück.

4. Zustände von GUI-Komponenten lesen und verändern

• GUI-Komponenten sind Objekte mit internem Zustand.
• get- und is-Methoden lesen Zustände.
• set-Methoden verändern Zustände.
• Die Komponente bleibt bestehen; nur ihr Zustand ändert sich.
• setText("") löscht nicht das Objekt, sondern setzt den Textzustand auf die leere Zeichenkette.

Vertiefung: Spezielle Layout-Formen

Bisher wurde in E3 bewusst mit setLayout(null) und setBounds(...) gearbeitet, damit Positionen und Größen explizit sichtbar werden. In größeren Swing-Programmen werden stattdessen Layout-Manager eingesetzt. Sie ordnen Komponenten automatisch an und reagieren auf Fenstergrößen sowie die verfügbare Containerfläche.

In dieser Vertiefung werden drei zentrale Layouts aus der Swing-Grundausbildung betrachtet: FlowLayout, BorderLayout und GridLayout. Als kurzer Ausblick gelten außerdem BoxLayout, CardLayout und GridBagLayout, die hier nicht weiter vertieft werden.

FlowLayout – zeilenweise Anordnung

Komponenten werden zeilenweise von links nach rechts angeordnet. Wenn kein Platz mehr vorhanden ist, beginnt automatisch eine neue Zeile. Die sichtbare Anordnung hängt daher direkt von der Fensterbreite ab.

Hinweis: Das Beispiel nutzt hier extends JFrame, weil viele Swing-Quellen so kompakt erklären. Die bisherigen E3-Beispiele arbeiten weiterhin ohne Vererbung über ein separates JFrame-Objekt.

import javax.swing.*;
import java.awt.FlowLayout;

public class FlowLayoutDemo extends JFrame {
    public FlowLayoutDemo() {
        setTitle("FlowLayoutDemo");
        setSize(500, 160);
        setDefaultCloseOperation(JFrame.EXIT_ON_CLOSE);

        setLayout(new FlowLayout(FlowLayout.LEFT));

        add(new JButton("Button 1"));
        add(new JButton("Button 2"));
        add(new JButton("Button 3"));
        add(new JButton("Long-Named Button 4"));
        add(new JButton("5"));

        setVisible(true);
    }

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

BorderLayout – fünf Bereiche

Die Containerfläche wird in fünf Bereiche eingeteilt: NORTH, WEST, SOUTH, EAST und CENTER. Bei Größenänderungen wächst besonders der CENTER-Bereich; die Randbereiche passen sich entsprechend an. Direkt pro Position kann höchstens eine Komponente eingefügt werden (für mehrere Elemente nutzt man z. B. ein zusätzliches JPanel).

import javax.swing.*;
import java.awt.BorderLayout;

public class BorderLayoutDemo extends JFrame {
    public BorderLayoutDemo() {
        setTitle("BorderLayoutDemo");
        setSize(420, 240);
        setDefaultCloseOperation(JFrame.EXIT_ON_CLOSE);

        setLayout(new BorderLayout());

        add(new JButton("North"), BorderLayout.NORTH);
        add(new JButton("West"), BorderLayout.WEST);
        add(new JButton("South"), BorderLayout.SOUTH);
        add(new JButton("East"), BorderLayout.EAST);
        add(new JButton("Center"), BorderLayout.CENTER);

        setVisible(true);
    }

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

GridLayout – gitterförmige Anordnung

Komponenten werden gitterförmig angeordnet. Jede Komponente ist gleich groß und nutzt den verfügbaren Platz vollständig aus. new GridLayout(0, 2) bedeutet dabei: beliebig viele Zeilen und genau zwei Spalten.

import javax.swing.*;
import java.awt.GridLayout;

public class GridLayoutDemo extends JFrame {
    public GridLayoutDemo() {
        setTitle("GridLayoutDemo");
        setSize(420, 220);
        setDefaultCloseOperation(JFrame.EXIT_ON_CLOSE);

        setLayout(new GridLayout(0, 2));

        add(new JButton("Button 1"));
        add(new JButton("Button 2"));
        add(new JButton("Button 3"));
        add(new JButton("Long-Named Button 4"));
        add(new JButton("5"));

        setVisible(true);
    }

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

import javax.swing.*;

JCheckBox newsletter = new JCheckBox("Newsletter abonnieren");
newsletter.setBounds(20, 20, 220, 25);
fenster.add(newsletter);

boolean ausgewaehlt = newsletter.isSelected();

JRadioButton klein = new JRadioButton("klein");
klein.setBounds(20, 20, 100, 25);

JRadioButton gross = new JRadioButton("groß");
gross.setBounds(20, 50, 100, 25);

ButtonGroup gruppe = new ButtonGroup();
gruppe.add(klein);
gruppe.add(gross);

fenster.add(klein);
fenster.add(gross);

if (gross.isSelected()) {
    ausgabe.setText("Groß wurde gewählt.");
}

String[] farben = {"Rot", "Grün", "Blau"};
JComboBox<String> auswahl = new JComboBox<>(farben);
auswahl.setBounds(20, 20, 120, 25);
fenster.add(auswahl);

String farbe = (String) auswahl.getSelectedItem();

JTextArea textbereich = new JTextArea();
textbereich.setBounds(20, 20, 220, 80);
fenster.add(textbereich);

String text = textbereich.getText();

JPasswordField passwortFeld = new JPasswordField();
passwortFeld.setBounds(20, 20, 160, 25);
fenster.add(passwortFeld);

String passwort = new String(passwortFeld.getPassword());

JPanel panel = new JPanel();
panel.setLayout(null);
panel.setBounds(10, 10, 250, 100);

JLabel label = new JLabel("Gruppe");
label.setBounds(20, 20, 100, 25);
panel.add(label);

fenster.add(panel);

Zustände allein machen eine GUI noch nicht interaktiv. Erst durch Ereignisse wird festgelegt, wann diese Zustände gelesen oder verändert werden.

5. Listener und Ereignisreaktion

Ereignisverarbeitung trennt den Aufbau der Oberfläche vom Verhalten des Programms. Der GUI-Aufbau beschreibt, welche Objekte sichtbar sind; der Listener beschreibt, wie auf ein Ereignis reagiert wird. Ein Ereignis ist z. B. ein Button-Klick oder eine Auswahländerung. Über addActionListener(...) wird eine Reaktion registriert. Die Methode actionPerformed(...) wird erst ausgeführt, wenn das Ereignis eintritt.

Ein Button ist damit Auslöser, nicht Datenspeicher und nicht die Verarbeitung selbst. Welche Verarbeitungsroutine beim Klick ausgeführt wird, steht im registrierten Listener.

Button-Klick
    ↓
ActionEvent entsteht
    ↓
registrierter Listener reagiert
    ↓
actionPerformed(...) wird ausgeführt

import javax.swing.*;
import java.awt.event.ActionEvent;
import java.awt.event.ActionListener;

Im sichtbaren Kern wird nur das anonyme ActionListener-Muster verwendet. Es ist im folgenden vollständigen Anhalteweg-Beispiel integriert.

btnLogin.addActionListener(new ActionListener() {
    @Override
    public void actionPerformed(ActionEvent e) {
        // Dieser Block wird erst beim Klick auf den Button ausgeführt.
    }
});

Object quelle = e.getSource();

button.addActionListener(new ActionListener() {
    @Override
    public void actionPerformed(ActionEvent e) {
        String name = eingabe.getText();

        if (name.equals("")) {
            ausgabe.setText("Bitte Namen eingeben.");
        } else {
            ausgabe.setText("Hallo, " + name + "!");
        }
    }
});

6. Vollständiger GUI-EVA-Ablauf am Anhalteweg-Beispiel

GUI-Programme bestehen aus Aufbau und Verhalten. Zum Aufbau gehören Fenster, Komponenten, Positionen und Container. Zum Verhalten gehören die Reaktion auf Ereignisse, das Lesen von Eingaben, die Verarbeitung und die Ausgabe. Der Event-Handler verbindet beides: Er arbeitet mit den sichtbaren Objekten, sobald ein Benutzerereignis eintritt.

Das folgende Minimalbeispiel kombiniert die vorherigen Bausteine vollständig und zeigt den Weg von Eingabe über Ereignis und Verarbeitung zur Ausgabe.

import javax.swing.*;
import java.awt.event.ActionEvent;
import java.awt.event.ActionListener;

public class GuiEvaMinimal {
    public static void main(String[] args) {
        JFrame fenster = new JFrame("Anhalteweg");
        fenster.setSize(320, 160);
        fenster.setDefaultCloseOperation(JFrame.EXIT_ON_CLOSE);
        fenster.setLayout(null);

        JTextField eingabe = new JTextField();
        eingabe.setBounds(20, 20, 160, 25);
        fenster.add(eingabe);

        JButton button = new JButton("Berechnen");
        button.setBounds(190, 20, 100, 25);
        fenster.add(button);

        JLabel ausgabe = new JLabel("Noch keine Berechnung.");
        ausgabe.setBounds(20, 70, 260, 25);
        fenster.add(ausgabe);

        button.addActionListener(new ActionListener() {
            @Override
            public void actionPerformed(ActionEvent e) {
																double geschwindigkeitKmh = Double.parseDouble(eingabe.getText());
																double anhalteweg = berechneAnhalteweg(geschwindigkeitKmh);
																ausgabe.setText("Anhalteweg: " + anhalteweg + " m");
            }
        });

        fenster.setVisible(true);
    }

															public static double berechneAnhalteweg(double geschwindigkeitKmh) {
																double reaktionsweg = (geschwindigkeitKmh / 10.0) * 3.0;
																double bremsweg = (geschwindigkeitKmh / 10.0) * (geschwindigkeitKmh / 10.0);
																return reaktionsweg + bremsweg;
    }
}

• Aufbau: JFrame, JTextField, JButton und JLabel werden erzeugt und hinzugefügt.
• Ereignis: Ein Button-Klick startet actionPerformed(...).
• Eingabe: getText() liest Text aus dem Textfeld, Double.parseDouble(...) macht daraus eine Zahl.
• Verarbeitung: berechneAnhalteweg(...) berechnet Reaktionsweg und Bremsweg und addiert beide Werte.
• Ausgabe: setText(...) aktualisiert das Label.
• Trennung: Dieselbe Methode könnte auch aus einem Konsolenprogramm oder Test heraus aufgerufen werden.

Modellgrenze: Das Beispiel verwendet eine vereinfachte Faustformel. Reale Anhaltewege hängen unter anderem von Reaktionszeit, Fahrbahn, Reifen und Bremsvorgang ab. Das Minimalbeispiel setzt zudem eine gültige Zahleneingabe voraus; Eingabevalidierung ist ein anschließender Diagnose- und Transferfall.

Für größere Programme gilt: Die Oberfläche steuert Ein- und Ausgabe. Berechnungen und Prüfungen sollten möglichst in getrennten Methoden liegen, damit der Event-Handler als Vermittlungsschicht übersichtlich bleibt. Das betrifft zum Beispiel den Anhalteweg oder Prüfregeln.

import javax.swing.*;
import java.awt.event.ActionEvent;
import java.awt.event.ActionListener;

// Der Button löst nur aus.
button.addActionListener(new ActionListener() {
    @Override
    public void actionPerformed(ActionEvent e) {
        String name = eingabe.getText();
        ausgabe.setText("Hallo, " + name + "!");
    }
});

System.out.println("Programmstart");

button.addActionListener(new ActionListener() {
    @Override
    public void actionPerformed(ActionEvent e) {
        System.out.println("Button wurde geklickt");
    }
});

double summe = a + b;                 // Fachlogik
ausgabe.setText("Summe: " + summe);   // GUI-Ausgabe

public static void main(String[] args) {
    // Wird beim Programmstart ausgeführt.
}

public void actionPerformed(ActionEvent e) {
    // Wird beim Klick ausgeführt.
}

button.addActionListener(new ActionListener() {
    @Override
    public void actionPerformed(ActionEvent e) {
																					double geschwindigkeitKmh =
																						Double.parseDouble(eingabe.getText());

																				double anhalteweg =
																					berechneAnhalteweg(geschwindigkeitKmh);

        ausgabe.setText(
            "Anhalteweg: " + anhalteweg
        );
    }
});

																			public static double berechneAnhalteweg(double geschwindigkeitKmh) {
																				double reaktionsweg = (geschwindigkeitKmh / 10.0) * 3.0;
																				double bremsweg = (geschwindigkeitKmh / 10.0) * (geschwindigkeitKmh / 10.0);
																				return reaktionsweg + bremsweg;
}

import java.awt.event.ActionEvent;
import java.awt.event.ActionListener;

button.addActionListener(new ActionListener() {
    @Override
    public void actionPerformed(ActionEvent e) {
        String name = eingabe.getText().trim();

        if (name.equals("")) {
            name = "Gast";
        }

        ausgabe.setText("Hallo, " + name + "!");
    }
});

import javax.swing.*;
import java.awt.event.ActionEvent;
import java.awt.event.ActionListener;

public class GuiAddition {
    public static void main(String[] args) {
        JFrame fenster = new JFrame("Addition");
        fenster.setSize(360, 180);
        fenster.setDefaultCloseOperation(JFrame.EXIT_ON_CLOSE);
        fenster.setLayout(null);

        JTextField eingabeA = new JTextField();
        eingabeA.setBounds(20, 20, 80, 25);
        fenster.add(eingabeA);

        JTextField eingabeB = new JTextField();
        eingabeB.setBounds(110, 20, 80, 25);
        fenster.add(eingabeB);

        JButton button = new JButton("Addieren");
        button.setBounds(200, 20, 110, 25);
        fenster.add(button);

        JLabel ausgabe = new JLabel("Noch kein Ergebnis.");
        ausgabe.setBounds(20, 70, 280, 25);
        fenster.add(ausgabe);

        button.addActionListener(new ActionListener() {
            @Override
            public void actionPerformed(ActionEvent e) {
                double a = Double.parseDouble(eingabeA.getText());
                double b = Double.parseDouble(eingabeB.getText());
                double summe = a + b;
                ausgabe.setText("Summe: " + summe);
            }
        });

        fenster.setVisible(true);
    }
}

In E3 wird die gesamte fachliche Bewegung sichtbar: Ein Problem wird fachlich verstanden und durch Daten sowie Zustände modelliert. Ein einfacher Algorithmus ordnet die Verarbeitung; ein Struktogramm kann ihn sprachunabhängig darstellen. Java implementiert ihn als Programm, gegebenenfalls in mehreren Methoden. Ein Trace zeigt die konkrete Ausführung für bestimmte Eingaben, und Diagnose unterscheidet Fehler sowie Modellgrenzen.

Diagnoseperspektive: Programmieren als prüfende Praxis

Programmieren bedeutet in E3 nicht nur, Code zu schreiben. Entscheidend ist, die Wirkung einer Anweisung, eines Ausdrucks oder einer Methode prüfen zu können. Die Diagnose trennt Fehlerarten nach ihrer Ursache.