Queue programmieren

Lernziele

Nach diesem Kapitel kannst du:

• das Queue-Pattern in einem Praxis-Projekt anwenden (Bestellung aufgeben, versenden),
• das Umschütt-Pattern erklären und implementieren (Suchen/Zählen ohne Queue zu zerstören),
• erklären, warum Queue<int> nicht kompiliert und Wrapper-Klassen verwenden,
• eine FulfillmentCenter-Klasse mit Queue entwerfen und implementieren.

Leitfrage: Wie suchst und zählst du in einer Queue, wenn du immer nur das erste Element sehen kannst?

Dein Lernweg

Bearbeite A1 und erweitere entweder deinen Shop aus Unit 1 (A2) oder repariere die Suche (A3). Beide Wege müssen einen vollständigen Vorher-/Nachher-Test enthalten. Der Kompetenzcheck gilt für alle. Stornierung, Fibonacci und Expressverwaltung sind Wahlvertiefungen.

Mermaid-Diagramm wird geladen…

Arbeitsweise: Abruffragen und Kompetenzchecks beantwortest du zuerst allein ohne Unterlagen und KI. Speichere deine eigene Antwort, bevor du die Rückmeldung öffnest. Im Übungsteil darfst du Hilfen nutzen; nenne anschließend, welche Hilfe du gebraucht hast. Bei jedem Programm: erst erwartete Ausgabe und einen Leerfall notieren, dann ausführen und vergleichen.

Voraussetzungen

Phase 1: Einstieg — Das Zähl-Problem

Aufgabe: Wie viele Bestellungen sind offen?

Exploration – 4 Minuten allein, ohne KI: Skizziere eine Methode, die die Anzahl der Bestellungen zählt und danach dieselbe Reihenfolge erhält. Notiere deinen Versuch vor dem Aufklappen. Scheitert er, markiere genau den Schritt, an dem Daten verloren gehen.

Phase 2: Konzeptaufbau — Umschütt-Pattern und Praxis

Abruf 2 – ohne Nachlesen: Was muss nach einer nur lesenden Untersuchung der Queue erhalten sein? Warum ist eine Referenz auf ein Element noch keine Kopie des Elements?

Beim folgenden Beispiel ohne KI: Sage das Ergebnis vorher. Erkläre anschließend einer anderen Person, welche Zeile die Datenstruktur verändert. Erst dann ausführen.

2.1 Das Fulfillment-Center-Projekt

Wir entwickeln die Schnittstelle aus Unit 1 weiter: Aus bestellungAufgeben wird bestellungEingang. naechsteVersenden gibt jetzt eine Bestellung oder null zurück; die Ausgabe übernimmt Main. Übertrage deinen Code aus Unit 1 oder nutze das Gerüst. Die neue Aufgabe ist das erhaltende Zählen, nicht das erneute Abschreiben der beiden Grundmethoden.

Zwei Klassen:

• Bestellung — speichert Kundenname, Produktname und Menge
• FulfillmentCenter — verwaltet Bestellungen in einer Queue<Bestellung>

Mermaid-Diagramm wird geladen…

bestellungEingang() und naechsteVersenden() sind direkt:

public void bestellungEingang(String pKunde, String pProdukt, int pMenge)
{
    schlange.enqueue(new Bestellung(pKunde, pProdukt, pMenge));
}
 
public Bestellung naechsteVersenden()
{
    if (!schlange.isEmpty())
    {
        Bestellung b = schlange.front();
        schlange.dequeue();
        return b;
    }
    return null;
}

2.2 Das Umschütt-Pattern

Problem: anzahlOffene() muss alle Elemente zählen, ohne die Queue zu zerstören.

Lösung: Eine Hilfs-Queue. Jedes Element wird aus der Original-Queue entnommen, gezählt und in die Hilfs-Queue gesteckt. Am Ende werden alle Elemente zurückgeschüttet.

public int anzahlOffene()
{
    int count = 0;
    Queue<Bestellung> hilfe = new Queue<Bestellung>();
 
    // Umschütten: Original → Hilfe (dabei zählen)
    while (!schlange.isEmpty())
    {
        hilfe.enqueue(schlange.front());
        schlange.dequeue();
        count++;
    }
 
    // Zurückschütten: Hilfe → Original
    while (!hilfe.isEmpty())
    {
        schlange.enqueue(hilfe.front());
        hilfe.dequeue();
    }
 
    return count;
}

Teste den Unterschied — naiv vs. sicher:

// Zählen/Suchen in einer Queue, ohne sie zu zerstören:
Queue<Typ> hilfe = new Queue<Typ>();
while (!original.isEmpty())
{
    Typ x = original.front();
    original.dequeue();
    // ... x verarbeiten (zählen, suchen, filtern) ...
    hilfe.enqueue(x);
}
// Zurückschütten
while (!hilfe.isEmpty())
{
    original.enqueue(hilfe.front());
    hilfe.dequeue();
}

Reflexionsfrage: Warum muss man die Elemente zurückschütten? Was wäre die Konsequenz, wenn man es vergisst?

Ruhige Sicherung: Der Bug und die Rettung

2.3 Wrapper-Klassen — Queue<int> geht nicht

Was, wenn du Zahlen in einer Queue speichern willst?

Queue<int> zahlen = new Queue<int>();  // COMPILERFEHLER!

Problem: Generics (<...>) benötigen Referenztypen, nicht primitive Typen wie int oder double.

Lösung: Wrapper-Klassen — sie „verpacken" primitive Werte in Objekte.

Queue<Integer> zahlen = new Queue<Integer>();
zahlen.enqueue(42);    // Auto-Boxing: int → Integer automatisch
int x = zahlen.front(); // Auto-Unboxing: Integer → int automatisch

Zwei Mini-Checks vor der Übung

1. Original A,B,C: A und B sind in die Hilfs-Queue übertragen. Was ist jeweils vorne?

2. Original ist nach dem Zählen nicht leer. Reicht das als Korrektheitsnachweis?

Fading – Hilfen nach Bedarf

Hilfen für Zählen, Suchen und Filtern

Phase 3: Üben

Abgabe-Aufgaben

Erwartungs-Check für A2/A3: Notiere vor jedem Lauf Inhalt und Reihenfolge. Nach wiederholtem Zählen müssen drei Bestellungen in derselben Reihenfolge vorhanden sein. Suche einmal nach einem mittleren Kunden, einmal nach einem unbekannten Namen, danach erneut nach dem ersten. Eine reine Ausgabe „true“ genügt nicht: Entnimm am Ende alle Bestellungen und vergleiche ihre vollständige Reihenfolge.

Kompetenzcheck – allein, 8–10 Minuten (Pflicht)

Beantworte die drei Aufgaben ohne Vorlage, Ausführen oder KI. Speichere deine erste Antwort vor dem Vergleich. Eine Partnerlösung ersetzt deine Antwort nicht.

1. Eine Queue enthält A, B, C. Eine Suchmethode findet B und lässt B, C zurück. Erfüllt sie „Suchen ohne Veränderung“? Begründe.
2. Skizziere eine Reparatur mit Hilfs-Queue. Erkläre, warum ein return beim ersten Treffer vor dem Wiederherstellen falsch wäre.
3. Formuliere für Treffer, Nichttreffer und leere Queue je Ergebnis und erwartete Reihenfolge danach.

Neuer Versuch nach gezielter Übung

Queue K,L,K. Beschreibe eine Suche nach Z und danach nach K, die jeweils die erste passende Bestellung liefert und die Queue erhält. Gib beide Endzustände an.

Phase 4: Transfer und Vernetzung

Transferaufgabe

Ohne KI: Notiere zuerst deine eigene Regel und einen erwarteten Ablauf. Erst danach nutze die Hilfen.

Vernetzung

Heute gelöst: Du kannst eine Queue nicht nur benutzen, sondern kontrolliert untersuchen. Mit dem Umschütt-Pattern kannst du zählen, suchen oder filtern, ohne die Warteschlange am Ende leer zurückzulassen.

Noch offen: Bei der Queue haben wir viel Aufwand betrieben, um die ursprüngliche Reihenfolge zu erhalten. Es gibt aber Probleme, bei denen genau die umgekehrte Reihenfolge gewünscht ist: Die letzte Aktion soll zuerst zurückgenommen werden.

Nächster Schritt: Dafür brauchen wir kein FIFO, sondern LIFO. Die nächste Datenstruktur ist der Stack: oben drauflegen, oben wegnehmen, ideal für Undo.

Reflexion

Selbstdiagnose

• Ich kann das Umschütt-Pattern erklären und anwenden.
• Ich weiß, warum Queue<int> nicht funktioniert und verwende Queue<Integer>.
• Ich kann eine FulfillmentCenter-Klasse mit Queue implementieren.

Partnerprüfung oder Solo-Erklärung (5 Minuten)

Erkläre 2 Minuten lang deine gewählte Methode. Dein Gegenüber prüft einen Randfall und fragt: „Warum bleibt die Reihenfolge hier erhalten oder ändert sich?“ Wechselt dann die Rollen. Allein: Schreibe die Erklärung und beantworte dieselbe Frage schriftlich. Vergleiche mit dem passenden Beispiel und verbessere einen unklaren Satz.

Selbstdiagnose: Welchen Ablauf, welche Begründung und welchen Randfall kannst du ohne Hilfe erklären? Nenne jeweils eine konkrete Aufgabe als Beleg. Wie sicher bist du (1–5)? Bei 1–2 bearbeitest du eine passende Hilfe und den neuen Versuch; bei 4–5 wählst du eine eigene Erweiterung.