Datenübertragung
Überblick: Das Liefernetz von Food Now!
Worum es geht: Alle Stationen von Food Now! teilen sich einen gestörten Funkkanal → In sechs Kapiteln vereinbaren Sie gemeinsame Regeln und bauen eine Station, auf der alle Abteilungen aufbauen.
Wie können sich Zentrale, Kurierinnen und Kuriere, Kasse und Kundschaft über einen gemeinsamen, gestörten Funkkanal eindeutig und zuverlässig verständigen – und wer legt die Regeln dafür fest?
„Food Now!“ kennen Sie aus der objektorientierten Modellierung. Der Lieferdienst bekommt jetzt ein eigenes Liefernetz: Alle Stationen funken auf derselben Frequenz. In der Online-IDE ist diese Frequenz eine WebSocket-Sitzung – jede Nachricht einer Station kommt bei allen anderen Stationen der Sitzung an. Damit das funktioniert, braucht das Netz ein Protokoll.
| Kapitel | Problem im Liefernetz | Ergebnis |
|---|---|---|
| 1 Funkchaos | Alle funken frei, Bestellungen gehen unter | Anforderungen, eigenes Paketformat |
| 2 Das Paket | Jede Gruppe spricht einen anderen „Dialekt“ | Standard FN/1, Klasse Paket |
| 3 Funken | Das Programm hört nicht zu – und dann hört es alles | ereignisgesteuerte Station mit Adressfilter |
| 4 Rauschen auf der Leitung | „Hasestraße 72“ statt „12“ | Prüfsumme, NAK; Hamming als Alternative |
| 5 Verloren und doppelt | Bestellung weg – oder doppelt geliefert | ACK, Timeout, Seq, Stop-and-Wait |
| 6 Die Großbestellung | 137 Zeichen passen in kein Paket | Fragmentierung |
Nach jedem Kapitel gibt es einen Checkpoint: eine lauffähige Datei mit dem Stand am Kapitelende. Wer hängt, lädt sie und arbeitet weiter. Danach arbeiten Sie in Abteilungen; alle bauen auf der Station aus diesem Kern auf.
Kapitel 1: Funkchaos
Worum es geht: Alle funken frei durcheinander → Sie leiten ab, was ein Protokoll regeln muss, und entwerfen ein eigenes Format.
Einstieg: Die erste Schicht im Liefernetz
Freitag, 17 Uhr: Die erste Schicht im neuen Liefernetz beginnt. Jede Station hat ein Funkgerät, Regeln gibt es keine. „Das klappt schon“, meint Praktikant Till.
- Sie erhalten eine Rollenkarte und ein Rufzeichen mit genau sechs Zeichen (kürzere werden mit
_aufgefüllt, z. B.KUR10_). Geben Sie in der Online-IDE als Namen nur Ihr Rufzeichen ein. - Starten Sie im Workspace
Funkchaos.javaund melden Sie sich mit dem Sitzungscode an, den die Lehrkraft nennt. - Funkdisziplin: Funken Sie nur, was zu Ihrer Rolle gehört – keine Namen, keine privaten Nachrichten. Die Zentrale (Lehrkraft,
CHAOS1) streut zusätzlich automatisch Funksprüche ein. - Nach der Schicht wertet der Kurs aus: Welche Bestellung wurde von wem geliefert und bezahlt?
| Rolle | Rufzeichen | Auftrag in der Schicht |
|---|---|---|
| Kundschaft | KUNDE1 … KUNDE4 | zwei Gerichte mit Adresse bestellen, nach der Lieferung bezahlen, nach vier Minuten ohne Lieferung beschweren |
| Kurier/in | KURIR1 … KUR10_ | Aufträge übernehmen, Position und Auslieferung melden |
| Kasse | KASSE1 | jede Zahlung der richtigen Bestellung zuordnen |
| Zentrale | CHAOS1 | Bestellungen annehmen und verteilen |
Funkchaos.java ansehen (für die Aufgabe nicht nötig)
String session = Input.readString("Session-Code:", "FN-Q1-CHAOS");
String ruf = Input.readString("Rufzeichen:", "CHAOS1");
Chaosfunk funk = new Chaosfunk();
funk.open(session, ruf);
// ... die Lehrkraft (CHAOS1) sendet automatisch, alle anderen tippen:
while (true) {
String t = Input.readString("Funkspruch:");
funk.sendToAll(t, "TXT");
}
class Chaosfunk extends WebSocket {
// wird automatisch aufgerufen, wenn ein Funkspruch eintrifft
public void onMessage(WebSocketClient sender, String message,
String messageType) {
println(sender.getNickname() + ": " + message, Color.yellow);
}
}Das Rufzeichen vor einer Nachricht kommt von der Online-IDE (Nickname der Verbindung), nicht aus dem Funkspruch. Ein echter Funkempfänger kennt es nicht.
Leitfrage: Welche Bestellungen wurden sicher ausgeliefert und bezahlt – und warum wissen Sie es bei den anderen nicht?
Sammeln Sie Ihre „Ich wusste nicht, …“-Sätze an der Tafel in drei Spalten: Problem → Idee → offene Frage. Legen Sie dann höchstens vier Arbeitsschritte fest.
- Was weiß der Absender nicht, nachdem er gesendet hat?
- Würde ein Programm diese Funksprüche verstehen? Was bräuchte es?
| Nr. | Plan-Punkt | Aufgabe |
|---|---|---|
| 1 | Einen Mitschnitt systematisch auf Unklarheiten untersuchen | 1.1 a |
| 2 | Aus jeder Unklarheit eine Anforderung an Funksprüche ableiten | 1.1 b |
| 3 | Ein Format entwerfen, das ein Programm eindeutig zerlegen kann | 1.2 a, b |
| 4 | Prüfen, ob andere das Format ohne Rückfrage lesen können | 1.2 c |
Aufgaben: Funkchaos auswerten
Werten Sie einen Mitschnitt der ersten Schicht aus und formulieren Sie Anforderungen an ein Protokoll.
Ein Funkempfänger hat 30 Sekunden der Schicht mitgeschnitten. Wer gesendet hat, steht nicht darin.
[17:02:11] Pizza Salami 2x Hasestr 12 [17:02:12] wer faehrt? [17:02:14] ich [17:02:15] ich auch [17:02:19] Pasta Pesto Lotter Str. 5, bitte schnell [17:02:20] OK [17:02:22] Bestellung bezahlt 23,80 [17:02:25] wo bist du? [17:02:26] Neumarkt [17:02:27] Pizza Salami 2x Hasestr 12 [17:02:30] Schulfest GSG: 12x Margherita, 8x Salami, 5x To [17:02:31] Hasestr 72 ist falsch, meinte 12 [17:02:33] ok bin unterwegs zur 72
Markieren Sie alle Stellen, an denen ein Mensch oder ein Programm nicht sicher weiß, was gemeint oder zu tun ist. Notieren Sie zu jeder Stelle die offene Frage („Wer ist mit ‚ich‘ gemeint?“).
Vor dem Vergleich: Welche Stelle haben Sie übersehen – und mit welcher Frage aus Hilfe 2 hätten Sie sie gefunden?
| Zeit | offene Frage |
|---|---|
| :14/:15 | Wer ist „ich“? Fahren jetzt zwei Kuriere? |
| :20 | Wer bestätigt was mit „OK“? |
| :22 | Welche Bestellung, wer zahlt? Alle hören den Betrag. |
| :25/:26 | Wer fragt wen, wer antwortet? |
| :27 | Neue Bestellung oder Wiederholung? Doppelte Lieferung droht. |
| :30 | Abgeschnitten – niemand merkt, dass etwas fehlt. |
| :31/:33 | Die Adresse kam verfälscht an, die Korrektur wurde wieder falsch verstanden. |
Formulieren Sie mindestens sechs Anforderungen der Form „Jeder Funkspruch muss … enthalten, damit …“ oder „Es muss vereinbart sein, dass …, damit …“.
Vor dem Vergleich: Ordnen Sie jede Ihrer Anforderungen einer Zeile aus Teil a) zu. Bleibt eine Zeile ohne Anforderung?
| Problem | Anforderung |
|---|---|
| Ist das für mich? | Empfänger angeben, Rundruf an alle möglich |
| Wem antworte ich? | Absender angeben |
| Bestellung, Antwort, Zahlung? | Art (Typ) angeben |
| „OK“ ohne Bezug, Doppelte | laufende Nummer; Antworten nennen die Nummer |
| abgeschnitten | Länge bzw. „Teil x von y“ angeben |
| Tippfehler/Verfälschung | Kontrollwert mitschicken |
| Angekommen? | Bestätigung vereinbaren, sonst erneut senden |
| Programm kann Freitext nicht zerlegen | festes, maschinenlesbares Format mit Kennung |
Ausgezeichnet – Alle Aufgaben abgeschlossen!
Sie haben aus dem Chaos Anforderungen an ein Protokoll abgeleitet.
Aufgaben: Ein eigenes Paketformat entwerfen
Ihre Gruppe (3–4 Personen) entwirft ein Format, das ein Programm eindeutig zerlegen kann. Jede Gruppe zieht eine Bedingungskarte.
Material: Bedingungskarte (Tabelle 1.2), Anforderungsliste aus Aufgabe 1.1 b, leere Funkzettel.
| Karte | Name | Entwurfsbedingung (zusätzlich zur Anforderungsliste) |
|---|---|---|
| A | Kurzfunk | Ein Funkzettel fasst insgesamt höchstens 24 Zeichen. |
| B | Alles erlaubt | Die Nachricht darf jedes Zeichen enthalten, auch Ihr Trennzeichen. |
| C | Rundruf | Die Zentrale funkt an alle, Kuriere immer nur an eine Station. |
| D | Großbestellung | Bestellungen bis 150 Zeichen, ein Funkzettel fasst 50 Zeichen. |
| E | Rauschen | Jedes einzelne verfälschte Zeichen muss auffallen. |
| F | Viele Sorten | Mindestens fünf Arten von Nachrichten müssen unterscheidbar sein. |
| G | Eilt! | Eilbestellungen müssen sofort erkennbar sein. |
Legen Sie fest, welche Angaben jeder Funkspruch enthält und in welcher Reihenfolge. Entscheiden Sie, woran ein Programm erkennt, wo eine Angabe endet. Begründen Sie mit Ihrer Bedingungskarte.
007), Trennzeichen (# zwischen den Angaben), Präfixfreiheit. Prüfen Sie für Ihre Karte: Was kostet jede Angabe an Platz? Was passiert, wenn das Trennzeichen in der Bestellung vorkommt?ZE>K3#B#012#1/1#2x Pizza Salami, Hasestr. 12#Prüfwert. Welche Anforderungen erfüllt er, welche nicht, und wo scheitert er an Ihrer Karte?Vor dem Vergleich: Formulieren Sie in einem Satz, welche Abwägung Ihr Entwurf trifft (z. B. „kurz, aber …“).
| Karte | typische Entscheidung |
|---|---|
| A | feste, sehr kurze Felder (Z3B07…), wenig Platz für die Nachricht |
| B | Nachricht ans Ende, Längenangabe davor – dann muss nichts verboten werden |
| C | Empfänger-Feld mit festem Wert für „an alle“ |
| D | Felder „Teil“ und „Gesamt“ |
| E | Kontrollwert, z. B. Summe der ASCII-Werte |
| F, G | Typfeld mit festen Abkürzungen, ggf. Prioritätsfeld |
Entwürfe sind verschieden; entscheidend sind Vollständigkeit und Begründung.
Beschreiben Sie Ihr Format als Tabelle Feld | Position bzw. Trennung | Länge | Bedeutung | Beispiel. Schreiben Sie drei Funksprüche aus dem Mitschnitt in Ihrem Format: die Salami-Bestellung an KURIR1, die Bestätigung von KURIR1 und die Position Neumarkt von KURIR2.
| Feld | Position | Länge | Bedeutung |
|---|---|---|---|
| Absender | 0–5 | 6 | Rufzeichen, z. B. ZENTRA |
| Empfänger | 6–11 | 6 | Rufzeichen oder ALLE__ |
| Art | 12 | 1 | B Bestellung, Q Quittung, P Position |
| Nummer | 13–15 | 3 | laufend, führende Nullen |
| Länge | 16–17 | 2 | Zeichen der Nachricht |
| Nachricht | ab 18 | Länge | Text |
ZENTRAKURIR1B012282x Pizza Salami, Hasestr. 12 KURIR1ZENTRAQ01200 KURIR2ZENTRAP03108Neumarkt
Zwei Personen schreiben drei neue Funksprüche nach Ihrer Tabelle, die anderen zerlegen sie ohne Rückfrage. Notieren Sie jede Stelle, an der jemand raten musste, und verbessern Sie die Tabelle zu Version 0.2.
Typische Unklarheiten: Nummer ein- oder dreistellig? Gehört das Leerzeichen zum Feld? Wie heißt „an alle“? Wo endet die Nachricht, wenn sie das Trennzeichen enthält? Jede Unklarheit wird eine Regel in Version 0.2.
Erfüllen Sie zusätzlich die Bedingungen der Karten A und D: Wie viele Funkzettel braucht eine Bestellung mit 150 Zeichen in Ihrem Format? Welche Felder müssen Sie dafür kürzen?
Beispiel: Absender und Empfänger je 2 Zeichen, Art 1, Nummer 2, Teil 1, Gesamt 1 → 9 Zeichen Kopf, 15 Zeichen Nachricht je Zettel → 150 / 15 = 10 Zettel. Teil und Gesamt müssen dann zweistellig sein (10) – der Kopf wächst auf 11 Zeichen, es bleiben 13 Zeichen, also 150 / 13 → 12 Zettel. Kurze Zettel kosten viel Verwaltung.
Ausgezeichnet – Alle Aufgaben abgeschlossen!
Ihr eigener Entwurf steht.
Sicherung
Ein Protokoll ist eine Vereinbarung zwischen Kommunikationspartnern. Es legt fest, in welchem Format Nachrichten übertragen werden und wie sich Sender und Empfänger verhalten (z. B. bestätigen, wiederholen, verwerfen).
Alle Stationen teilen sich einen Kanal. Damit ein Programm Funksprüche verarbeiten kann, braucht jeder Funkspruch neben der Nachricht Verwaltungsangaben.
| Funktion | im Liefernetz | kommt in |
|---|---|---|
| Codierung | festes Format, Kennung, Länge | Kap. 2 |
| Adressierung | Absender, Empfänger | Kap. 2, 3 |
| Fehlererkennung | Kontrollwert, Nummer, Bestätigung | Kap. 4, 5 |
| Priorisierung | Eilbestellungen | Abteilung Zentrale |
| Verschlüsselung, Authentifizierung | Zahlungen, echte Absender | Abteilung Kasse |
Lesen Sie Ihre „Ich wusste nicht, …“-Sätze aus dem Einstieg. Welche davon beantwortet Ihr Format (Version 0.2)? Welcher bleibt offen?
Mit Absender, Empfänger, Nummer und Bestätigung wäre klar gewesen, welcher Kurier welche Bestellung fährt. Die zweite Salami-Bestellung (17:02:27) wäre als Wiederholung erkennbar gewesen, die abgeschnittene Schulfest-Bestellung an der Länge. Offen bleibt in vielen Entwürfen: Was tut der Sender, wenn keine Bestätigung kommt?
Kein Programm-Stand. Bewahren Sie Ihre Formattabelle (Version 0.2) und die drei Funkzettel auf – Sie brauchen sie im Einstieg von Kapitel 2.
Kapitel 2: Das Paket
Worum es geht: Sechs Gruppen, sechs Formate → ein gemeinsamer Standard FN/1 und eine Klasse Paket, die ihn umsetzt.
Einstieg: Sechs Gruppen, sechs Dialekte
Ab Montag funkt die Zentrale mit allen Kurierinnen und Kurieren. Geben Sie Ihre drei Funkzettel aus Aufgabe 1.2 b ohne Formattabelle an die nächste Gruppe. Zerlegen Sie die Zettel, die Sie bekommen: Wer sendet an wen, welche Art, welche Nachricht? Erst nach zwei Minuten gibt es die Formattabelle dazu.
Leitfrage: Die Zentrale ist ein Programm. Wie viele Zerlege-Methoden bräuchte sie, wenn jede Station ein eigenes Format benutzt – und was folgt daraus?
Nebenfragen:
- Welcher Entwurf war ohne Tabelle am leichtesten zu zerlegen? Warum?
- Welche Entscheidung muss Food Now! treffen?
- Ein Paket ist für ein Programm nur ein Text. Was muss das Programm damit tun, bevor es sendet, und nachdem es empfangen hat?
| Nr. | Plan-Punkt | Aufgabe |
|---|---|---|
| 1 | Ein gemeinsamer Standard für alle: FN/1 | Infobox unten |
| 2 | FN/1 lesen und schreiben, mit dem eigenen Entwurf vergleichen | 2.1 |
| 3 | Klasse Paket: Funktext bauen (toString) und zerlegen (parse) | 2.2 a–c |
| 4 | Ohne Netz testen: bauen → zerlegen → bauen ergibt denselben Text | 2.2 d |
Jedes Paket ist ein Text aus Feldern mit fester Breite. Zahlen stehen mit führenden Nullen. Gesendet wird mit dem messageType "FN1". Was in den Nutzdaten steht, legen später die Abteilungen fest.
| Feld | Pos. | Länge | Inhalt |
|---|---|---|---|
| Kennung | 0–2 | 3 | immer FN1 |
| Absender | 3–8 | 6 | Rufzeichen, z. B. ZENTRA, KURIR1, KASSE1 |
| Empfänger | 9–14 | 6 | Rufzeichen oder ALLE__ (an alle) |
| Typ | 15–17 | 3 | BST BestellungACK QuittungNAK negative QuittungPOS PositionKRT KarteZAH ZahlungKEY SchlüsselSTA Status |
| Seq | 18–20 | 3 | laufende Nummer 000–999, nach 999 folgt 000 |
| Teil | 21–22 | 2 | Nummer des Teilpakets 01 … |
| Gesamt | 23–24 | 2 | Anzahl der Teilpakete 01 … |
| Länge | 25–27 | 3 | Zeichen der Nutzdaten 000–060 |
| Nutzdaten | ab 28 | L | höchstens 60 Zeichen, nur ASCII 32–126 (keine Umlaute) |
| Prüfsumme | letzte 3 | 3 | Summe der ASCII-Werte aller Zeichen davor mod 1000 |
Die Felder 0–27 bilden den Kopf, danach folgen die Nutzdaten und die Prüfsumme. Die laufende Nummer heißt Seq.
Aufgaben: FN/1 lesen und mit dem eigenen Entwurf vergleichen
Arbeiten Sie mit Tabelle 2.1 und Ihrer Formattabelle aus Kapitel 1.
Ein Mitschnitt im Format FN/1:
(1) FN1ZENTRAKURIR1BST0070101015Pizza Salami x2198 (2) FN1KURIR1ZENTRAACK0070101000807 (3) FN1ZENTRAALLE__STA0130101020Schichtbeginn 17 Uhr669 (4) FN1KURIR2ZENTRAPOS0310101008Neumarkt687 (5) FN1KASSE1ZENTRAZAH0040101027Bestellung 12 bezahlt 23.80048
Zerlegen Sie die Pakete (2) bis (5) in ihre Felder. Beschreiben Sie in einem Satz, was in jedem Paket passiert.
Vor dem Vergleich: Prüfen Sie bei jedem Paket: Stimmt die Zahl im Längenfeld mit der Zahl Ihrer Nutzdatenzeichen überein?
(1) Die Zentrale schickt Bestellung 7 an Kurier 1. (2) Kurier 1 bestätigt Paket 7. (3) Die Zentrale meldet allen den Schichtbeginn. (4) Kurier 2 meldet seine Position. (5) Die Kasse meldet eine Zahlung – lesbar für alle.
Schreiben Sie als FN/1-Pakete; für die Prüfsumme schreiben Sie ??? (sie folgt in Kapitel 4):
- Die Zentrale schickt Kurier 2 die Bestellung
1x Pasta Pesto, Lotter Str. 5mit Seq 14. - Kurier 2 bestätigt dieses Paket.
Die Prüfsummen wären 290 und 806.
Vergleichen Sie FN/1 mit Ihrem Entwurf nach den Kriterien eindeutig zerlegbar, vollständig, Nutzanteil (Nachrichtenzeichen ÷ alle Zeichen), erweiterbar, für Menschen lesbar. Notieren Sie je einen Vorteil von FN/1 und von Ihrem Entwurf. Erfüllt FN/1 Ihre Bedingungskarte?
# in der Bestellung?Vor dem Vergleich: Markieren Sie die Zeile, in der Ihr Entwurf besser ist als FN/1.
| Kriterium | FN/1 | typischer Trennzeichen-Entwurf |
|---|---|---|
| zerlegbar | jede Position bekannt; Längenfeld erlaubt jedes Zeichen in den Nutzdaten | nur, wenn das Trennzeichen in der Nachricht verboten ist |
| vollständig | Kennung, Adressen, Typ, Seq, Teil/Gesamt, Länge, Prüfsumme | oft ohne Kennung, Länge oder Kontrollwert |
| Nutzanteil | 31 Verwaltungszeichen; Paket (1): 15/46 ≈ 33 % | meist höher |
| erweiterbar | harte Grenzen (6, 999, 60); neue Version über Kennung FN2 | Felder beliebig lang |
| lesbar | mühsam | gut |
Karte A (24 Zeichen) erfüllt FN/1 nicht, schon der Kopf hat 28 Zeichen. B: durch das Längenfeld. D: durch Teil/Gesamt. E: durch die Prüfsumme. F: durch das Typfeld.
Ausgezeichnet – Alle Aufgaben abgeschlossen!
Sie können FN/1-Pakete lesen und schreiben.
Aufgaben: Die Klasse Paket
Sie programmieren die Klasse Paket und testen sie ohne Netz.
Material: Workspace „FN-Kern“ mit Paket.java (Gerüst) und PaketTest.java. Starten Sie PaketTest.java nach jedem Teil: ✓ = klappt, ✗ = offen. Die Tests zu TODO 3 und 5 bleiben bis Kapitel 4 ✗. Pair Programming: Wechseln Sie alle 15 Minuten.
Gerüst Paket.java anzeigen (Auszug)
class Paket {
private String kennung;
private String absender;
private String empfaenger;
private String typ;
private int seq;
private int teil;
private int gesamt;
private int laenge;
private String nutzdaten;
private int pruefsumme;
public Paket(String absender, String empfaenger, String typ,
int seq, int teil, int gesamt, String nutzdaten) {
this.kennung = "FN1";
this.absender = absender;
this.empfaenger = empfaenger;
this.typ = typ;
this.seq = seq;
this.teil = teil;
this.gesamt = gesamt;
this.nutzdaten = nutzdaten;
this.laenge = nutzdaten.length();
this.pruefsumme = berechnePruefsumme(ohnePruefsumme());
}
// TODO 1: Zahl mit führenden Nullen als Text.
// mitNullen(7, 3) -> "007", mitNullen(15, 2) -> "15"
public String mitNullen(int zahl, int stellen) {
return "" + zahl;
}
// TODO 2: alle Felder bis einschließlich Nutzdaten hintereinander,
// Zahlenfelder mit mitNullen auf feste Breite.
// Beispiel: "FN1ZENTRAKURIR1BST0070101015Pizza Salami x2"
public String ohnePruefsumme() {
return "";
}
// TODO 3 (Kapitel 4)
public int berechnePruefsumme(String s) {
return 0;
}
// fertig: Funktext = ohnePruefsumme() + Prüfsumme (3-stellig)
public String toString() {
return ohnePruefsumme() + mitNullen(pruefsumme, 3);
}
// TODO 4: Funktext mit substring zerlegen (Aufgabe 2.2 c)
public static Paket parse(String text) {
return null;
}
// TODO 5 (Kapitel 4)
public boolean istGueltig() {
return false;
}
// fertig: Ziffernfolge -> Zahl, -1 bei einer Nicht-Ziffer
private static int zahlAus(String s) {
int wert = 0;
for (int i = 0; i < s.length(); i++) {
char c = s.charAt(i);
if (c < '0' || c > '9') {
return -1;
}
wert = wert * 10 + ((int) c - 48);
}
return wert;
}
// ... beschreibung() und Getter (fertig)
}Warum? Eine eigene Methode zahlAus statt Integer.parseInt
Integer.parseInt liest in der Online-IDE "4x" ohne Fehler als 4. Ein verfälschtes Zahlenfeld fiele dann nicht auf. zahlAus arbeitet nur mit charAt und ASCII-Werten und liefert bei jeder Nicht-Ziffer −1.
TODO 1
Ziel: mitNullen(7, 3) liefert "007". Fertig, wenn: die vier Tests zu TODO 1 ✓ zeigen.
"" + 7? Wie lang ist das, und wie lang soll es werden?Hilfe 2: Ergänzen Sie das Struktogramm:
Hilfe 3:
Vor dem Vergleich: Was liefert Ihre Methode für mitNullen(1234, 3)? Ist das sinnvoll?
public String mitNullen(int zahl, int stellen) {
String s = "" + zahl;
while (s.length() < stellen) {
s = "0" + s;
}
return s;
}mitNullen(1234, 3) liefert "1234" – die Methode kürzt nicht. Das Feld wäre dann zu breit; deshalb begrenzt FN/1 die Werte (Seq bis 999, Länge bis 60).
TODO 2
Ziel: ohnePruefsumme() setzt die Felder nach Tabelle 2.1 zusammen. Fertig, wenn: der Test „Kopf + Nutzdaten richtig zusammengesetzt“ ✓ zeigt. toString() hängt vorerst 000 an.
mitNullen?+ verkettet.Hilfe 3:
return kennung + absender + empfaenger + typ
+ mitNullen(seq, 3) + /* Teil, Gesamt, Länge */ + nutzdaten;public String ohnePruefsumme() {
return kennung + absender + empfaenger + typ
+ mitNullen(seq, 3) + mitNullen(teil, 2)
+ mitNullen(gesamt, 2) + mitNullen(laenge, 3) + nutzdaten;
}TODO 4
Ziel: parse schneidet die Felder mit substring heraus, wandelt Zahlen mit zahlAus um und erzeugt ein Paket. Danach übernimmt es Kennung, Länge und Prüfsumme so, wie sie angekommen sind. Texte unter 31 Zeichen ergeben null. Ob das Paket fehlerfrei ist, prüft erst istGueltig() in Kapitel 4. Fertig, wenn: alle Tests zu TODO 4 ✓ zeigen (außer „Prüfsumme 198 übernommen“).
public static Paket parse(String text) {
if (text == null || text.length() < 31) {
return null;
}
int n = text.length();
String abs = text.substring(3, 9);
String emp = // TODO: Positionen 9 bis 14
String typ = // TODO
int seq = zahlAus(text.substring(18, 21));
int teil = // TODO
int gesamt = // TODO
// Nutzdaten: alles zwischen Kopf und Prüfsumme
String daten = text.substring(28, n - 3);
Paket p = new Paket(abs, emp, typ, seq, teil, gesamt, daten);
p.kennung = // TODO: wie angekommen
p.laenge = zahlAus(text.substring(25, 28));
p.pruefsumme = // TODO: letzte drei Zeichen, wie angekommen
return p;
}parse ohne Gerüst und begründen Sie, warum parse Kennung, Länge und Prüfsumme nach dem Konstruktor überschreiben muss."FN1ZENTRA".substring(3, 9)? Ist Position 9 dabei?substring(a, b) liefert Position a bis vor b. Feld „Empfänger“ (9–14) → substring(9, 15). Bestimmen Sie so die Grenzen aller Felder aus Tabelle 2.1; die Prüfsumme steht in substring(n - 3, n).istGueltig() dann bei einem verfälschten Paket feststellen?Vor dem Vergleich: Ihre Lösung liest die Nutzdaten mit substring(28, n - 3) und nicht mit substring(28, 28 + laenge). Was wäre bei einem verfälschten Längenfeld 099 passiert?
public static Paket parse(String text) {
if (text == null || text.length() < 31) {
return null;
}
int n = text.length();
Paket p = new Paket(text.substring(3, 9), text.substring(9, 15),
text.substring(15, 18),
zahlAus(text.substring(18, 21)),
zahlAus(text.substring(21, 23)),
zahlAus(text.substring(23, 25)),
text.substring(28, n - 3));
p.kennung = text.substring(0, 3);
p.laenge = zahlAus(text.substring(25, 28));
p.pruefsumme = zahlAus(text.substring(n - 3, n));
return p;
}Mit 28 + laenge käme es bei 099 zu einem Laufzeitfehler (Index hinter dem Textende). Begründung (Challenge): Der Konstruktor setzt FN1, berechnet Länge und Prüfsumme neu – jedes empfangene Paket sähe „richtig“ aus. Nur mit den angekommenen Werten kann istGueltig() vergleichen.
Ergänzen Sie in PaketTest.starte() zwei Tests mit pruefe(bedingung, text): Paket (4) aus Aufgabe 2.1 und eine Quittung ohne Nutzdaten. Erklären Sie, warum der Test „parse und toString passen zusammen“ besonders aussagekräftig ist.
Paket pos = Paket.parse("FN1KURIR2ZENTRAPOS0310101008Neumarkt687"); – was muss danach für pos gelten?Paket pos = Paket.parse("FN1KURIR2ZENTRAPOS0310101008Neumarkt687");
pruefe(pos != null && pos.getAbsender().equals("KURIR2")
&& pos.getSeq() == 31 && pos.getNutzdaten().equals("Neumarkt"),
"Position Neumarkt");
Paket quit = Paket.parse("FN1KURIR1ZENTRAACK0070101000807");
pruefe(quit != null && quit.getNutzdaten().equals("")
&& quit.getLaenge() == 0, "Quittung ohne Nutzdaten");Der Test zeigt, ob toString und parse zueinander passen: Jede Position, die beim Zerlegen anders gezählt wird als beim Bauen, verändert den Text. Genau das brauchen zwei Stationen, um sich zu verstehen.
Zeichnen Sie das Struktogramm zu zahlAus (Listing 2.1) und erklären Sie, warum (int) c - 48 den Ziffernwert liefert.
Die Ziffern 0–9 haben die ASCII-Werte 48–57. Zieht man 48 ab, erhält man den Ziffernwert. wert · 10 schiebt die bisherigen Ziffern eine Stelle nach links.
Ausgezeichnet – Alle Aufgaben abgeschlossen!
Die Klasse Paket kann Funktexte bauen und zerlegen.
Sicherung
Verschiedene Programme können zusammenarbeiten, weil beide dieselbe Vereinbarung (dasselbe Protokoll) genau gleich umsetzen.
Ein Paket besteht aus Kopf, Nutzdaten und Prüfsumme. In FN/1 haben alle Kopffelder eine feste Breite, die Länge der Nutzdaten steht im Kopf. Deshalb genügen length, charAt und substring zum Zerlegen, und die Nutzdaten dürfen jedes Zeichen enthalten. Senden: Objekt → Text (toString). Empfangen: Text → Objekt (parse).
Vergleichen Sie Ihre Vermutung aus dem Einstieg: Wie viele Zerlege-Methoden braucht die Zentrale jetzt? Welche Eigenschaft Ihres eigenen Entwurfs fehlt FN/1?
Mit sechs Formaten bräuchte die Zentrale sechs Zerlege-Methoden – und jede neue Station eine weitere. Mit FN/1 genügt eine Klasse Paket für alle Stationen. Die Dialekte waren einzeln sinnvoll, aber nicht zueinander kompatibel. Was FN/1 nicht kann (z. B. kurze Pakete wie Karte A), ist der Preis des Standards.
Checkpoint_Kap2_Paket.java (TODO 1, 2, 4 gelöst, TODO 3 und 5 offen). Regel: Zeigt PaketTest nach längerer Fehlersuche noch ✗ bei TODO 4, laden Sie den Checkpoint und suchen Sie den Unterschied zu Ihrem Code.
Kapitel 3: Funken
Worum es geht: Ihr Programm soll zuhören, während es auf Eingaben wartet – und dabei nur auf Pakete reagieren, die für Ihre Station bestimmt sind.
Einstieg: Funkspruch während der Eingabe
Ihre Klasse Paket funktioniert, jetzt geht sie auf Sendung. Das Hauptprogramm Ihrer Station sieht so aus:
while (true) {
String ziel = Input.readString("Empfänger:");
String text = Input.readString("Bestellung:");
station.sende(ziel, "BST", text);
}1. Vorhersage (allein): Ihr Programm wartet in Input.readString auf Ihre Eingabe. Genau jetzt funkt die Zentrale eine Bestellung an Sie. Was passiert?
(A) Der Funkspruch geht verloren. (B) Er erscheint, sobald Sie die Eingabe abschicken. (C) Er erscheint sofort, obwohl das Programm wartet.
2. Beobachten: Öffnen Sie Station.java, tragen Sie Ihr Rufzeichen und den Sitzungscode der Lehrkraft ein, setzen Sie demo = false und starten Sie. Geben Sie nichts ein. Die Zentrale funkt einige Bestellungen an verschiedene Kuriere, eine Statusmeldung an alle und eine Zahlung der Kasse. Zählen Sie mit: Wie viele Pakete erscheinen bei Ihnen? Wie viele waren für Ihr Rufzeichen bestimmt?
Leitfrage: Wie kann ein Funkspruch erscheinen, während Ihr Programm in Input.readString wartet – wer hat den Code ausgeführt, der ihn anzeigt?
Nebenfragen:
- Was soll Ihre Station mit Paketen tun, die nicht für sie bestimmt sind?
- Vergleichen Sie: Wer klingelt an Ihrer Haustür – und müssen Sie dafür ständig an der Tür stehen?
- Wo im Programm entscheidet sich, ob ein Paket „für mich“ ist?
| Nr. | Plan-Punkt | Aufgabe |
|---|---|---|
| 1 | Klären, wer empfange aufruft und warum das während der Eingabe geht | 3.1 a |
| 2 | Senden verstehen: Seq, Rundruf, Grenzen | 3.1 b |
| 3 | Adressfilter: nur Pakete an das eigene Rufzeichen oder ALLE__ verarbeiten | 3.2 gA / 3.3 eA |
| 4 | Klären, wer im Netz welche Daten über uns erfährt | 3.1 c |
Aufgaben: Senden und Empfangen verstehen
Ein ausgearbeitetes Beispiel zeigt, welchen Weg ein Paket nimmt. Danach erklären Sie Ihre Beobachtung aus dem Einstieg.
Beispiel: Der Weg eines Pakets. KURIR1 meldet der Zentrale seine Position. Ein Sequenzdiagramm (Zeit-Weg-Diagramm) zeigt den Ablauf: Die Stationen stehen nebeneinander, die Zeit läuft nach unten.
| Schritt | Wo? | Was passiert? | Wer ruft auf? |
|---|---|---|---|
| 1 | Hauptprogramm KURIR1 | station.sende(„ZENTRA“, „POS“, „Neumarkt“) | Ihr Programm |
| 2 | Station KURIR1 | zerlege baut ein Paket mit der nächsten Seq | Ihr Programm |
| 3 | Station KURIR1 | sendeZuverlaessig(p) → funk.senden(p.toString()) | Ihr Programm |
| 4 | Funkgerät KURIR1 | Text durch den StoerKanal, dann sendToAll(text, "FN1") | Ihr Programm |
| 5 | Online-IDE | überträgt an alle anderen Stationen der Sitzung | System |
| 6 | Funkgerät ZENTRA (und KURIR2 …) | onMessage(sender, text, "FN1") startet, in einem eigenen Thread | System |
| 7 | Funkgerät ZENTRA | station.empfange(text) | Funkgerät |
| 8 | Station ZENTRA | parse, Adressfilter, verarbeite | Ihre Station |
eA Ihre Station ist selbst das Funkgerät: Die Schritte 4, 6 und 7 laufen in Ihrer Klasse Station extends WebSocket.
Erklären Sie mit Tabelle 3.1, warum der Funkspruch im Einstieg erschien, obwohl Ihr Programm in Input.readString wartete. Welche Methoden ruft Ihr Programm selbst auf, welche werden „von außen“ aufgerufen?
Input.readString, der andere …Vor dem Vergleich: Welche Antwort (A, B, C) hatten Sie vorhergesagt? Was genau war an Ihrer Begründung richtig oder falsch?
(C) ist richtig. sende ruft Ihr Programm selbst auf (Schritte 1–4). onMessage und damit empfange ruft die Online-IDE auf, sobald etwas ankommt – jedes Mal in einem eigenen Thread (Schritte 6–8). Der Haupt-Thread wartet weiter in Input.readString, der Empfangs-Thread zeigt das Paket an. So eine Methode heißt Ereignismethode: Man schreibt sie, ruft sie aber nie selbst auf – wie eine Türklingel, die Sie ruft, statt dass Sie an der Tür warten.
Beantworten Sie mit Listing 3.2 (unten im gA-Gerüst; im eA-Gerüst ist sende fast gleich):
- Welche Seq bekommen die ersten drei Pakete einer Station? Welche das Paket nach Seq 999?
- Was passiert anders, wenn der Empfänger
ALLE__ist? - Sagen Sie vorher: Was passiert mit einer Bestellung aus 137 Zeichen? Ist das noch FN/1?
zerlege die Zeile mit % 1000 an.060?- Seq 0, 1, 2 (
000,001,002); nach 999 folgt 0 (Ring). - Rundrufe gehen ohne
sendeZuverlaessigdirekt ans Funkgerät; sie werden später nicht quittiert. - Das vorläufige
zerlegepackt alles in ein Paket mit Länge137. Das verletzt FN/1 (höchstens 60) – Thema von Kapitel 6.
Die Online-IDE liefert zu jeder Station der Sitzung nicht nur getNickname(), sondern auch getFirstName(), getLastName() und getUserName() des angemeldeten Kontos. Ihre Station schreibt außerdem jedes gehörte Paket ins Logbuch (eine Datenbank). Wer kann was über Sie erfahren? Vereinbaren Sie drei Regeln für den Kurs.
Jedes Programm in der Sitzung kann die Klarnamen aller anderen lesen, auch ein reines „Lausch-Programm“. Das Logbuch speichert jedes Paket mit Zeit, Absender, Empfänger und Nutzdaten – bei jeder Station, auch fremde Zahlungen im Klartext. Ein Rufzeichen ist ein Pseudonym – nicht anonym. Regeln z. B.: Nickname = Rufzeichen; Klarnamen-Methoden nie aufrufen, anzeigen oder speichern; keine echten Adressen oder Telefonnummern in Nutzdaten; Logbuch nach dem Projekt löschen.
Ausgezeichnet – Alle Aufgaben abgeschlossen!
Sie wissen, wie ein Paket durch das Netz läuft.
Aufgaben: Empfangen mit Adressfilter gA
Sie verbinden Ihre Klasse Paket mit dem fertigen Funkgeraet zu einer Station.
Material: Workspace mit Paket.java (Ihre Lösung oder Checkpoint), StoerKanal.java, Funkgeraet.java, Logbuch.java, Station.java (Gerüst). Das Funkgerät schickt jeden Text über den StoerKanal an alle anderen Stationen und ruft bei Empfang von sich aus station.empfange(text) auf.
Gerüst Station.java anzeigen (Auszug)
// ---- Einstellungen ----
String rufzeichen = "ZENTRA"; // genau 6 Zeichen
String session = "LOOPBACK"; // im Netz: Code der Gruppe
String datenbank = ""; // Logbuch-Datenbank oder ""
boolean demo = true;
Station station = new Station(rufzeichen, datenbank);
StoerKanal kanal = station.getFunk().getKanal();
kanal.setVerlust(0); // Kapitel 5
kanal.setFehler(0); // Kapitel 4
kanal.setVerzoegerung(0);
station.starte(session);
// ... Demo bzw. Eingabeschleife (Listing 3.1)
class Station {
// ... Attribute, Konstruktor, starte, getFunk
// fertig: zerlegen, dann jedes Paket senden
public boolean sende(String empfaenger, String typ,
String text) {
DynArray pakete = zerlege(empfaenger, typ, text);
for (int i = 0; i < pakete.getLength(); i++) {
Paket p = (Paket) pakete.getItem(i);
if (empfaenger.equals("ALLE__")) {
funk.senden(p.toString());
} else if (!sendeZuverlaessig(p)) {
println("Abbruch: " + empfaenger, Color.red);
return false;
}
}
return true;
}
// vorläufig (TODO 4, Kapitel 5): nur senden
public boolean sendeZuverlaessig(Paket p) {
funk.senden(p.toString());
return true;
}
// vorläufig (TODO 5, Kapitel 6): alles in EIN Paket
public DynArray zerlege(String empfaenger, String typ,
String text) {
DynArray liste = new DynArray();
liste.append(new Paket(rufzeichen, empfaenger, typ,
naechsteSeq, 1, 1, text));
naechsteSeq = (naechsteSeq + 1) % 1000;
return liste;
}
// TODO 1 (Aufgabe 3.2 a)
public void empfange(String text) {
println("empfangen: " + text, Color.gray);
}
// hier kommt später die Logik Ihrer Abteilung hin
private synchronized void verarbeite(Paket p, String text) {
println("<= " + p.getTyp() + " von " + p.getAbsender()
+ ": " + text, Color.yellow);
}
}TODO 1
Ziel: empfange zerlegt den Funktext; bei null Abbruch. Pakete, die weder an das eigene Rufzeichen noch an ALLE__ gehen, werden ignoriert, ebenso Quittungen (ACK, NAK – die legt das Funkgerät für später ab). Alle anderen gehen an verarbeite(p, p.getNutzdaten()). Fertig, wenn: die Funkprobe in Teil b) klappt.
Hilfe 2: Ergänzen Sie:
an ≠ rufzeichen und an ≠ "ALLE__", in Java !an.equals(rufzeichen) && !an.equals("ALLE__").Vor dem Vergleich: Warum steht in der Bedingung && und nicht ||? Probieren Sie beide Varianten gedanklich mit an = "ALLE__" aus.
public void empfange(String text) {
Paket p = Paket.parse(text);
if (p == null) {
return;
}
String an = p.getEmpfaenger();
// nicht für mich?
if (!an.equals(rufzeichen) && !an.equals("ALLE__")) {
return;
}
// Quittungen erledigt das Funkgerät
if (p.getTyp().equals("ACK") || p.getTyp().equals("NAK")) {
return;
}
verarbeite(p, p.getNutzdaten());
}Mit || wäre die Bedingung immer wahr (kein Text ist gleichzeitig ZENTRA und ALLE__), die Station würde alles ignorieren.
- Allein:
session = "LOOPBACK",demo = true. Die Demo sendet an das eigene Rufzeichen. Ändern Sie dann ein Ziel auf ein fremdes Rufzeichen. Was erwarten Sie? - In der Gruppe: Sitzungscode Ihrer Gruppe,
demo = false, jede Person mit eigenem Rufzeichen. Senden Sie an einzelne Stationen und anALLE__. Kommt alles genau bei den richtigen Stationen an?
demo = false?LOOPBACK: Pakete an das eigene Rufzeichen erscheinen, an fremde nicht. Gruppe: Bestellungen erscheinen nur beim adressierten Kurier, Rundrufe bei allen anderen – nicht beim Sender, denn sendToAll erreicht nur die anderen.
Ihre Station soll für jedes gehörte Paket (auch fremde) mitzählen, wie viele Pakete jeder Absender gesendet hat, und die Liste mit zeigeStatistik() ausgeben. Nutzen Sie eine DynArray mit Objekten einer kleinen Klasse Zaehler (Rufzeichen, Anzahl).
In empfange direkt nach der null-Prüfung: den Zaehler mit getRufzeichen().equals(p.getAbsender()) suchen (Schleife über getItem), sonst neu anlegen und mit append anfügen; dann anzahl++. Ausgabe in einer Schleife. Die Zählung vor dem Adressfilter zeigt: Jede Station kennt den Funkverkehr aller.
Ausgezeichnet – Alle Aufgaben abgeschlossen!
Ihre Station funkt.
Aufgaben: Die Station wird selbst zum Funkgerät eA
Ihre Station erbt von WebSocket und ist damit selbst das Funkgerät. Sie sendet über ihren StoerKanal (kanal.uebertrage(text)), der sendToAll(text, "FN1") aufruft bzw. im LOOPBACK-Modus onMessage(null, text, "FN1").
Material: Workspace mit Paket.java, StoerKanal.java, Logbuch.java, Station.java (eA-Gerüst) – ohne Funkgeraet.java.
Erläutern Sie an Abbildung 3.3: Welche geerbten Methoden ruft Station selbst auf? Welche überschreibt sie, damit die Online-IDE sie aufruft? Warum führt ein Tippfehler wie onOtherClientDisConnected zu keiner Fehlermeldung, aber zu falschem Verhalten?
WebSocket in zwei Spalten: „Ich rufe auf“ und „Ich werde aufgerufen (on…)“.Selbst aufgerufen: open, sendToAll (über den Störkanal). Überschrieben: onMessage (Pflicht), optional onOpen, onOtherClientConnected, onOtherClientDisconnected – die Online-IDE ruft sie bei Ereignissen auf. Ein Tippfehler erzeugt eine neue Methode. Sie ist erlaubt, wird aber nie aufgerufen; die geerbte, leere Methode bleibt wirksam.
TODO 1
Ziel: Bei "LOOPBACK" den Kanal mit kanal.setLoopback(true) umschalten, sonst open(sessionCode, rufzeichen) – Nickname = Rufzeichen. (Den Timer aus dem Kommentar ergänzen Sie erst in Kapitel 5.)
equals, nicht mit ==.public void verbinde(String sessionCode) {
if (sessionCode.equals("LOOPBACK")) {
kanal.setLoopback(true);
} else {
// Nickname = Rufzeichen, nie der Klarname
open(sessionCode, rufzeichen);
}
}TODO 2
Ziel: onMessage überschreiben: Nur messageType "FN1" beachten; den Text zuerst an empfange geben, danach ins Logbuch schreiben (logbuch.schreibe("EIN", message)). In empfange den Adressfilter ergänzen (wie Hilfe 2 zu Aufgabe 3.2 a). onOtherClientConnected zeigt das Rufzeichen jeder neuen Station.
public void onMessage(WebSocketClient sender, String message, String messageType). Im LOOPBACK ist sender gleich null – benutzen Sie ihn nicht.rufzeichen oder "ALLE__" ist.Vor dem Vergleich: Warum erst empfange, dann Logbuch? (Tipp: Ein Datenbankzugriff dauert pro Paket spürbar.)
public void onMessage(WebSocketClient sender, String message,
String messageType) {
if (!messageType.equals("FN1")) {
return;
}
empfange(message);
logbuch.schreibe("EIN", message);
}
public void onOtherClientConnected(WebSocketClient c) {
// nur das Rufzeichen, keine Klarnamen
println("+ " + c.getNickname() + " ist auf Sendung.");
}
// in empfange nach der null-Prüfung:
String an = p.getEmpfaenger();
if (!an.equals(rufzeichen) && !an.equals("ALLE__")) {
return;
}Erst verarbeiten, dann protokollieren: Ab Kapitel 5 muss eine Quittung schnell beim Sender sein. Wartet sie auf die Datenbank, läuft beim Sender die Wartezeit ab.
Testen Sie wie in Aufgabe 3.2 b) – erst LOOPBACK, dann in der Gruppen-Sitzung, gern zusammen mit einer gA-Station. Begründen Sie, warum sich beide verstehen, obwohl die Programme verschieden aufgebaut sind.
Beide halten sich an FN/1 (gleiche Funktexte, messageType "FN1"). Wie eine Station intern gebaut ist, spielt keine Rolle: Interoperabilität.
Führen Sie eine DynArray mit den Rufzeichen aller verbundenen Stationen: onOtherClientConnected fügt an, onOtherClientDisconnected (kleines c!) entfernt mit delete. Eine Methode zeigeTeilnehmer() gibt die Liste aus.
Beim Entfernen die Liste mit getItem(i) durchsuchen, bei Gleichheit delete(i) und abbrechen. Hinweis: Wer sich ohne Abmeldung trennt (Browser zu), bleibt eventuell in der Liste – das Netz kennt keinen sicheren Abmeldezeitpunkt.
Ausgezeichnet – Alle Aufgaben abgeschlossen!
Ihre Station funkt als eigene WebSocket-Unterklasse.
Sicherung
Eine Ereignismethode schreibt man selbst, aufgerufen wird sie aber vom System, wenn ein Ereignis eintritt (Callback). In der Online-IDE läuft jeder Aufruf von onMessage in einem eigenen Thread – das Hauptprogramm läuft weiter.
Der Funkkanal ist ein geteiltes Medium: Jede Nachricht erreicht alle. Adressierung im Kopf und ein Adressfilter in jeder Station sorgen dafür, dass nur die richtige Station ein Paket verarbeitet. Ein Rundruf geht an ALLE__.
Ein Adressfilter ist kein Schutz. Jede Station kann alle Pakete lesen und einen beliebigen Absender eintragen. Vertraulichkeit und Echtheit brauchen Kryptologie (Abteilung Kasse).
Lesen Sie Ihre Vorhersage aus dem Einstieg. War sie richtig? Formulieren Sie in einem Satz, was ein Konsolenprogramm von einer Station mit Ereignismethode unterscheidet.
Der Funkspruch erschien sofort (C), weil nicht Ihr Hauptprogramm ihn abholte, sondern die Online-IDE onMessage in einem eigenen Thread aufrief. Von allen Paketen, die bei Ihnen ankamen, waren nur wenige für Ihr Rufzeichen bestimmt; die Kuriere aus der ersten Schicht hätten mit dem Adressfilter nur noch ihre eigenen Aufträge gesehen.
Checkpoint_Kap3_Station_gA.java bzw. Checkpoint_Kap3_Station_eA.java (empfangen mit Adressfilter). Läuft Ihre Funkprobe nach längerer Fehlersuche nicht: Checkpoint laden und mit dem eigenen Code vergleichen.
Kapitel 4: Rauschen auf der Leitung
Worum es geht: Verfälschte Bestellungen führen Kuriere in die Irre → Ihre Station prüft die Prüfsumme und reklamiert. Sie testen, was die Prüfsumme kann und was nicht – und ob Korrigieren besser wäre.
Einstieg: Hasestraße 72
Mitschnitt von gestern Abend, Gewitter über Osnabrück:
gesendet von ZENTRA: FN1ZENTRAKURIR1BST01201010282x Pizza Salami, Hasestr. 12181 empfangen bei KURIR1: FN1ZENTRAKURIR1BST01201010282x Pizza Salami, Hasestr. 72181
<= BST von ZENTRA: 2x Pizza Salami, Hasestr. 72
Kurier 1 fährt zur Hasestraße 72. Dort hat niemand bestellt. Die Station von KURIR1 hat die mitgeschickte Prüfsumme gar nicht beachtet.
Leitfrage: Erkennt die FN/1-Prüfsumme jede Verfälschung? Legen Sie sich fest: Ja oder Nein – mit einem Beispiel.
Nebenfragen:
- Was soll eine Station mit einem verfälschten Paket tun?
- Könnte der Empfänger den Fehler auch selbst beheben, statt nachzufragen?
- Erinnern Sie sich an Paritätsbit und EAN-Prüfziffer: Was wird berechnet, was mitgeschickt, was geprüft?
- Wie können Sie Ihre Festlegung überprüfen, ohne zu programmieren?
| Nr. | Plan-Punkt | Aufgabe |
|---|---|---|
| 1 | Prüfsumme von Hand rechnen, Festlegung an verschiedenen Fehlerarten testen | 4.1 |
| 2 | Ausprobieren, ob Korrigieren mit dem Hamming-Code besser wäre | 4.2 |
| 3 | berechnePruefsumme und istGueltig programmieren | 4.3 a, b |
| 4 | Verfälschte Pakete nicht verarbeiten, sondern reklamieren; messen | 4.3 c, d |
Aufgaben: Die Prüfsumme auf dem Prüfstand
Erst auf Papier: Was erkennt die Prüfsumme, was nicht?
Die FN/1-Prüfsumme ist die Summe der ASCII-Werte aller Zeichen vor ihr, mod 1000, dreistellig.
| Zeichen | ASCII | Zeichen | ASCII |
|---|---|---|---|
| 0 … 9 | 48 … 57 | A | 65 |
| 1 | 49 | C | 67 |
| 2 | 50 | K | 75 |
| 7 | 55 | Leerzeichen | 32 |
Berechnen Sie die Prüfsumme der Quittung FN1KURIR1ZENTRAACK0070101000???. Gegeben: FN1 = 197, KURIR1 = 446, ZENTRA = 468.
ACK und 0070101000. Wie viele Nullen stecken im zweiten Block?| Block | Summe |
|---|---|
| FN1 | 197 |
| KURIR1 | 446 |
| ZENTRA | 468 |
| ACK | 65 + 67 + 75 = 207 |
| 0070101000 | 10 · 48 + 7 + 1 + 1 = 489 |
| gesamt | 1807 → mod 1000 = 807 |
Gesendet wurde FN1ZENTRAKURIR1BST01201010282x Pizza Salami, Hasestr. 12181 (Prüfsumme 181). Bestimmen Sie für jede empfangene Variante nur, wie sich die Summe ändert, und ob der Empfänger den Fehler bemerkt.
| Nr. | empfangen (veränderter Teil) | Fehlerart |
|---|---|---|
| (1) | … Hasestr. 72 … 181 | ein Zeichen verfälscht |
| (2) | …KURIR2… … 181 | ein Zeichen im Kopf verfälscht |
| (3) | … Hasestr. 21 … 181 | zwei Zeichen vertauscht |
| (4) | … Hasestr. 12 … 131 | Prüfsumme verfälscht |
1 (49) eine 7 (55). Um wie viel ändert sich die Summe?Vor dem Vergleich: Passt das Ergebnis zu Ihrer Festlegung aus dem Einstieg?
| Nr. | Änderung | neu berechnet | erkannt? |
|---|---|---|---|
| ✓ (1) | +6 | 187 ≠ 181 | ja |
| ✓ (2) | +1 | 182 ≠ 181 | ja – sonst nähme Kurier 2 die Bestellung an |
| ✗ (3) | ±0 | 181 = 181 | nein: Hausnummer 21 |
| ✓ (4) | Summe gleich, Prüffeld falsch | 181 ≠ 131 | ja – Paket wird unnötig verworfen, aber kein falscher Auftrag |
Formulieren Sie: Welche Fehler erkennt die FN/1-Prüfsumme sicher, welche nie, welche manchmal? Begründen Sie mit den Zahlen aus Teil b).
1 eine 0 und aus 2 eine 3 wird?Sicher erkannt wird jedes einzelne verfälschte Zeichen, auch im Kopf und in der Prüfsumme: Die Summe ändert sich um höchstens ±94, nie um 0 oder ein Vielfaches von 1000. Nie erkannt werden Vertauschungen (gleiche Zeichen, gleiche Summe). Manchmal übersehen werden mehrere Fehler, die sich aufheben (12 → 03: −1 + 1 = 0).
Ausgezeichnet – Alle Aufgaben abgeschlossen!
Sie wissen, was die FN/1-Prüfsumme leistet.
Aufgaben: Korrigieren statt reklamieren?
Eine Prüfsumme kann nur reklamieren. Der Hamming-Code aus der Codierungstheorie kann einzelne Bitfehler korrigieren. Lohnt sich das im Liefernetz? (Papier, ohne IDE)
Material: Hamming(7,4) wie im Abitur: Reihenfolge p0 p1 d0 p2 d1 d2 d3, gerade Parität. Das Zeichen 1 hat den ASCII-Wert 49 = 0011 0001; jedes Halbbyte wird ein Codewort.
| Prüfbit | Stellen (1–7) | Bits |
|---|---|---|
| p0 | 1, 3, 5, 7 | p0, d0, d1, d3 |
| p1 | 2, 3, 6, 7 | p1, d0, d2, d3 |
| p2 | 4, 5, 6, 7 | p2, d1, d2, d3 |
Das erste Halbbyte 0011 ergibt das Codewort 1000011. Kodieren Sie das zweite Halbbyte 0001.
p0 = 1, p1 = 0 + 0 + 1 = 1, p2 = 0 + 0 + 1 = 1 → p0 p1 d0 p2 d1 d2 d3 = 1101001.
Beim Kurier kommt für das zweite Halbbyte 1101101 an. Finden Sie das gekippte Bit, korrigieren Sie es und bestimmen Sie das Zeichen. Was hätte der Kurier ohne Korrektur gelesen?
| Gruppe | Bits (Stellen) | Einsen | s |
|---|---|---|---|
| p0 | 1, 0, 1, 1 (1, 3, 5, 7) | 3 | 1 |
| p1 | 1, 0, 0, 1 (2, 3, 6, 7) | 2 | 0 |
| p2 | 1, 1, 0, 1 (4, 5, 6, 7) | 3 | 1 |
Fehlerstelle 1 + 4 = 5 (d1). Korrigiert 1101001 → Daten 0001 → 0011 0001 = 1. Ohne Korrektur: Daten 0101 → 0011 0101 = 53 = 5, also „Hasestr. 52“.
Vergleichen Sie den Aufwand: Hamming braucht für jedes Zeichen 14 statt 8 Bit, die FN/1-Prüfsumme 3 Zeichen je Paket. Wann lohnt sich Korrigieren statt Reklamieren?
Hamming: Rate 4/7 ≈ 57 %, fast die Hälfte der Bits ist Schutz. Prüfsumme: 3 von 46 Zeichen ≈ 7 %. Korrigieren lohnt, wenn Rückfragen teuer oder unmöglich sind (lange Laufzeiten, Rundfunk ohne Rückkanal, viele Einzelbitfehler). Im Liefernetz ist eine Rückfrage billig, deshalb reklamiert FN/1. Die Abteilung Funkstrecke eA baut Hamming ein.
Aus 1 (0011 0001) wird im Einstieg 7 (0011 0111): Im zweiten Halbbyte kippen zwei Bits. Kodieren Sie, verfälschen Sie die beiden Bits und wenden Sie das Korrekturverfahren an. Was liest der Kurier?
1101001 mit gekippten d1 und d2 → 1101111. Gruppen: p0 → 1, p1 → 1, p2 → 0, Fehlerstelle 1 + 2 = 3. „Korrigiert“ wird d0 → 1111111 → Daten 1111 → 0011 1111 = ?. Bei zwei Fehlern korrigiert Hamming(7,4) falsch – der Mindestabstand 3 reicht nur für einen Fehler.
Ausgezeichnet – Alle Aufgaben abgeschlossen!
Sie kennen Stärken und Grenzen beider Verfahren.
Aufgaben: Prüfen und reklamieren
Jetzt im Code: Die Station soll verfälschte Pakete erkennen und reklamieren.
Material: Ihre Paket.java (TODO 3 und 5) und Ihre Station.java.
TODO 3 (Paket)
Ziel: Summe der ASCII-Codes aller Zeichen von s, mod 1000. Fertig, wenn: in PaketTest die Tests mit 197, 198 und 807 ✓ zeigen.
zahlAus Zeichen für Zeichen durch einen Text gegangen? Den ASCII-Wert liefert (int) s.charAt(i).Hilfe 2: Ergänzen Sie:
public int berechnePruefsumme(String s) {
int summe = 0;
for (int i = 0; i < s.length(); i++) {
summe = summe + (int) s.charAt(i);
}
return summe % 1000;
}TODO 5 (Paket)
Ziel: istGueltig() liefert nur true, wenn
- die Kennung
FN1ist, seq ≥ 0und1 ≤ teil ≤ gesamtgilt (Nicht-Ziffern ergaben −1),laengezur Länge der Nutzdaten passt und höchstens 60 ist,- die mitgeschickte Prüfsumme gleich der neu berechneten ist.
Fertig, wenn: alle Tests zu TODO 5 ✓ zeigen. Lesen Sie die „Beobachtung“ am Ende von PaketTest.
return false.berechnePruefsumme(ohnePruefsumme()).Vor dem Vergleich: Ein Paket wurde unterwegs abgeschnitten. An welcher Ihrer Bedingungen scheitert es?
public boolean istGueltig() {
if (!kennung.equals("FN1")) {
return false;
}
if (seq < 0 || teil < 1 || gesamt < 1 || teil > gesamt) {
return false;
}
if (laenge != nutzdaten.length() || laenge > 60) {
return false;
}
return pruefsumme == berechnePruefsumme(ohnePruefsumme());
}Ein abgeschnittenes Paket hat weniger Nutzdaten, als das Längenfeld angibt (Bedingung 3); meist stimmt auch die Prüfsumme nicht. Die „Beobachtung“: Salmai statt Salami gilt als gültig – die Vertauschung aus Aufgabe 4.1 b (3).
gA: TODO 2 eA: TODO 3
Ziel: Ist ein Paket (nach dem Adressfilter) ungültig, wird es nicht verarbeitet. Die Station zählt es (defekt++) und schickt – wenn es an das eigene Rufzeichen ging und selbst keine Quittung ist – mit der fertigen Methode quittiere(p, "NAK") eine negative Quittung mit derselben Seq an den Absender.
Hilfe 3:
boolean istQuittung = p.getTyp().equals("ACK")
|| p.getTyp().equals("NAK");
if (!p.istGueltig()) {
defekt++;
if (an.equals(rufzeichen) && !istQuittung) {
// ...
}
return;
}Vor dem Vergleich: Was passiert, wenn Sie das NAK vor dem Adressfilter senden?
public void empfange(String text) {
Paket p = Paket.parse(text);
if (p == null) {
return;
}
String an = p.getEmpfaenger();
if (!an.equals(rufzeichen) && !an.equals("ALLE__")) {
return;
}
boolean istQuittung = p.getTyp().equals("ACK")
|| p.getTyp().equals("NAK");
if (!p.istGueltig()) {
defekt++;
println(" defekt: " + text, Color.lightcoral);
// nie auf Quittungen, nie auf Rundrufe
if (an.equals(rufzeichen) && !istQuittung) {
quittiere(p, "NAK");
}
return;
}
if (istQuittung) {
return;
}
verarbeite(p, p.getNutzdaten());
}Ohne Adressfilter davor würden alle Stationen fremde defekte Pakete reklamieren. Antworten auf Quittungen lösen ein endloses „Quittungs-Pingpong“ aus, auf einen Rundruf antworteten alle gleichzeitig.
Stellen Sie kanal.setFehler(30) ein (eA: station.getKanal().setFehler(30)) und testen Sie mit LOOPBACK und demo = true. Vergleichen Sie mit station.zeigeStatistik(): Wie viele Pakete hat der Kanal verfälscht, wie viele hat die Station als defekt erkannt? Kam eine verfälschte Bestellung unerkannt durch?
Die Zahl „defekt empfangen“ stimmt mit den verfälschten Paketen überein. Unerkannt kommt keines durch: Ein gekipptes Bit ändert den ASCII-Wert um 1, 2, 4, 8 oder 16 – ein einzelner Zeichenfehler wird immer erkannt. Vertauschungen erzeugt der Störkanal nicht. Der Sender bekommt das NAK, tut aber noch nichts damit: Die Bestellung fehlt.
Schreiben Sie in Paket eine Methode gewichtetePruefsumme(String s): \( \sum_i (i+1)\cdot \text{ASCII}(s_i) \bmod 997 \). Zeigen Sie mit zwei Tests in PaketTest, dass Salami und Salmai jetzt verschiedene Werte ergeben. Warum mod 997 und nicht mod 1000? Warum dürfen Sie FN/1 trotzdem nicht einfach im eigenen Programm ändern?
Für FN1ZENTRAKURIR1BST0070101015Pizza Salami x2 ergibt sich 193, mit Salmai 181: Vertauschte Zeichen stehen an Stellen mit anderem Gewicht. Mit mod 1000 kann ein Einzelfehler verschwinden: Gewicht 40 und Änderung 25 (A → Z) ergibt 1000 ≡ 0. 997 ist eine Primzahl größer als alle Gewichte und Änderungen, deshalb ist (Gewicht · Änderung) nie durch 997 teilbar. FN/1 ist eine Vereinbarung: Rechnet eine Station allein anders, hält sie jedes fremde Paket für verfälscht und umgekehrt. Nötig ist eine neue Version (Kennung FN2), die alle umsetzen.
Ausgezeichnet – Alle Aufgaben abgeschlossen!
Ihre Station erkennt verfälschte Pakete und reklamiert sie.
Sicherung
Eine Prüfsumme ist ein Kontrollwert, den der Sender aus den übertragenen Zeichen berechnet und mitschickt. Der Empfänger berechnet ihn neu; stimmen beide nicht überein, ist das Paket verfälscht. Eine negative Quittung (NAK) meldet dem Sender das.
Die Prüfsumme erkennt Fehler, sie korrigiert sie nicht. Sie erkennt nicht jeden Fehler (Vertauschungen nie). Sie schützt nicht vor absichtlicher Fälschung – wer fälscht, rechnet die Prüfsumme einfach neu. Ein fehlerkorrigierender Code wie Hamming(7,4) spart Rückfragen, kostet aber viel mehr Prüfbits.
Lesen Sie Ihre Festlegung aus dem Einstieg (Ja/Nein mit Beispiel). Stimmt sie? Ergänzen Sie ein Beispiel, das die Prüfsumme sicher erkennt, und eines, das sie nie erkennt.
Die Antwort lautet Nein. Kurier 1 hätte bei „Hasestr. 72“ die Prüfsumme 187 statt 181 berechnet, das Paket verworfen und mit NAK reklamiert. Bei „Hasestr. 21“ (Vertauschung) wäre er trotzdem falsch gefahren. Mit Hamming hätte er ein einzelnes gekipptes Bit selbst korrigiert, aber 1 → 7 kippt zwei Bits in einem Codewort – das korrigiert Hamming falsch.
Checkpoint_Kap4_Paket.java (vollständige Klasse Paket) und Checkpoint_Kap4_Station_gA.java bzw. Checkpoint_Kap4_Station_eA.java (mit NAK). Ab hier rechnen alle mit derselben, vollständigen Klasse Paket.
Kapitel 5: Verloren und doppelt
Worum es geht: Pakete verschwinden spurlos, Wiederholungen führen zu doppelten Lieferungen → Quittung, Timeout, Wiederholung und Duplikaterkennung (Stop-and-Wait).
Einstieg: Die verschwundene Bestellung
Dienstag, am Stadtrand reißt die Funkverbindung immer wieder ab: Jedes vierte Paket kommt gar nicht an. Aus den Logbüchern von ZENTRA und KURIR1:
| Zeit | Station | Ereignis | Funktext |
|---|---|---|---|
| 17:40:02 | ZENTRA | AUS | BST 040 Pizza Tonno, Iburger Str. 4 |
| ✗ – | KURIR1 | kein Eintrag, kein NAK, keine Antwort | – |
| 17:58:30 | – | Anruf von KUNDE3: „Wo bleibt meine Pizza?“ | – |
| 17:58:41 | ZENTRA | AUS (von Hand wiederholt) | BST 040 Pizza Tonno, Iburger Str. 4 |
| 17:58:41 | KURIR1 | EIN | BST 040 Pizza Tonno, Iburger Str. 4 |
| 18:01:15 | ZENTRA | AUS („sicherheitshalber“ noch einmal) | BST 040 Pizza Tonno, Iburger Str. 4 |
| ✗ 18:01:15 | KURIR1 | EIN → liefert zwei Pizzen Tonno | BST 040 Pizza Tonno, Iburger Str. 4 |
Leitfrage: Wie kann die Zentrale sicher erfahren, ob ihre Bestellung angekommen ist – ohne dass Kurier 1 doppelt liefert?
Nebenfragen:
- Warum hat die NAK-Regel aus Kapitel 4 hier nicht geholfen?
Rollenspiel (Dreiergruppen): Zentrale, Kanal (würfelt: bei einer 1 geht der Zettel verloren – auch ein Antwortzettel) und Kurier. Spielen Sie drei Bestellungen mit Ihrer Idee durch. Was passiert, wenn die Antwort verloren geht?
- Was soll der Empfänger nach jedem gültigen Paket tun? Was der Sender, wenn keine Antwort kommt?
- Woran erkennt der Kurier, dass ein Paket nur eine Wiederholung ist?
| Nr. | Plan-Punkt | Aufgabe |
|---|---|---|
| 1 | Abläufe mit Verlust als Sequenzdiagramm durchspielen, den Sender als Automaten beschreiben | 5.1, 5.2 |
| 2 | Empfänger: jedes gültige Paket mit ACK quittieren, Duplikate erkennen | 5.3 |
| 3 | Sender: auf ACK warten, nach Timeout oder NAK wiederholen, nach 5 Versuchen aufgeben | 5.4 gA / 5.5 eA |
| 4 | Mit Verlust und Fehlern testen | 5.4 c / 5.5 d |
Aufgaben: Abläufe beschreiben
Die Regeln von FN/1: Der Empfänger bestätigt jedes gültige Paket an ihn mit einer Quittung ACK mit derselben Seq. Der Sender wartet höchstens 2000 ms. Kommt bis dahin kein passendes ACK (Timeout) oder kommt ein NAK, sendet er dasselbe Paket erneut, höchstens fünfmal.
| Zeit | ZENTRA (Sender) | Kanal | KURIR1 (Empfänger) |
|---|---|---|---|
| 0 ms | sendet BST 40, wartet | → | |
| 30 ms | gültig, neu → verarbeiten, ACK 40 | ||
| 60 ms | ACK 40 passt → fertig | ← |
Zeichnen Sie die Abläufe; als Tabelle wie Tabelle 5.2 ist auch erlaubt.
BST 40 geht beim ersten Versuch verloren.
| Zeit | ZENTRA | Kanal | KURIR1 |
|---|---|---|---|
| ✗ 0 ms | sendet BST 40, wartet | → ✗ verloren | |
| 2000 ms | Timeout → BST 40 erneut (Versuch 2) | → | |
| 2030 ms | gültig, neu → verarbeiten, ACK 40 | ||
| 2060 ms | ACK 40 passt → fertig | ← |
Das ACK 40 geht beim ersten Mal verloren. Beschreiben Sie, woran KURIR1 das Duplikat erkennt und warum er es trotzdem quittieren muss.
Vor dem Vergleich: Vergleichen Sie mit dem Logbuch aus dem Einstieg. Welche Zeile entspricht dem Duplikat?
| Zeit | ZENTRA | Kanal | KURIR1 |
|---|---|---|---|
| 0 ms | sendet BST 40, wartet | → | |
| ✗ 30 ms | ✗ verloren ← | gültig, neu → verarbeiten, ACK 40 | |
| 2000 ms | Timeout → BST 40 erneut | → | |
| 2030 ms | gleicher Absender, gleiche Seq → Duplikat: nicht verarbeiten, aber ACK 40 | ||
| 2060 ms | ACK 40 passt → fertig | ← |
KURIR1 hat sich Absender ZENTRA und Seq 40 gemerkt. Ohne erneutes ACK würde ZENTRA bis zum fünften Versuch wiederholen und „Abbruch“ melden, obwohl die Bestellung längst angekommen ist.
BST 40 kommt beim ersten Mal verfälscht an.
| Zeit | ZENTRA | Kanal | KURIR1 |
|---|---|---|---|
| 0 ms | sendet BST 40, wartet | → verfälscht | |
| 30 ms | Prüfsumme falsch → NAK 40 | ||
| 60 ms | NAK 40 → BST 40 sofort erneut | ← / → | |
| 90 ms | gültig, neu → verarbeiten, ACK 40 | ||
| 120 ms | ACK 40 passt → fertig | ← |
Pakete brauchen wegen einer Störung 1500 ms je Richtung, der Timeout bleibt bei 2000 ms. Beschreiben Sie, was passiert, und schlagen Sie eine Regel für einen guten Timeout vor.
Das ACK kommt erst nach 3000 ms. Schon nach 2000 ms sendet ZENTRA erneut, KURIR1 erkennt ein Duplikat und quittiert noch einmal: unnötige Wiederholungen, doppelte Quittungen, mehr Last. Ein verspätetes ACK kann ankommen, während der Sender schon auf das nächste Paket wartet – deshalb der Seq-Vergleich. Regel: Timeout größer als die Rundlaufzeit (Hinweg + Verarbeitung + Rückweg), z. B. das Doppelte des gemessenen Höchstwerts. Zu lang ist auch schlecht: Verlorene Pakete werden spät wiederholt.
Der Sender reagiert auf Eingaben (SENDEN = neuer Auftrag, ACK = passendes gültiges ACK, NAK = passendes gültiges NAK, TIMEOUT) mit Ausgaben und wechselt den Zustand. Betrachtet wird ein Paket nach dem anderen.
Zeichnen Sie den Sender als Mealy-Automaten mit den Zuständen BEREIT und WARTET, Σ = {SENDEN, ACK, NAK, TIMEOUT} und Ω = {sende, wiederhole, fertig}. Die Grenze von 5 Versuchen lassen Sie weg. Geben Sie den Automaten vollständig an.
WARTET.BEREIT bei einem verspäteten ACK? Was in WARTET bei einem neuen Auftrag?BEREIT –SENDEN / sende→ WARTET, WARTET –ACK / fertig→ BEREIT, WARTET –TIMEOUT / wiederhole→ WARTET. Es fehlen fünf.| Zustand | SENDEN | ACK | NAK | TIMEOUT |
|---|---|---|---|---|
| BEREIT | sende → WARTET | ε → BEREIT | ε → BEREIT | ε → BEREIT |
| WARTET | ε → WARTET (Auftrag wartet) | fertig → BEREIT | wiederhole → WARTET | wiederhole → WARTET |
Ausgezeichnet – Alle Aufgaben abgeschlossen!
Sie können die Abläufe beschreiben.
Aufgaben: Quittieren und Duplikate erkennen
Der Empfänger quittiert und erkennt Duplikate. Dafür merkt er sich, was er von wem zuletzt bekommen hat.
Angenommen, die Zentrale merkt sich nur ein Paar letzterAbsender/letzteSeq. Bei ihr kommen nacheinander an: (1) KURIR1 POS 031, (2) KURIR2 POS 017, (3) KURIR1 POS 031 (Wiederholung, weil das ACK verloren ging). Notieren Sie nach jedem Paket die beiden Werte und ob (3) als Duplikat erkannt wird. Was muss sich die Station stattdessen merken?
letzterAbsender und letzteSeq?| Paket | letzterAbsender | letzteSeq | Duplikat? |
|---|---|---|---|
| (1) KURIR1 031 | KURIR1 | 31 | nein (neu) |
| (2) KURIR2 017 | KURIR2 | 17 | nein (neu) |
| ✗ (3) KURIR1 031 | KURIR1 | 31 | nicht erkannt, wird doppelt verarbeitet |
Ein einziges Paar reicht nur bei einem Gesprächspartner. Die Station merkt sich deshalb die letzte Seq je Absender: für jede Gegenstelle ein eigenes Objekt.
gA: TODO 3 eA: TODO 4, 5
Material: In Ihrer Station sind die Klasse Gegenstelle und die Methode finde(rufzeichen) fertig: finde sucht die Gegenstelle zum Rufzeichen in der Reihung gegenstellen und legt sie an, wenn es sie noch nicht gibt.
Ziel: Am Ende von empfange (nach der Gültigkeitsprüfung und nach if (istQuittung) { return; }):
- Jedes Paket an das eigene Rufzeichen mit
quittiere(p, "ACK")bestätigen – auch Duplikate. - Nur bei Paketen an das eigene Rufzeichen: Duplikat (gleiche Seq wie zuletzt von diesem Absender)? →
duplikate++, nicht verarbeiten. Sonst die Seq bei der Gegenstelle merken. - Danach verarbeiten. Rundrufe an
ALLE__werden weder quittiert noch auf Duplikate geprüft – sie werden nie wiederholt.
Fertig, wenn: die LOOPBACK-Demo ohne Fehler läuft. Duplikate testen Sie in Aufgabe 5.4 c bzw. 5.5 d.
Hilfe 2: Ergänzen Sie:
Letzte Seq von g = Seq von p und g.setLetzteSeq(Seq von p).Vor dem Vergleich: Warum startet letzteSeq mit −1 und nicht mit 0?
if (istQuittung) {
return;
}
if (an.equals(rufzeichen)) {
// immer quittieren, auch Duplikate
quittiere(p, "ACK");
// Duplikate nur bei Paketen an mich prüfen:
// Rundrufe werden nie wiederholt.
Gegenstelle g = finde(p.getAbsender());
if (g.getLetzteSeq() == p.getSeq()) {
duplikate++;
println(" Duplikat " + p.getSeq() + " verworfen",
Color.gray);
return;
}
g.setLetzteSeq(p.getSeq());
}
verarbeite(p, p.getNutzdaten());Mit Startwert 0 würde das allererste Paket (Seq 0) als Duplikat verworfen.
Eine Station stürzt ab und startet neu – wieder mit Seq 000. Ihr Partner hat sich von ihr zuletzt Seq 000 gemerkt. Was passiert? Wie kann onOtherClientDisconnected (kleines c) helfen?
Das erste neue Paket gilt als Duplikat: Es wird quittiert, aber nicht verarbeitet – eine Bestellung geht stillschweigend verloren. Abhilfe: Meldet sich eine Station ab, die Gegenstelle mit ihrem Rufzeichen aus gegenstellen löschen (delete). Ganz sicher ist das nicht, weil ein Absturz nicht immer als Abmeldung ankommt.
Ausgezeichnet – Alle Aufgaben abgeschlossen!
Ihr Empfänger quittiert zuverlässig.
Aufgaben: Stop-and-Wait programmieren gA
Das fertige Funkgerät legt jede ACK/NAK-Nachricht an Ihr Rufzeichen sofort in ein Quittungsfach – noch bevor es ins Logbuch schreibt, damit keine Quittung auf die Datenbank warten muss. funk.warteAufQuittung(int ms) wartet höchstens ms Millisekunden darauf und liefert den Funktext der Quittung oder "" (Timeout).
TODO 4
Ziel: Die Methode soll
psenden und mitfunk.warteAufQuittung(2000)auf eine Antwort warten,- bei einem gültigen
ACKmit der Seq vonptruezurückgeben, - sonst (NAK, Timeout, unbrauchbar) erneut senden – höchstens 5 Versuche, Wiederholungen in
wiederholungenzählen, - nach 5 Fehlversuchen
abgebrochen++undfalsezurückgeben.
Hilfe 2: Ergänzen Sie:
q != null && q.istGueltig() && q.getSeq() == p.getSeq() && q.getTyp().equals("ACK"). Wegen && wird q.istGueltig() nur aufgerufen, wenn q nicht null ist.Vor dem Vergleich: Ihre Lösung prüft die Seq der Quittung. Welcher Fall aus Aufgabe 5.1 d) ginge ohne diese Prüfung schief?
public boolean sendeZuverlaessig(Paket p) {
for (int versuch = 1; versuch <= 5; versuch++) {
if (versuch > 1) {
wiederholungen++;
}
println("-> " + p.beschreibung() + " (Versuch " + versuch + ")",
Color.lightblue);
funk.senden(p.toString());
Paket q = Paket.parse(funk.warteAufQuittung(2000));
if (q == null) {
println(" Timeout", Color.orange);
} else if (!q.istGueltig() || q.getSeq() != p.getSeq()) {
println(" Quittung unbrauchbar", Color.orange);
} else if (q.getTyp().equals("ACK")) {
println(" ACK", Color.green);
return true;
} else {
println(" NAK - sende erneut", Color.orange);
}
}
abgebrochen++;
return false;
}Ohne Seq-Vergleich könnte ein verspätetes ACK zum vorigen Paket das aktuelle „bestätigen“, obwohl es verloren ging.
Ordnen Sie die Teile des Automaten aus Aufgabe 5.2 der Methode sendeZuverlaessig zu: Wo ist der Zustand WARTET, wo der Übergang nach BEREIT, wo kommen die Eingaben TIMEOUT und NAK her? Was im Programm kommt im Automaten nicht vor?
Aufruf mit dem ersten funk.senden = SENDEN / sende (BEREIT → WARTET). Die Schleife ist der Zustand WARTET. warteAufQuittung liefert die Eingabe: "" = TIMEOUT, passendes NAK = NAK, passendes ACK = ACK. return true = ACK / fertig; ein neuer Durchlauf = wiederhole. Nicht im Automaten: der Zähler versuch, der Abbruch nach 5 Versuchen und unbrauchbare Quittungen (im Programm eine Wiederholung, im Automaten keine Eingabe).
Stellen Sie setVerlust(20) und setFehler(20) ein. Testen Sie mit LOOPBACK (demo = true), dann zu zweit in der Gruppen-Sitzung – beide Stationen mit Störkanal, denn auch Quittungen laufen hindurch. Senden Sie 20 Bestellungen und notieren Sie mit zeigeStatistik(): Wiederholungen, Duplikate, Abbrüche, Dauer.
Jede Bestellung wird beim Empfänger genau einmal verarbeitet; einige Duplikate werden erkannt (verlorene ACKs); viele Pakete brauchen 2–3 Versuche, Timeouts verlängern die Übertragung deutlich. Ein Abbruch ist selten (\(0{,}59^5 \approx 7\,\%\) je Paket). Kommt er vor, kann die Bestellung trotzdem angekommen sein – nur die ACKs gingen verloren.
Warum? Vor verarbeite steht synchronized
sendeZuverlaessig blockiert den aufrufenden Thread bis zu 10 s, und es gibt nur ein Quittungsfach. Ruft Ihre Abteilung später aus verarbeite heraus sende auf, dürfen nicht zwei Empfangs-Threads gleichzeitig darin sein – synchronized lässt immer nur einen Thread hinein. empfange selbst ist nicht synchronized: Sonst blieben eingehende Pakete während eines blockierenden sende unquittiert.
Messen Sie in sendeZuverlaessig mit System.currentTimeMillis() die Zeit vom Senden bis zum passenden ACK und geben Sie Mittelwert und Höchstwert in zeigeStatistik() aus. Welcher Timeout wäre in Ihrem Netz angemessen?
Vor funk.senden die Startzeit merken, bei return true die Differenz zu einer Summe und einem Zähler addieren, Höchstwert mitführen. Typisch sind im Schulnetz einige zehn bis wenige hundert Millisekunden; ein Timeout vom Doppelten des Höchstwerts ist deutlich kürzer als 2000 ms, macht das Netz aber anfälliger für Lastspitzen.
Ausgezeichnet – Alle Aufgaben abgeschlossen!
Ihre Station überträgt zuverlässig.
Aufgaben: Der Automat im Programm eA
Im eA-Gerüst wartet der Sender nicht in einer Schleife: Der Automat ist die Methode ereignis(String eingabe, int seq) mit dem Attribut zustand ("BEREIT"/"WARTET"). Neue Aufträge warten in der Queue sendepuffer.
| Eingabe | kommt von | Aufruf |
|---|---|---|
| SENDEN | sende(...) (fertig) | ereignis(„SENDEN“, -1) |
| ACK, NAK | empfange (Ihr Code) | ereignis(p.getTyp(), p.getSeq()) |
| TIMEOUT | Timer → pruefeTimeout() alle 100 ms | ereignis(„TIMEOUT“, -1) |
Die Ausgaben erledigen fertige Methoden: naechstesPaket() (sende bzw. fertig: nächstes Paket aus der Queue senden und WARTET, oder BEREIT, wenn die Queue leer ist) und wiederholeOderAbbrechen(grund) (wiederhole bzw. abbrechen). Mit Sendepuffer wird aus „ACK / fertig“ also „ACK / sende (nächstes)“, und der Automat bleibt in WARTET, solange Aufträge warten.
Erweitern Sie den Automaten aus Aufgabe 5.2 so, dass er nach dem fünften erfolglosen Versuch abbricht (Ausgabe „abbrechen“). Verwenden Sie nur Zustände, keinen Zähler. Wie viele Zustände brauchen Sie? Warum nutzt man im Programm trotzdem eine Zählvariable?
W1 (einmal gesendet) … W5.Zustände BEREIT, W1 … W5 (sechs), Ω = {sende, wiederhole, fertig, abbrechen}.
| Zustand | SENDEN | ACK | NAK oder TIMEOUT |
|---|---|---|---|
| BEREIT | sende → W1 | ε → BEREIT | ε → BEREIT |
| Wk (k = 1 … 4) | ε → Wk | fertig → BEREIT | wiederhole → W(k+1) |
| W5 | ε → W5 | fertig → BEREIT | abbrechen → BEREIT |
Für n Versuche braucht der Automat n + 1 Zustände. Ein endlicher Automat „zählt“ nur über Zustände; im Programm fasst man W1 … W5 zu WARTET mit der Zählvariablen versuche zusammen – kürzer und leicht änderbar.
Timer-Thread und Empfangs-Thread arbeiten gleichzeitig. Ergänzen Sie die letzte Zeile und markieren Sie den Konflikt.
| Zeit | Timer-Thread | Empfangs-Thread | aktuell |
|---|---|---|---|
| t1 | pruefeTimeout: WARTET, 2000 ms vorbei → gleich ereignis("TIMEOUT", -1) | – | Seq 40 |
| t2 | – | ACK 40: ereignis("ACK", 40) → naechstesPaket() sendet Seq 41 | Seq 41 |
| t3 | ereignis(„TIMEOUT“, -1) | – | ? |
aktuell?ereignis ankämen und beide versuche und aktuell ändern?In t3 bezieht sich der TIMEOUT auf Seq 40, behandelt würde aber Seq 41: Sie würde sofort wiederholt und ein Versuch verbraucht, obwohl gerade erst gesendet wurde. Abhilfe: ereignis prüft beim TIMEOUT die Zeit noch einmal (System.currentTimeMillis() - gesendetUm >= timeoutMs), sonst ε. Und ereignis ist synchronized: Immer nur ein Thread ist „im Automaten“, ACK und TIMEOUT können sich nicht vermischen.
TODO 6, 7
Ziel: Der ACK-Fall ist vorgegeben. Ergänzen Sie
- in
ereignis(TODO 6) die Fälle NAK und TIMEOUT im ZustandWARTET, pruefeTimeout(TODO 7) und den Timerstart am Ende vonverbinde,- in
empfange: gültige ACK/NAK an das eigene Rufzeichen mitereignis(p.getTyp(), p.getSeq())melden.
public synchronized void ereignis(String eingabe, int seq) {
if (zustand.equals("BEREIT")) {
if (eingabe.equals("SENDEN")) {
// sende -> WARTET (oder BEREIT, wenn leer)
naechstesPaket();
}
// ACK, NAK, TIMEOUT: ε
} else if (zustand.equals("WARTET")) {
if (eingabe.equals("ACK") && seq == aktuell.getSeq()) {
// fertig bzw. nächstes Paket
naechstesPaket();
}
// TODO 6: NAK mit passender Seq -> wiederholen
// TODO 6: TIMEOUT, wenn die Zeit wirklich um ist
// SENDEN, unpassende Quittung: ε
}
}seq == aktuell.getSeq() – sonst ε. Welche fertige Methode erledigt „wiederhole“?Hilfe 2: Timer starten (am Ende von verbinde):
Station ich = this;
Timer.repeat(() -> { ich.pruefeTimeout(); }, 100);Hilfe 3: Beim TIMEOUT in ereignis:
} else if (eingabe.equals("TIMEOUT")
&& System.currentTimeMillis() - gesendetUm >= timeoutMs) {
wiederholeOderAbbrechen("Timeout");
}Vor dem Vergleich: Nennen Sie für jede Zeile Ihres ereignis den Übergang aus Ihrem Automaten (Aufgabe 5.2).
} else if (eingabe.equals("NAK") && seq == aktuell.getSeq()) {
wiederholeOderAbbrechen("NAK");
} else if (eingabe.equals("TIMEOUT")
&& System.currentTimeMillis() - gesendetUm
>= timeoutMs) {
wiederholeOderAbbrechen("Timeout");
}
public void pruefeTimeout() {
if (zustand.equals("WARTET")
&& System.currentTimeMillis() - gesendetUm >= timeoutMs) {
ereignis("TIMEOUT", -1);
}
}
// in empfange nach der Gültigkeitsprüfung:
if (istQuittung) {
if (an.equals(rufzeichen)) {
ereignis(p.getTyp(), p.getSeq());
}
return;
}Im Unterschied zur gA-Lösung blockiert das Hauptprogramm nicht: Die Station empfängt während des Wartens weiter und nimmt neue Aufträge an (sie warten im Sendepuffer). Die Grenze von fünf Versuchen steckt in wiederholeOderAbbrechen (Zähler versuche, vgl. Teil a).
Testen Sie wie in Aufgabe 5.4 c) – erst LOOPBACK, dann zu zweit, beide mit setVerlust(20) und setFehler(20). Senden Sie mehrere Bestellungen direkt nacheinander. Was zeigt die Statistik? Was fällt beim Senden im Vergleich zur gA-Station auf?
Wie bei gA: jede Bestellung genau einmal verarbeitet, Duplikate erkannt, seltene Abbrüche. Zusätzlich: Neue Aufträge lassen sich sofort eingeben, sie warten im Sendepuffer und gehen nacheinander hinaus.
Meldet der Sender „Abbruch“, war die Bestellung vielleicht doch da. Kann irgendein Protokoll über einen Kanal, der Nachrichten verlieren kann, erreichen, dass beide Seiten sicher wissen, dass die Nachricht angekommen ist? Begründen Sie.
Nein. Der Empfänger weiß nach dem ACK nicht, ob das ACK ankam; eine Quittung auf die Quittung hätte dasselbe Problem – die letzte Nachricht ist immer unbestätigt (Problem der zwei Armeen). Protokolle machen Fehler nur unwahrscheinlich und begrenzen den Schaden (Duplikaterkennung, Abbruchmeldung, Nachfragen beim Kunden).
Ausgezeichnet – Alle Aufgaben abgeschlossen!
Ihr Sender ist ein ereignisgesteuerter Automat.
Sicherung
Bei Stop-and-Wait schickt der Sender ein Paket und wartet auf dessen Quittung. Bei ACK mit passender Seq sendet er das nächste, bei NAK oder Timeout dasselbe erneut (höchstens 5 Versuche). Der Empfänger quittiert jedes gültige Paket – auch Duplikate –, verarbeitet aber jedes nur einmal.
Quittungen tragen die Seq des bestätigten Pakets, sonst bestätigt ein verspätetes ACK das falsche Paket. Duplikate erkennt der Empfänger an Absender und Seq. Ein einziges Paar letzterAbsender/letzteSeq reicht nur bei einem Gesprächspartner; im Liefernetz merkt sich die Station die Seq je Gegenstelle.
TCP nutzt dieselben Ideen – Sequenznummern, Quittungen, Timeout, Wiederholung, Prüfsumme –, schickt aber mehrere Pakete, bevor die Quittungen zurückkommen. Unser WebSocket läuft selbst über TCP und ist eigentlich zuverlässig; der StoerKanal bildet einen echten Funkkanal nach.
Lesen Sie Ihre Idee aus dem Einstieg. Was davon steckt in Stop-and-Wait? Was hatten Sie nicht bedacht (z. B. verlorene Quittung)?
Mit Stop-and-Wait hätte die Zentrale nach 2 Sekunden ohne ACK wiederholt – nicht erst nach dem Anruf um 17:58 Uhr. Die zweite Sendung „sicherheitshalber“ wäre nicht nötig gewesen; und wäre sie doch gekommen, hätte Kurier 1 sie an Absender ZENTRA und Seq 040 als Duplikat erkannt, erneut quittiert und nur eine Pizza Tonno geliefert. Die NAK-Regel half nicht, weil ein verlorenes Paket keine Antwort erzeugt.
Checkpoint_Kap5_Station_gA.java bzw. Checkpoint_Kap5_Station_eA.java (Stop-and-Wait, Duplikate je Gegenstelle). Wer hier einsteigt, bearbeitet Kapitel 6 mit diesem Stand.
Kapitel 6: Die Großbestellung
Worum es geht: Eine Bestellung ist länger als 60 Zeichen → Fragmentierung: zerlegen, nummerieren, wieder zusammensetzen – auch wenn unterwegs etwas schiefgeht.
Einstieg: Die Großbestellung
Das GSG feiert sein Schulfest. Die Zentrale schickt Kurier 1 diese Bestellung (137 Zeichen):
Schulfest GSG: 12x Pizza Margherita, 8x Pizza Salami, 5x Pizza Tonno, 10x Cola, 10x Wasser. Lieferung 11:30 an Hausmeister, Seiteneingang
Bildschirm der Zentrale:
-> [BST 058 1/1 ZENTRA->KURIR1] Schulfest GSG: ... (Versuch 1) NAK - sende erneut -> [BST 058 1/1 ZENTRA->KURIR1] Schulfest GSG: ... (Versuch 2) NAK - sende erneut ... Abbruch: KURIR1
Till schlägt vor: „Dann erlauben wir eben 200 Zeichen.“
Leitfrage: FN/1 hat die Felder Teil und Gesamt. Reichen sie, damit Kurier 1 eine zerlegte Bestellung immer richtig zusammensetzt? Legen Sie sich fest und nennen Sie einen Fall, der schiefgehen könnte.
Nebenfragen:
- Warum lehnt Kurier 1 das Paket ab, obwohl kein Zeichen verfälscht ist – und warum ist Tills Vorschlag keine gute Idee?
- Welche Felder haben wir bisher immer mit
01gefüllt? - Was kann mit Teilpaketen passieren: fehlen, doppelt kommen, überholen, sich mit Teilen eines anderen Senders mischen?
| Nr. | Plan-Punkt | Aufgabe |
|---|---|---|
| 1 | Die Bestellung von Hand in Teilpakete zerlegen | 6.1 a |
| 2 | zerlege: Stücke zu höchstens 60 Zeichen, Teil/Gesamt, eigene Seq | 6.1 b |
| 3 | setzeZusammen und Puffer in empfange | 6.1 c, d |
| 4 | Kritische Fälle prüfen (fehlt, doppelt, Reihenfolge, zwei Sender) | Plan-Check, Challenge |
Länge 137 > 60: istGueltig() lehnt ab, der Kurier antwortet mit NAK. Tills Vorschlag bräche FN/1 – alle anderen Stationen müssten geändert werden. Außerdem gehen lange Pakete häufiger kaputt.
Aufgaben: Lange Nachrichten zerlegen
Der Sender zerlegt, der Empfänger setzt zusammen. gA und eA schreiben denselben Code (eA ohne TODO-Nummern).
Material: Ihre Station.java. Signaturen:
Zerlegen Sie die Schulfest-Bestellung in FN/1-Pakete von ZENTRA an KURIR1 (erste Seq: 20). Für die Teile 1 und 2 genügen Seq, Teil, Gesamt und Länge; Teil 3 schreiben Sie vollständig (Prüfsumme ???). Wie viele Zeichen werden insgesamt übertragen (ohne Quittungen)?
Übertragen werden 3 · 31 + 137 = 230 Zeichen; Nutzanteil 137/230 ≈ 60 %.
gA: TODO 5 eA: ohne TODO-Nummer
Ziel: Der Text wird in Stücke von höchstens 60 Zeichen zerlegt. Jedes Stück wird ein Paket mit Teil i + 1, Gesamt = Anzahl der Stücke und einer eigenen Seq (naechsteSeq, danach erhöhen, nach 999 folgt 0). Auch ein leerer Text ergibt ein Paket. Fertig, wenn: die Demo die lange Bestellung als drei Pakete sendet.
(text.length() + 59) / 60. Was ergibt das für 137, für 60, für 0?Hilfe 2: Ergänzen Sie:
public DynArray zerlege(String empfaenger, String typ,
String text) {
DynArray liste = new DynArray();
int anzahl = (text.length() + 59) / 60;
if (anzahl == 0) {
// auch leerer Text ergibt ein Paket
anzahl = 1;
}
for (int i = 0; i < anzahl; i++) {
int von = i * 60;
int bis = von + 60;
if (bis > text.length()) {
bis = text.length();
}
Paket p = new Paket(rufzeichen, empfaenger, typ, naechsteSeq,
i + 1, anzahl, text.substring(von, bis));
naechsteSeq = (naechsteSeq + 1) % 1000;
liste.append(p);
}
return liste;
}Grenze: Teil und Gesamt sind zweistellig – höchstens 99 Teile, also 5940 Zeichen.
gA: TODO 6 eA: ohne TODO-Nummer
Ziel: Die Teile liegen in beliebiger Reihenfolge in der Reihung. Die Methode hängt ihre Nutzdaten in der Reihenfolge der Teilnummern aneinander.
t von 1 bis Gesamt das passende Paket und hängen Sie seine Nutzdaten an.getItem/setItem) nach der Teilnummer und verketten Sie dann der Reihe nach.Object: Paket t = (Paket) liste.getItem(i);t von 1 bis Gesamt, innere Schleife sucht das Paket mit getTeil() == t. Gesamt steht in jedem Paket, z. B. im ersten.getTeil().Vor dem Vergleich: Was liefert Ihre Methode für eine leere Reihung?
public String setzeZusammen(DynArray liste) {
if (liste.isEmpty()) {
return "";
}
int gesamt = ((Paket) liste.getItem(0)).getGesamt();
String text = "";
for (int t = 1; t <= gesamt; t++) {
for (int i = 0; i < liste.getLength(); i++) {
Paket p = (Paket) liste.getItem(i);
if (p.getTeil() == t) {
text = text + p.getNutzdaten();
}
}
}
return text;
}public String setzeZusammen(DynArray liste) {
for (int i = 1; i < liste.getLength(); i++) {
Paket akt = (Paket) liste.getItem(i);
int j = i - 1;
while (j >= 0
&& ((Paket) liste.getItem(j)).getTeil() > akt.getTeil()) {
liste.setItem(j + 1, liste.getItem(j));
j--;
}
liste.setItem(j + 1, akt);
}
String text = "";
for (int i = 0; i < liste.getLength(); i++) {
text = text + ((Paket) liste.getItem(i)).getNutzdaten();
}
return text;
}gA: TODO 5/6 in empfange eA: in empfange, ohne TODO-Nummer
Ziel: Am Ende von empfange (nach der Duplikatprüfung): Ist gesamt gleich 1, wird das Paket wie bisher verarbeitet. Sonst kommt es in den Puffer teile; bei Teil 1 wird teile vorher neu angelegt. Sind so viele Teile gesammelt, wie Gesamt angibt: zusammensetzen, verarbeiten, Puffer leeren. Fertig, wenn: die Schulfest-Bestellung mit LOOPBACK und dann mit setVerlust(20) zu zweit als eine Nachricht erscheint.
// am Ende von empfange (nach der Duplikatprüfung):
if (p.getGesamt() == 1) {
verarbeite(p, p.getNutzdaten());
return;
}
if (p.getTeil() == 1) {
// neue Nachricht beginnt
teile = new DynArray();
}
teile.append(p);
if (teile.getLength() == p.getGesamt()) {
String ganz = setzeZusammen(teile);
teile = new DynArray();
verarbeite(p, ganz);
} else {
println(" Teil " + p.getTeil() + "/" + p.getGesamt()
+ " gepuffert", Color.gray);
}Bricht der Sender bei einem Teil ab, bleibt der Puffer unvollständig; mit dem nächsten Teil 1 wird er verworfen.
Die Zentrale sendet Teile ohne zu warten nacheinander, mit setVerzoegerung(1500) – Teil 3 kann vor Teil 1 ankommen. Ändern Sie den Empfänger: Der Puffer wird nicht bei Teil 1 geleert, ein schon vorhandener Teil wird nicht noch einmal aufgenommen, und der Puffer bleibt nach Teilnummer sortiert (insertAt). Was passiert, wenn zwei Stationen gleichzeitig lange Nachrichten an Sie senden? Schlagen Sie eine Lösung vor.
insertAt mit Index = Länge). Gleiche Teilnummer = Duplikat.private void nimmAuf(Paket p) {
int i = 0;
while (i < teile.getLength()
&& ((Paket) teile.getItem(i)).getTeil() < p.getTeil()) {
i = i + 1;
}
if (i < teile.getLength()
&& ((Paket) teile.getItem(i)).getTeil() == p.getTeil()) {
// Teil schon vorhanden: Duplikat
return;
}
teile.insertAt(i, p);
if (teile.getLength() == p.getGesamt()) {
String ganz = setzeZusammen(teile);
teile = new DynArray();
verarbeite(p, ganz);
}
}Bei zwei Sendern landen Teile verschiedener Nachrichten im selben Puffer und werden vermischt. Lösung: je Absender ein eigener Puffer – als Attribut von Gegenstelle – oder ein Kopffeld „Nachrichtennummer“ (eine Formatänderung FN/2, die alle vereinbaren müssten). Ohne Quittungen fehlt ein verlorener Teil für immer.
Ausgezeichnet – Alle Aufgaben abgeschlossen!
Lange Nachrichten kommen vollständig an.
Sicherung
Bei der Fragmentierung wird eine Nachricht, die länger als die erlaubte Nutzdatenlänge ist, in nummerierte Teilpakete (Teil x von Gesamt) zerlegt. Der Empfänger sammelt sie und setzt sie nach der Teilnummer zusammen.
Jedes Paket kostet in FN/1 31 Verwaltungszeichen (Overhead). Zuverlässigkeit kostet zusätzlich Quittungen, Wartezeit und Wiederholungen. Teil/Gesamt genügen nur, weil Stop-and-Wait die Teile eines Senders nacheinander und ohne Duplikate liefert.
Erstens: Prüfen Sie Ihre Festlegung zur Leitfrage. Welcher kritische Fall wird durch Stop-and-Wait abgefangen, welcher nicht?
Zweitens – Rückblick auf den ganzen Kern: Ergänzen Sie für jedes Problem aus dem Funkchaos, wodurch FN/1 und Ihre Station es lösen. Beantworten Sie damit die Leitfrage der Einheit.
| Problem aus dem Funkchaos (Kap. 1) | Lösung |
|---|---|
| „Ist das für mich?“, „Wer hat das gesendet?“ | |
| „Bestellung, Antwort oder Zahlung?“ | |
| „Ich – ich auch!“, „OK“ ohne Bezug | |
| Bestellung doppelt | |
| Adresse verfälscht | |
| Bestellung verschwunden | |
| Lange Bestellung abgeschnitten | |
| Zahlungen für alle lesbar, Absender fälschbar |
Wie es weitergeht: In den Abteilungen bekommt jede Gruppe eine Aufgabe im Liefernetz (Zentrale, Kurier, Kundenverzeichnis, Kasse, Funkstrecke, Bestellstatus, Logbuch). Die Nutzdaten erhalten dann feste Formate, z. B. eine Bestellung KKKKP Text (Kundennummer, Priorität, Bestelltext). Die Logik Ihrer Abteilung kommt in verarbeite.
Teil/Gesamt reichen nicht immer: Fehlt ein Teil, bleibt die Nachricht unvollständig; überholen sich Teile oder senden zwei Stationen gleichzeitig, mischt ein einfacher Puffer sie. Stop-and-Wait verhindert Überholen und Duplikate bei einem Sender; für mehrere Sender braucht man einen Puffer je Absender.
| Problem | Lösung |
|---|---|
| „Ist das für mich?“ / „Wer?“ | Empfänger und Absender im Kopf, Adressfilter (Kap. 3) |
| „Bestellung, Antwort oder Zahlung?“ | Typfeld (Kap. 2) |
| „OK“ ohne Bezug | Seq; Quittungen tragen die Seq (Kap. 5) |
| Bestellung doppelt | Duplikaterkennung über Absender und Seq (Kap. 5) |
| Adresse verfälscht | Prüfsumme, NAK (Kap. 4) |
| Bestellung verschwunden | ACK, Timeout, Wiederholung (Kap. 5) |
| abgeschnitten | Längenfeld (Kap. 2), Fragmentierung (Kap. 6) |
| Zahlungen lesbar, Absender fälschbar | noch offen → Abteilung Kasse |
Die Leitfrage der Einheit: Eindeutig wird die Verständigung durch ein gemeinsames Format, zuverlässig durch Prüfsumme, Quittungen und Wiederholung. Die Regeln legt eine Vereinbarung fest, die alle genau gleich umsetzen – ändert eine Station sie allein, versteht sie niemand mehr.
Checkpoint_Kap6_Station_gA.java bzw. Checkpoint_Kap6_Station_eA.java – die vollständige Station. Sie ist der Ausgangspunkt aller Abteilungen.
Abteilungen: Überblick
Worum es geht: FN/1 bringt Pakete sicher ans Ziel – aber noch keine Pizza zur Kundschaft. → Sie teilen das Liefernetz in Abteilungen auf, vereinbaren, was in den Nutzdaten steht, und bauen jede Abteilung als eigene Station.
Einstieg: Die Probe vor dem ersten Abend
Ihr Protokoll FN/1 funktioniert: Zwei Stationen tauschen Pakete aus, erkennen verfälschte Pakete an der Prüfsumme, quittieren mit ACK und wiederholen verlorene Pakete. Die Geschäftsleitung von Food Now! plant den ersten echten Abend mit dem Liefernetz. Bei der Probe hört der Lausch-Client Folgendes (Quittungen weggelassen):
19:02:11 KUNDE1 → ZENTRA BST 00423 2xPIZZA,1xCOLA
19:02:14 KUNDE1 → ZENTRA BST 08151 1xBURGER
19:02:19 ZENTRA → ALLE__ BST 2xPIZZA,1xCOLA liefern!!
19:02:20 ZENTRA → ALLE__ BST 1xBURGER auch!!
19:03:40 ZENTRA → ALLE__ STA wo wohnt Kunde 0042?
19:09:12 KURIR1 → ALLE__ STA welcher Weg??
19:21:55 KURIR1 → ALLE__ ZAH 19,50 EUR KUNDE 0042 KARTE
19:22:30 PIZPAR → ALLE__ ZAH 6,90 EUR KUNDE 0815 BAR
// PIZPAR = Pizza Paradiso, die KonkurrenzDie Zentrale weiß nicht, wo Kunde 0042 wohnt. Der eilige Burger (Priorität 1) wartet hinter der Pizza. Der Kurier hat keinen Stadtplan und findet den Rückweg nicht. Jede Station liest die Zahlungen mit, und die Konkurrenz meldet eine Zahlung, die es nie gab. Hinterher kann niemand sagen, wie lange die Lieferung gedauert hat.
Leitfrage: Welche Aufgaben muss das Liefernetz außer dem Transport von Paketen noch erledigen – und welche Stationen („Abteilungen“) braucht Food Now! dafür?
Nebenfragen:
- Welche Fachinhalte aus der Q-Phase helfen jeweils?
- Was müssen zwei Abteilungen miteinander vereinbaren, bevor sie programmieren?
Sammeln Sie im Kurs in drei Spalten: Problem im Mitschnitt → zuständige Abteilung → offene Frage.
- Gehen Sie den Mitschnitt Zeile für Zeile durch und notieren Sie zu jeder Zeile das Problem.
- Fassen Sie Probleme zusammen, die dieselbe Abteilung lösen könnte. Geben Sie jeder Abteilung einen Namen und ein Rufzeichen mit genau sechs Zeichen.
- Zeichnen Sie mit Pfeilen, welche Abteilung welcher anderen welche Pakete schickt.
- Zentrale (Bestellungen verwalten), Kurier und Kartendienst (Weg finden), Kundenverzeichnis (Adressen), Kasse (Zahlungen verschlüsseln und buchen), Bestellstatus (Ablauf überwachen), Logbuch (Funkverkehr auswerten, Datenschutz), eA zusätzlich Funkstrecke (verrauschte Außenverbindung).
- FN/1 regelt, wie Pakete transportiert werden. Was in den Nutzdaten steht (Adresse, Karte, Zahlung, Status), müssen die Abteilungen zusätzlich vereinbaren – ein Protokoll über dem Protokoll, die Anwendungsschicht.
- Die genaue Aufteilung zeigt der Aufklapper „Die Abteilungen im Überblick“ unten.
So arbeiten die Abteilungen
Jede Gruppe (2–4 Personen) übernimmt eine Abteilung und baut sie als eigene Station. Im Go-Live arbeiten alle Stationen in einer gemeinsamen Sitzung zusammen.
Die Abteilungen im Überblick (erst nach der Kursdiskussion öffnen)
| Abteilung | Rufzeichen | Aufgabe im Liefernetz | Fachthemen |
|---|---|---|---|
| Zentrale | ZENTRA | nimmt Bestellungen an, fragt Adressen ab, verteilt Aufträge | Queue, DynArray, Einfügesortierung; eA Vererbung, Fairness |
| Kurier | KURIR1 …, KARTE1 | holt den Stadtplan, fährt aus, kassiert, fährt zurück | 2D-Array, Stack, RLE, Huffman-Vergleich; eA Backtracking |
| Kundenverzeichnis | KUNDEN | beantwortet Adressanfragen | binärer Suchbaum, Datenschutz; eA Löschen, Ausgleichen |
| Kasse | KASSE1 | entschlüsselt Zahlungen, führt das Kassenbuch | Vigenère, bekannter Klartext; eA Diffie-Hellman, Signatur, RSA-Idee |
| Funkstrecke eA | RELAIS, AUSSEN | verbindet die Außenfiliale über eine verrauschte Strecke | Hamming(7,4), Huffman-Baum |
| Bestellstatus | STATUS | verfolgt jede Bestellung, warnt bei unzulässigen Abläufen | Mealy-Automat, DEA; eA Grammatik, Kellerautomat |
| Logbuch | LOGBUC | richtet die Datenbank ein, wertet aus, wacht über den Datenschutz | SQL, Datenschutz; eA ER-Modell, PreparedStatement |
Dazu kommen Stationen der Lehrkraft: KUNDE1 (die Kundschaft), der Lausch-Client am Beamer und im eA-Go-Live die Konkurrenz PIZPAR.
| Abteilung | braucht von … | liefert an … |
|---|---|---|
| Zentrale | Kundenverzeichnis: Lage der Adresse (ADR); Kurier: Meldung „frei“ (POS); eA Bestellstatus: Prüfung von Bestelltexten | Kundenverzeichnis: Anfrage; Kurier: Lieferauftrag (BST); alle: STA mit ANN, KOC, STO; eA Funkstrecke: Aufträge für Hasbergen |
| Kurier | Zentrale: Lieferauftrag; Kartendienst: Stadtplan (KRT); Kasse: Zahlungsformat, Schlüssel, Klasse Zahlung | Zentrale: POS; Kasse: ZAH; alle: STA mit ABH, LIE |
| Kundenverzeichnis | Zentrale: Anfrageformat; Lehrkraft: Kundenliste | Zentrale: Lage der Lieferadresse |
| Kasse | Kurier: ZAH im vereinbarten Format; eA KEY-Austausch | Kurier: Schlüsselregel, Klassen Kasse und Zahlung |
| Funkstrecke eA | Zentrale: Aufträge für Hasbergen | alle: STA mit ABH, LIE der Außenfiliale |
| Bestellstatus | Zentrale, Kurier: STA mit den vereinbarten Codes | alle: Anzeigetafel, Warnungen; eA Zentrale: Klasse Bestellstatus |
| Logbuch | alle: Einträge in die Tabelle logbuch | alle: Datenbank, Zugangscode, Datenschutzregeln, Auswertung |
| Nr. | Von → An | Typ | Nutzdaten | Bedeutung |
|---|---|---|---|---|
| 0 | KURIR1 → KARTE1 | KRT | (leer) | Kurier fordert den Stadtplan an |
| 0 | KARTE1 → KURIR1 | KRT | Kartenzeilen, RLE | Stadtplan |
| 0 | KURIR1 → ZENTRA | POS | laut Vertrag | Kurier steht an der Zentrale und ist frei |
| 1 | KUNDE1 → ZENTRA | BST | 00423 2xPIZZA,1xCOLA | Kunde 0042, Priorität 3, Bestelltext |
| 2 | ZENTRA → ALLE__ | STA | 017ANN | Bestellung 017 angenommen |
| 3 | ZENTRA → KUNDEN | ADR | laut Vertrag | Wo wohnt Kunde 0042? |
| 4 | KUNDEN → ZENTRA | ADR | laut Vertrag | Lage im Stadtplan |
| 5 | ZENTRA → ALLE__ | STA | 017KOC | wird gekocht, wartet auf einen Kurier |
| 6 | ZENTRA → KURIR1 | BST | laut Vertrag | Lieferauftrag |
| 7 | KURIR1 → ALLE__ | STA | 017ABH | abgeholt |
| 8 | KURIR1 → ALLE__ | STA | 017LIE | geliefert |
| 9 | KURIR1 → KASSE1 | ZAH | laut Vertrag | Zahlung, verschlüsselt |
| 10 | KURIR1 → ZENTRA | POS | laut Vertrag | zurück und wieder frei |
„Laut Vertrag“ heißt: Dieses Format entwirft Ihr Kurs selbst in der Schnittstellenkonferenz.
Wahl der Abteilung
- Abteilungsmarkt: Lesen Sie die Kurzsteckbriefe (Tabelle Ü4). Die Sterne zeigen den Programmieranteil.
- Wahlzettel: Jede Gruppe gibt einen Erst-, Zweit- und Drittwunsch mit je einem Satz Begründung ab.
- Zuteilung durch die Lehrkraft: Jede Pflichtabteilung wird genau einmal besetzt (gA: Zentrale, Kurier, Kundenverzeichnis, Kasse, Bestellstatus, Logbuch; eA zusätzlich Funkstrecke). Nur so braucht der Kurs alle Themen der Q-Phase. Weitere Gruppen werden weitere Kurier-Gruppen (
KURIR2,KURIR3). - Rollen in der Gruppe (Wechsel an jedem Meilenstein): Protokollverantwortliche/r (führt das Protokollblatt, vertritt die Gruppe in der Schnittstellenkonferenz), Modulentwickler/in (Fachalgorithmus), Stationsentwickler/in (Anbindung, Test). Jede Person muss am Ende jeden Teil erklären können.
| Abteilung | Problem in einem Satz | Fachthemen | Anspruch |
|---|---|---|---|
| Zentrale | Der eilige Burger wartet hinter der Pizza, Antworten gehen durcheinander. | Queue, DynArray, Sortieren | ★★★ |
| Kurier | Der Stadtplan braucht neun Pakete, und Kim findet nicht zurück. | 2D-Array, Stack, RLE, Huffman | ★★☆ |
| Kundenverzeichnis | 4 000 Kunden in einer Liste, und Pizza Paradiso hört Namen mit. | Suchbaum, Rekursion, Datenschutz | ★★☆ |
| Kasse | Alle lesen die Zahlungen mit – auch verschlüsselt. | Vigenère, Kryptoanalyse | ★★☆ |
| Funkstrecke eA | Jedes hundertste Bit kippt, Wiederholen hilft nicht. | Hamming, Huffman, Binärbaum | ★★★ |
| Bestellstatus | „Geliefert“, bevor „abgeholt“ – und niemand merkt es. | Mealy-Automat, DEA | ★★☆ |
| Logbuch | Wer hat recht – und was darf das Logbuch speichern? | SQL, Datenschutz | ★★☆ |
Meilensteine
- M1 Entwurf: Plan-Ticket gezeigt, Protokollblatt v0.1, Schnittstellenvertrag unterschrieben.
- M2 Modul: Ihre Modulklasse besteht den Selbsttest ohne Netz.
- M3 Station: Schnittstellentest mit der Partnerabteilung bestanden, Protokollblatt v1.0.
- eA M4 Erweiterung: eA-Aufgaben implementiert und getestet.
- eA M5 Integrationsprobe: Probelauf mit mindestens zwei Partnerabteilungen ohne Absturz, Protokollblatt v2.0.
Die Schnittstellenkonferenz
Erst plant jede Gruppe ihre Abteilung (Einstieg, Plan-Ticket, erster Entwurfsteil). Dann trifft sich der Kurs. Jede Gruppe bringt einen Angebotszettel mit: Welche Pakettypen bietet sie an, welche braucht sie? Für jedes angebotene Paket: Format v0.1 als Formattabelle mit einem Beispiel.
- Wer ein Paket anbietet, entwirft dessen Nutzdatenformat, soweit es nicht fest vorgegeben ist (Tabelle Ü5). Das Kundenverzeichnis entwirft die
ADR-Antwort, die Zentrale den Lieferauftrag, die Kasse den Klartext der Zahlung, der KurierPOS. - Wer es nutzt, prüft den Entwurf auf Eindeutigkeit und unterschreibt im Schnittstellenvertrag (Typ, Anbieter, Nutzer, Format mit Positionen, Beispiel, Version).
- Änderungen nach der Unterschrift nur mit neuer Versionsnummer und Zustimmung aller Nutzer.
- Ein eigener Pakettyp (z. B.
ADR,BIT) ist erlaubt, muss aber im Protokollblatt dokumentiert und mit allen Partnern ausgehandelt werden. Kopf und Prüfsumme von FN/1 bleiben unverändert. - Gibt es am Ende der ersten Stunde für ein Paket keinen unterschriebenen Vertrag, gibt die Lehrkraft für dieses Paket ein Referenzformat (Plan B) aus. So wartet keine Gruppe auf eine andere. Wer Plan B übernimmt, kennzeichnet das im Protokollblatt und begründet, warum es zu den eigenen Bedingungen passt.
| Was | Festlegung |
|---|---|
| Paketformat | FN/1 (Kopf 28 Zeichen, höchstens 60 Zeichen Nutzdaten, Prüfsumme mod 1000), messageType immer "FN1"; Rundrufe an ALLE__ werden nicht quittiert |
Bestellungen von KUNDE1 (BST) | KKKKP Text: Position 0–3 Kundennummer, Position 4 Priorität (1 = eilig … 3 = normal; eA 0 = Medikament), Position 5 Leerzeichen, ab Position 6 Bestelltext |
| Bestelltext | Positionen durch Komma getrennt, je Position Anzahl (1–9), x, Gericht in Großbuchstaben, z. B. 2xPIZZA,1xCOLA; nur ASCII, keine Umlaute. eA Menüs mit verschachtelten Klammern, z. B. 1xMENUE(PIZZA(SALAMI,KAESE),COLA) |
Stadtplan (KRT) | Anforderung mit leeren Nutzdaten; Antwort: Kartenzeilen mit / verbunden, dann lauflängencodiert (Anzahl-Wert) |
Statusmeldungen (STA) | an ALLE__; NNNCCC: dreistellige Bestellnummer, dann Code ANN angenommen, KOC in Zubereitung, ABH abgeholt, LIE geliefert, STO storniert; z. B. 017LIE |
| Bestellnummern | vergibt die Zentrale, dreistellig 001–999 |
| Sitzungscodes | FN-<Kurs>-<Gruppe> für Gruppentests, FN-<Kurs>-TEST für Tests mit den Ersatzstationen der Lehrkraft, FN-<Kurs>-LIVE fürs Go-Live |
Bedingungskarten
Jede Gruppe erhält eine von zwei (Kurier: drei) Bedingungskarten ihrer Abteilung. Die Bedingungen sorgen dafür, dass Sie nicht nachbauen, sondern selbst entwerfen: Sie planen eine Lösung, die genau diese Bedingungen erfüllt, und begründen Ihre Entscheidungen im Protokollblatt. Ihre Karte steht im Kapitel Ihrer Abteilung.
Schnittstelle zur Station
Alle Abteilungen bauen auf der Station aus dem Kern auf. Die Abteilungsarbeit steckt in eigenen Modulklassen (z. B. Zentrale, Kurier), die Sie zuerst ohne Netz testen, und in der Methode verarbeite der Station.
Für die Abteilungsphase starten alle mit dem Checkpoint vom Ende des Kerns (Kapitel 6, Datei Station.java). Sie erkennt Duplikate je Absender. Ein einziges Paar letzterAbsender/letzteSeq reicht nur bei einem Gesprächspartner – im Go-Live spricht die Zentrale mit vielen.
| Element | Bedeutung |
|---|---|
Hauptprogramm: rufzeichen, session, datenbank | Rufzeichen (genau 6 Zeichen), Sitzungscode ("LOOPBACK" zum Alleintesten), Zugangscode der Logbuch-Datenbank |
| c Station(rufzeichen: Zeichenkette, datenbankCode: Zeichenkette) | Station erzeugen; verbinden mit starte(sessionCode) (gA) bzw. verbinde(sessionCode) (eA) |
| – verarbeite(p: Paket, text: Zeichenkette) | wird für jedes gültige Datenpaket an diese Station oder an ALLE__ aufgerufen; text sind die vollständigen Nutzdaten (Teile zusammengesetzt, Quittung und Duplikaterkennung erledigt). Hier ergänzt jede Abteilung ihre Logik |
gA: + sende(empfaenger: Zeichenkette, typ: Zeichenkette, text: Zeichenkette): Wahrheitswert | sendet zuverlässig und wartet auf die Quittung; false nach 5 erfolglosen Versuchen |
eA + sende(empfaenger: Zeichenkette, typ: Zeichenkette, text: Zeichenkette) | legt die Pakete in den Sendepuffer und kehrt sofort zurück; bricht ein Paket ab, ruft die Station abgebrochen(p: Paket) auf (dort ergänzen Sie, was dann passieren soll) |
Paket: getAbsender(), getEmpfaenger(), getTyp(), getSeq(), getNutzdaten() | Zugriff auf die Felder |
Die ADT-Klassen der Online-IDE sind nicht generisch (Bibliothek „Abiturklassen Niedersachsen“ im Workspace einschalten). Man schreibt DynArray liste = new DynArray(); und liest mit Typumwandlung: Bestellung b = (Bestellung) liste.getItem(0);.
Warum? synchronized in verarbeite
In der gA-Station blockiert sende den aufrufenden Thread, bis die Quittung da ist, und es gibt nur ein Quittungsfach. Kommen zwei Pakete fast gleichzeitig an, laufen zwei Aufrufe von verarbeite in zwei Threads. Senden beide, holt sich womöglich der eine Thread die Quittung des anderen. private synchronized void verarbeite(Paket p, String text) sorgt dafür, dass immer nur ein Thread darin arbeitet. empfange bleibt ohne synchronized: Sonst würden eingehende Pakete während eines langen sende nicht quittiert.
eA Ihre Station sendet über einen Sendepuffer und blockiert nicht. sende und verarbeite dürfen synchronized sein – dann darf in verarbeite aber kein Thread.sleep stehen, sonst warten auch die eigenen Quittungen. Wartezeiten (z. B. eine simulierte Fahrt) erzeugen Sie mit Timer.executeLater(() -> …, ms).
Wenn nichts ankommt
Prüfen Sie der Reihe nach, bevor Sie Ihren Code verdächtigen:
- Sind beide Stationen in der Online-IDE angemeldet und im selben Sitzungscode?
- Hat jede Station ein eigenes Rufzeichen mit genau sechs Zeichen?
- Steht
demoso, wie Sie es brauchen? Ist der Geschwindigkeitsregler auf Maximum? - Kommt das Paket beim Lausch-Client an? Wenn nein: Senden prüfen. Wenn ja: Adressfilter und Typ beim Empfänger prüfen.
- Wird
verarbeiteaufgerufen? Eine Ausgabe in der ersten Zeile vonverarbeitezeigt es. - Passen die Nutzdaten zum Schnittstellenvertrag (Positionen, Längen)?
Ist Ihre Partnerabteilung noch nicht so weit, testen Sie gegen die Ersatzstationen der Lehrkraft im Sitzungscode FN-<Kurs>-TEST. Sie arbeiten mit den Referenzformaten (Plan B).
Welche Themen braucht der Kurs?
| Thema | gebraucht in … | zusätzlich eA |
|---|---|---|
| Objektorientierung | alle Abteilungen (Modulklassen, Assoziation Station – Modul) | Vererbung (Zentrale; Station extends WebSocket) |
| 2D-Array, Sortieren | Kurier, Zentrale | Laufzeitvergleich (Zentrale, Kundenverzeichnis) |
| Queue, Stack, DynArray | Zentrale, Kurier, Kasse, Bestellstatus | Tiefensuche (Kurier), Kellerautomat (Bestellstatus) |
| Binärbaum, Suchbaum | Kundenverzeichnis | Löschen; Huffman-Baum (Funkstrecke) |
| Kryptologie | Kasse (Vigenère, Angriff) | Diffie-Hellman, Signatur, RSA-Idee (Kasse) |
| Codierung | Kern (Prüfsumme, Hamming), Kurier (RLE, Huffman) | Hamming und Huffman auf Bitebene (Funkstrecke) |
| Automaten, Sprachen | Bestellstatus (Mealy, DEA) | Mealy-Sender (Kern), Grammatik, Kellerautomat |
| Datenbanken | Logbuch; Go-Live-Auswertung für alle | ER-Modell, PreparedStatement (Logbuch) |
| Datenschutz | Kundenverzeichnis, Logbuch, Kern | Recht auf Löschung, Metadaten |
Protokollblatt und Bewertung
Das Protokollblatt ist das wichtigste Produkt Ihrer Gruppe. Es beschreibt Ihre Abteilung so, dass eine andere Gruppe ohne Ihren Quelltext eine passende Station bauen könnte. Sie beginnen es im Einstieg (v0.1) und führen es bis nach dem Go-Live weiter.
| Abschnitt | Inhalt |
|---|---|
| 1 Kopf | Abteilung, Gruppe, Mitglieder mit Rolle, Rufzeichen, Bedingungskarte, Version und Datum |
| 2 Aufgabe und Pakettypen | 2–3 Sätze zum Problem der Abteilung; Tabelle: Typ, sendet/empfängt, Partner, quittiert ja/nein |
| 3 Nutzdatenformate | je Format eine Formattabelle (Position, Länge, Inhalt, Wertebereich, Beispiel), auch für Fehlermeldungen; Kennzeichnung „eigener Entwurf“ oder „Plan B übernommen, weil …“ |
| 4 Abläufe | Sequenzdiagramm für den Normalfall und mindestens zwei Fehlerfälle; bei Automaten der Zustandsgraph |
| 5 Datenstrukturen und Algorithmen | Klassendiagramm, Struktogramm des wichtigsten Algorithmus, verwendete ADT mit Begründung |
| 6 Entscheidungen und Bedingungen | mindestens drei (eA: vier) Entscheidungen: Entscheidung – Alternative – Begründung; je Bedingung der Karte: wie erfüllt, wie geprüft |
| 7 Tests | Selbsttest, Schnittstellentest, Go-Live: Testfall – erwartet – beobachtet – Ursache |
| 8 Go-Live | Kennzahlen mit SQL-Abfrage; die zwei wichtigsten Fehler mit Beleg und Verbesserung |
| 9 eA Datenschutz und Sicherheit | Welche Daten verarbeitet die Station? Was ist geschützt, was nicht? |
| 10 Versionen | Änderung – Grund – Datum – zugestimmt von |
Bewertung (Ausgabe zu Beginn der Abteilungsphase). Bewertet werden die Operatoren entwerfen („nach vorgegebenen Bedingungen ein Modell oder einen Algorithmus selbstständig planen und erarbeiten“) und implementieren („einen Algorithmus oder eine Datenstruktur erarbeiten und codieren“). Teile A–F sind Gruppenleistung, Teil G ist Ihre Einzelleistung.
| Kriterium | gA | eA | Voll erfüllt, wenn … |
|---|---|---|---|
| A1 Nutzdatenformate | 10 | 8 | jede Formattabelle mit Wertebereich und passendem Beispiel, auch für Fehlerfälle; mit allen Partnern unterschrieben |
| A2 Entwurfsbedingungen | 8 | 7 | jede Bedingung nachweislich erfüllt; die Lösung folgt erkennbar aus Ihren Bedingungen. Plan B ist erlaubt, wenn gekennzeichnet und gegen eine Alternative begründet |
| A3 Abläufe und Algorithmen | 6 | 5 | Sequenzdiagramm mit zwei Fehlerfällen, Klassendiagramm, Struktogramm (bzw. vollständiger Automat) |
| A4 Begründete Entscheidungen | 6 | 5 | Entscheidungen mit Alternative und fachlicher Begründung (Rechnung, Messung, Datenschutz); Grenzen benannt |
| B1 Fachalgorithmus | 10 | 7 | vollständig und korrekt, Selbsttest auch für Randfälle bestanden |
| B2 Abiturkonform | 7 | 5 | nur erlaubte String-Operationen, ADT mit Abitur-Signaturen, keine Laufzeitfehler (isEmpty, Indexgrenzen, Ziffernprüfung) |
| B3 Anbindung | 8 | 6 | verarbeite reagiert auf alle vereinbarten Pakete genau nach Vertrag; die Station stürzt nie ab |
| B4 Codequalität | 5 | 4 | Modul ohne Netz testbar, sprechende Namen, Kommentare mit Verweis aufs Protokollblatt |
| C1 Tests | 8 | 5 | mindestens sechs Testfälle mit Rand- und Fehlerfällen, Soll – Ist – Ursache |
| C2 Fehleranalyse Go-Live | 7 | 5 | zwei Probleme mit SQL-Beleg, Kategorie, Verbesserung |
| D1 Betrieb im Go-Live | 6 | 5 | Startcheck und Rauchtest, Absprachen eingehalten |
| D2 Auswertung | 4 | 3 | Kennzahlen per SQL bestimmt und gedeutet |
| E eA Erweiterung | – | 10 | eA-Aufgaben entworfen, implementiert, getestet, beurteilt |
| F eA Präsentation und Reflexion | – | 10 | eine Entscheidung überzeugend begründet, Beleg, differenzierte Reflexion |
| G Kolloquium (einzeln) | 15 | 15 | Sie erklären jeden Teil Ihrer Abteilung und beantworten „Was passiert, wenn …?“ |
Grundsätze: Übernommener Code (Gerüste, Plan B) ist erlaubt, muss aber gekennzeichnet sein. Störungen durch andere Gruppen im Go-Live gehen nicht zu Ihren Lasten, wenn Sie sie im Fehlerprotokoll belegen. Fällt Ihre Station im Go-Live aus, übernimmt die Lehrkraft mit einer Ersatzstation; Sie analysieren den Fehler im Fehlerprotokoll. Bei deutlich ungleichen Beiträgen können die Gruppenpunkte für Einzelne angepasst werden; Grundlage ist unter anderem eine kurze anonyme Beitragsrückmeldung, die regelmäßig eingeholt wird.
Kolloquium: Gruppengespräch (gA nach dem Go-Live, eA in der Präsentation). Jedes Gruppenmitglied zieht eine von drei Fragekarten; vorbereitet sein müssen also alle. Fragetypen: „Was passiert, wenn … verloren geht / doppelt kommt / gefälscht ist?“, „Zeigen Sie im Code, wo …“, „Warum haben Sie … und nicht … gewählt?“, dazu eine Frage zum Kern (z. B. „Was passiert, wenn das ACK zu Ihrem Paket verloren geht?“).
Selbstcheck vor der Abgabe
- Jedes Format, das wir anbieten, hat eine Formattabelle mit Beispiel – auch für Fehlermeldungen; Plan B ist gekennzeichnet.
- Jede Bedingung unserer Karte ist erfüllt, und wir können zeigen, wie wir das geprüft haben.
- Es gibt ein Sequenzdiagramm für den Normalfall und zwei Fehlerfälle, ein Klassendiagramm und ein Struktogramm.
- Wir haben drei (eA: vier) Entscheidungen mit Alternative und Begründung.
- Kein
split; jede ADT-Operation mitisEmpty– bzw. Indexprüfung; jede gelesene Zahl vorher geprüft. - Der Selbsttest läuft ohne Netz; das Testprotokoll hat mindestens sechs Fälle mit Soll – Ist – Ursache.
- Unsere Station hat im Go-Live die Absprachen eingehalten; zwei Fehler sind mit SQL belegt.
- Jede und jeder von uns kann jeden Teil erklären.
- eA Die Erweiterung ist implementiert, getestet und beurteilt.
Abteilung Zentrale
Worum es geht: Bestellungen kommen schneller, als Adressen und Kuriere bereitstehen. → Die Zentrale merkt sich jede Bestellung in einer Schlange, sortiert die ausliefbaren nach Dringlichkeit und vergibt sie an freie Kuriere.
Einstieg: Wo bleibt mein Burger?
Freitag, 19:30 Uhr. Die alte Zentrale arbeitet „einfach alles sofort ab“. Der Lausch-Client zeigt (Quittungen weggelassen):
19:30:02 KUNDE1 → ZENTRA BST 00423 2xPIZZA,1xCOLA
19:30:05 KUNDE1 → ZENTRA BST 08151 1xBURGER
19:30:06 KUNDE1 → ZENTRA BST 00073 3xPASTA
19:30:07 ZENTRA → KUNDEN ADR wo wohnt 0042?
19:30:07 ZENTRA → KUNDEN ADR wo wohnt 0815?
19:30:08 ZENTRA → KUNDEN ADR wo wohnt 0007?
19:30:09 KUNDEN → ZENTRA ADR Zeile 5, Spalte 30
19:30:10 KUNDEN → ZENTRA ADR Zeile 3, Spalte 20
19:30:10 KUNDEN → ZENTRA ADR Zeile 1, Spalte 6
19:30:11 ZENTRA → KURIR1 BST 3xPASTA, Zeile 5, Spalte 30
// danach ist KURIR1 wieder frei – und wartet
19:58:40 KUNDE1 → ZENTRA BST 08151 WO BLEIBT MEIN BURGER?Die Pasta kam zuletzt und wurde zuerst geliefert. Die Antworten des Kundenverzeichnisses kamen alle an – aber drei Anfragen waren gleichzeitig offen, und die Zentrale konnte keine Antwort sicher einer Bestellung zuordnen. Den eiligen Burger (Priorität 1) hat sie dabei vergessen. Und obwohl KURIR1 nach der Pasta längst wieder frei war, wartet die Pizza noch.
Leitfrage: In welcher Reihenfolge soll die Zentrale Bestellungen ausliefern lassen – und was muss sie sich merken, während eine Bestellung auf ihre Adresse oder auf einen Kurier wartet?
Nebenfragen:
- Gibt es mehr als eine sinnvolle Reihenfolge?
- Welche Datenstrukturen aus dem Unterricht verhalten sich so, wie die Zentrale es braucht?
Sammeln Sie in der Gruppe: Problem → Idee → offene Frage.
- Spielen Sie die Situation mit Karteikarten nach: Jede Bestellung ist eine Karte. Wo liegen die Karten, solange die Adresse fehlt? Wo, wenn die Adresse da ist, aber kein Kurier?
- Formulieren Sie für jeden „Kartenstapel“ eine Regel: Wo kommt eine Karte hinzu, wo wird sie entnommen?
- Mit welchen Abteilungen müssen Sie ein Nutzdatenformat vereinbaren?
Tragen Sie den Plan als Protokollblatt v0.1 ein (Abschnitte 2, 3 und 6) und zeigen Sie ihn der Lehrkraft (Plan-Ticket). Danach beginnt Aufgabe 1.
- Dringendere Bestellungen (kleinere Priorität) zuerst, bei gleicher Priorität gilt die Eingangsreihenfolge.
- Der Lieferauftrag enthält alles, was der Kurier für Weg und Kasse braucht – aber weder Kundennummer noch Adresse.
- Es ist immer nur eine Adressanfrage unterwegs.
- Die Zentrale meldet
ANN,KOCundSTOanALLE__. - eA Keine Bestellung verhungert: Wer dreimal übergangen wurde, rückt eine Prioritätsstufe auf.
- Dringendere Bestellungen zuerst, bei gleicher Priorität gilt die Eingangsreihenfolge.
- Den Auftrag bekommt der nächstgelegene freie Kurier (Abstand = Zeilenunterschied + Spaltenunterschied).
- Der Lieferauftrag enthält weder Kundennummer noch Adresse, aber den Betrag in Cent – der Kurier braucht keine Preisliste.
- Es ist immer nur eine Adressanfrage unterwegs; die Zentrale meldet
ANN,KOCundSTO. - eA Keine Bestellung verhungert: Wer dreimal übergangen wurde, rückt eine Prioritätsstufe auf.
Aufgaben: Die Zentrale entwerfen
Entwerfen Sie den Ablauf in der Zentrale und die Schnittstellen zu den anderen Abteilungen. Halten Sie alles im Protokollblatt fest.
Material: Ihre Bedingungskarte, Bestellformat KKKKP Text, Tabelle Ü3 (Ablauf einer Bestellung im Go-Live).
Zeichnen Sie ein Sequenzdiagramm für eine Bestellung aus Sicht der Zentrale: alle Pakete, die die Zentrale empfängt und sendet, mit Typ und den Angaben, die darin stehen müssen. Ergänzen Sie drei Sonderfälle: (1) Die Bestellung ist unlesbar. (2) Der Kunde ist unbekannt. (3) Kein Kurier ist frei, als die Adresse eintrifft.
KUNDE1, ZENTRA, KUNDEN, KURIR1 und ALLE__; die Zeit läuft nach unten. Quittungen dürfen Sie weglassen, die erledigt der Kern.BST von KUNDE1. Was muss die Zentrale danach sofort tun, was erst später? Welche Pakete lösen bei der Zentrale eine Reaktion aus?Entwerfen Sie (1) das Format der Adressanfrage und klären Sie mit dem Kundenverzeichnis, wie dessen Antwort aussieht, und (2) das Format des Lieferauftrags gemeinsam mit den Kurier-Gruppen. Geben Sie je eine Formattabelle (Position, Länge, Inhalt, Wertebereich, Beispiel) an und begründen Sie sie mit Ihrer Bedingungskarte.
substring. Damit die Zentrale eine Antwort ihrer Anfrage zuordnen kann, sollte in Anfrage und Antwort dieselbe Kennung stehen – welche?Das Klassendiagramm in Aufgabe 3 ist vorgegeben. Ergänzen Sie es um alles, was Ihre Bedingungskarte zusätzlich verlangt (Karte Z-b: Positionen der freien Kuriere), und begründen Sie Ihre Wahl der Datenstruktur.
Material: Ereignisse in dieser Reihenfolge (Bestellnummern ab 001; jede Adressantwort gehört zur gerade angefragten Bestellung).
| Nr. | Ereignis |
|---|---|
| 1 | BST 00423 2xPIZZA,1xCOLA |
| 2 | BST 08151 1xBURGER |
| 3 | BST 00073 3xPASTA |
| 4 | Adresse zu 001 |
| 5 | BST 12001 1xSALAT |
| 6 | Adresse zu 002 |
| 7 | Adresse zu 003 |
| 8 | BST 03503 2xPOMMES |
| 9 | Adresse zu 004 |
| 10 | Adresse zu 005 |
Die Zentrale verwaltet zwei „Kartenstapel“: Bestellungen ohne Adresse warten in einer Warteschlange, Bestellungen mit Adresse in einer nach Dringlichkeit sortierten Auftragsliste.
Geben Sie nach jedem Ereignis den Inhalt der Eingangsschlange an (vorn links) und notieren Sie, wann welche Adressanfrage gesendet wird. Geben Sie außerdem nach jeder Adressantwort die Auftragsliste an (Position 0 links, Schreibweise Nummer/Priorität), wenn noch kein Kurier frei ist. In welcher Reihenfolge wird ausgeliefert, wenn danach ein Kurier nacheinander alle übernimmt?
enqueue bei jeder neuen Bestellung, dequeue bei jeder Adressantwort. Eine Anfrage geht hinaus, wenn eine Bestellung in eine leere Schlange kommt oder wenn nach einem dequeue noch etwas in der Schlange steht.Stellen Sie die Operation sortiere() (Einfügesortierung auf der dynamischen Reihung liste) auf Papier als Struktogramm dar. Nutzen Sie nur getLength, getItem, setItem und istDringenderAls.
i ab 1; das Element an Position i wird in akt gemerkt.Hilfe 2: Ergänzen Sie die Lücken:
Ausgezeichnet – Alle Aufgaben abgeschlossen!
Ihr Entwurf steht. Prüfen Sie ihn, bevor Sie programmieren:
Aufgaben: Die Zentrale programmieren
Implementieren Sie die Klassen Bestellung und Zentrale als eigene Datei Zentrale.java und testen Sie sie ohne Netz (Bibliothek „Abiturklassen Niedersachsen“ einschalten).
Material: Klassendiagramm, Selbsttest und Gerüst der Datei Zentrale.java. Tragen Sie vor dem Programmieren in den Selbsttest die erwarteten Werte aus Ihrem Schnittstellenvertrag ein („test first“).
// ---- Selbsttest (Hauptprogramm) ----
Zentrale z = new Zentrale();
int n1 = z.neueNummer();
z.nimmAn(Bestellung.ausText("00423 2xPIZZA,1xCOLA", n1));
int n2 = z.neueNummer();
z.nimmAn(Bestellung.ausText("08151 1xBURGER", n2));
// erwartet: true (an Position 5 fehlt das Leerzeichen)
println(Bestellung.ausText("00423Pizza", 9) == null);
// Beispiele aus Ihrem Schnittstellenvertrag eintragen:
// Antwort "Kunde unbekannt" zu Bestellung 1
String unbekannt1 = "________";
// Antwort zu Bestellung 1: Kunde wohnt in Zeile 1, Spalte 6
String antwort1 = "________";
// Antwort zu Bestellung 2: Kunde wohnt in Zeile 3, Spalte 20
String antwort2 = "________";
// erwartet laut Protokollblatt: ________
println(z.adressanfrage());
// erwartet: false (Antwort gehört nicht zur vordersten)
println(z.adresseEingetroffen(antwort2));
// erwartet: false (Kunde unbekannt)
println(z.adresseEingetroffen(unbekannt1));
// erwartet: true
println(z.adresseEingetroffen(antwort1));
// erwartet laut Protokollblatt: ________
println(z.adressanfrage());
// erwartet: true
println(z.adresseEingetroffen(antwort2));
// erwartet: erst Nr 2 (Prio 1), dann Nr 1
z.zeigeListe();
z.kurierFrei("KURIR1");
Bestellung b = z.naechsteBestellung();
String k = z.naechsterKurier();
// erwartet laut Protokollblatt: KURIR1 ________
println(k + " " + z.lieferauftrag(b));Zentrale.javaGerüst der Klassen Bestellung und Zentrale anzeigen
class Bestellung {
private int kundennr;
// 1 = eilig ... 3 = normal
private int prioritaet;
// Eingangsnummer = Bestellnummer
private int zeit;
private String text;
private int zeile = -1;
private int spalte = -1;
public Bestellung(int kundennr, int prioritaet, int zeit,
String text) {
this.kundennr = kundennr;
this.prioritaet = prioritaet;
this.zeit = zeit;
this.text = text;
}
// liest "KKKKP Text"; null, wenn das Format nicht stimmt
public static Bestellung ausText(String s, int zeit) {
// TODO Teil a
return null;
}
// kommt diese Bestellung vor der anderen dran?
public boolean istDringenderAls(Bestellung andere) {
// TODO Teil a
return false;
}
public void setZiel(int zeile, int spalte) {
this.zeile = zeile;
this.spalte = spalte;
}
public String alsText() {
return "Kunde " + kundennr + ", Prio " + prioritaet
+ ", Nr " + zeit + ": " + text;
}
public int getKundennr() { return kundennr; }
public int getPrioritaet() { return prioritaet; }
public int getZeit() { return zeit; }
public String getText() { return text; }
public int getZeile() { return zeile; }
public int getSpalte() { return spalte; }
}
class Zentrale {
// Feldpositionen Ihres ADR-Antwortformats
// TODO Teil b: Werte laut Schnittstellenvertrag eintragen
private int ANTWORT_LAENGE = 0;
private int POS_NR = 0;
private int POS_ZEILE = 0;
private int POS_SPALTE = 0;
// Bestellungen, die auf ihre Adresse warten
private Queue eingang = new Queue();
// Adresse bekannt, dringendste vorn
private DynArray liste = new DynArray();
// Rufzeichen der freien Kuriere
private DynArray freieKuriere = new DynArray();
private int naechsteNr = 1;
public int neueNummer() {
int nr = naechsteNr;
// 1 ... 999, dann wieder 1
naechsteNr = naechsteNr % 999 + 1;
return nr;
}
public void nimmAn(Bestellung b) {
if (b == null) {
println("Bestellung unlesbar!", Color.orange);
return;
}
eingang.enqueue(b);
}
// Anfrage für die vorderste Bestellung; "" bei leerer Schlange
public String adressanfrage() {
// TODO Teil b
return "";
}
// false, wenn die Antwort nicht zur vordersten Bestellung
// passt oder unlesbar ist
public boolean adresseEingetroffen(String text) {
// TODO Teil b
return false;
}
// steht vorn in der Schlange die Bestellung mit dieser Nummer?
public boolean vordersteHatNr(String nrText) {
if (eingang.isEmpty()) {
return false;
}
Bestellung b = (Bestellung) eingang.head();
return mitNullen(b.getZeit(), 3).equals(nrText);
}
public Bestellung verwerfeVorderste() {
if (eingang.isEmpty()) {
return null;
}
return (Bestellung) eingang.dequeue();
}
// Einfügesortierung: dringendste Bestellung nach vorn
public void sortiere() {
// TODO Teil c
}
public Bestellung naechsteBestellung() {
if (liste.isEmpty()) {
return null;
}
Bestellung b = (Bestellung) liste.getItem(0);
liste.delete(0);
return b;
}
// Auftrag zurück in die Liste, z. B. Kurier nicht erreichbar
public void nimmAnZurueck(Bestellung b) {
liste.append(b);
sortiere();
}
public void kurierFrei(String rufzeichen) {
freieKuriere.append(rufzeichen);
}
public boolean kannVergeben() {
return !liste.isEmpty() && !freieKuriere.isEmpty();
}
public String naechsterKurier() {
if (freieKuriere.isEmpty()) {
return "";
}
String k = (String) freieKuriere.getItem(0);
freieKuriere.delete(0);
return k;
}
// Lieferauftrag im Format laut Schnittstellenvertrag
public String lieferauftrag(Bestellung b) {
// TODO Teil c
return "";
}
public void zeigeListe() {
println("--- offene Bestellungen: " + liste.getLength()
+ " ---", Color.aquamarine);
for (int i = 0; i < liste.getLength(); i++) {
Bestellung b = (Bestellung) liste.getItem(i);
println((i + 1) + ". " + b.alsText());
}
}
public String mitNullen(int zahl, int stellen) {
String s = "" + zahl;
while (s.length() < stellen) {
s = "0" + s;
}
return s;
}
// Ziffernfolge -> Zahl; -1, wenn ein Zeichen keine Ziffer ist
public int zahlAus(String s) {
int wert = 0;
for (int i = 0; i < s.length(); i++) {
char c = s.charAt(i);
if (c < '0' || c > '9') {
return -1;
}
wert = wert * 10 + ((int) c - 48);
}
return wert;
}
}Bestellung und ZentraleZiel: ausText und istDringenderAls arbeiten nach Vorgabe. Fertig, wenn: Die Zeile mit ausText("00423Pizza", 9) gibt true aus.
Implementieren Sie ausText (Format KKKKP Text: vier Ziffern Kundennummer, Priorität 1–3, an Position 5 ein Leerzeichen, sonst null) und istDringenderAls (kleinere Priorität zuerst, bei Gleichstand die kleinere Eingangsnummer).
zahlAus geprüft, ob ein Zahlenfeld nur Ziffern enthält? Wie lang muss eine gültige Bestellung mindestens sein?ausText: Länge und Leerzeichen prüfen → Kundennummer mit zahlAus(s.substring(0, 4)) lesen, bei −1 abbrechen → Priorität an Position 4 prüfen → neues Objekt mit s.substring(6) als Text.Integer.parseInt ist in der Online-IDE zu großzügig ("4x" ergibt 4). Prüfen Sie Zahlenfelder deshalb immer Zeichen für Zeichen.
Ziel: Die Zentrale fragt nur für die vorderste Bestellung an und übernimmt nur eine dazu passende Antwort. Fertig, wenn: Die fünf Ausgaben zu adressanfrage und adresseEingetroffen stimmen mit Ihren eingetragenen Erwartungen überein.
Tragen Sie zuerst die Feldpositionen Ihres Antwortformats in die Attribute am Klassenanfang ein. Implementieren Sie dann adressanfrage() und adresseEingetroffen(text) nach Ihrem Schnittstellenvertrag. Eine Antwort wird nur angenommen, wenn ihre Länge stimmt, alle Zahlenfelder lesbar sind und die Bestellnummer zur vordersten Bestellung passt. Dann wird die Bestellung entnommen, ihr Ziel gesetzt, sie an die Liste angehängt und die Liste sortiert.
head() und dequeue() immer isEmpty() prüfen – das verlangt auch das Abitur. head() liefert ein Object: Bestellung b = (Bestellung) eingang.head();zahlAus(text.substring(POS_ZEILE, POS_ZEILE + 2)). Eine Antwort „unbekannt“ hat dort keine Ziffern – zahlAus liefert dann −1.adresseEingetroffen: Schlange leer oder Länge falsch → false; Nummer, Zeile, Spalte lesen; passt die Nummer nicht oder ist ein Wert −1 → false; sonst dequeue, setZiel, append, sortiere, true.Ziel: Die dringendste Bestellung steht immer vorn, der Lieferauftrag entspricht Ihrem Vertrag. Fertig, wenn: Alle Ausgaben des Selbsttests stimmen.
Implementieren Sie sortiere nach Ihrem Struktogramm und lieferauftrag nach Ihrem Schnittstellenvertrag.
getItem liefert ein Object – beim Vergleich umwandeln: akt.istDringenderAls((Bestellung) liste.getItem(j)).Hilfe 2: Zahlen im Lieferauftrag brauchen feste Breiten: mitNullen(b.getZeile(), 2).
Karte Z-b: Speichern Sie zu jedem freien Kurier auch seine Position (z. B. eine zweite Reihung oder eine kleine Klasse) und schreiben Sie naechsterKurier(b: Bestellung), der den Kurier mit dem kleinsten Abstand zum Ziel von b liefert. Der Betrag kommt aus Preisliste.summe(text) (Klasse der Kurier-Gruppe).
Ausgezeichnet – Alle Aufgaben abgeschlossen!
Ihr Modul besteht den Selbsttest (Meilenstein M2). Prüfen Sie noch:
Aufgaben: Station ZENTRA anbinden
Jetzt wird die Zentrale zur Station. Kopieren Sie Bestellung und Zentrale ohne das Hauptprogramm in den Workspace mit Ihrer Station, setzen Sie rufzeichen = "ZENTRA" und testen Sie erst mit session = "LOOPBACK", dann im Gruppen-Sitzungscode.
Material: Ergänzung der Klasse Station
// in der Klasse Station:
private Zentrale zentrale = new Zentrale();
private synchronized void verarbeite(Paket p, String text) {
String typ = p.getTyp();
if (typ.equals("BST") && p.getAbsender().equals("KUNDE1")) {
// TODO Teil a
} else if (typ.equals("ADR")) {
// TODO Teil b
} else if (typ.equals("POS")) {
// TODO Teil c
}
}
// vergibt Aufträge, solange Kurier und Auftrag vorhanden sind
private void vergeben() {
// TODO Teil c
}ZENTRAErgänzen Sie den Fall BST: Bestellnummer holen, Bestellung lesen. Ist sie unlesbar, STO melden. Sonst annehmen, ANN melden und – wenn die neue Bestellung vorn in der Schlange steht – die Adressanfrage an KUNDEN senden.
vordersteHatNr hilft.sende("ALLE__", "STA", nrText + "ANN"); mit String nrText = zentrale.mitNullen(nr, 3);neueNummer()) gehören in eine eigene Zeile – die Online-IDE wertet Verkettungen nicht sicher von links nach rechts aus.Ergänzen Sie den Fall ADR: Bei unbekanntem Kunden die vorderste Bestellung verwerfen und STO melden, sonst eintragen und KOC melden. Danach die nächste Adressanfrage senden (falls vorhanden) und vergeben.
zentrale.vordersteHatNr(nrText) gilt. Sonst storniert eine verspätete Antwort die falsche Bestellung. Prüfen Sie vor jedem substring die Länge des Textes.Ergänzen Sie den Fall POS (ein Kurier meldet sich frei) und die Methode vergeben().
POS-Nutzdaten laut Vertrag, dass der Kurier frei ist?vergeben() ist eine Schleife mit zentrale.kannVergeben() als Bedingung. Was soll passieren, wenn sende false liefert (Kurier nicht erreichbar)? nimmAnZurueck hilft.sende nichts zurück. Bricht ein Paket ab, ruft die Station abgebrochen(p) auf. Lesen Sie dort die Bestellnummer aus p.getNutzdaten() und melden Sie STO – oder legen Sie den Auftrag zurück, wenn Sie sich ihn gemerkt haben.Planen Sie mit dem Kundenverzeichnis und einer Kurier-Gruppe einen Schnittstellentest und führen Sie ihn durch (Gruppen-Sitzungscode, Störkanal aus, dann 10 % Verlust). Halten Sie in einer Tabelle fest: Testfall – erwartet – beobachtet – Ursache bei Abweichung (Spezifikation oder Implementierung?).
rufzeichen = "KUNDE1" und demo = false und tippt die Bestellungen ein. Ist eine Partnerabteilung noch nicht bereit, testen Sie gegen die Ersatzstationen in FN-<Kurs>-TEST.Ausgezeichnet – Alle Aufgaben abgeschlossen!
Ihre Zentrale ist auf Sendung (Meilenstein M3). Prüfen Sie:
Aufgaben: Fairness und Vererbung eA
Die Zentrale wird fair und lernt eine neue Art von Bestellung.
Material: Am Freitagabend kommen fast nur eilige Bestellungen (Priorität 1). Die Pizza von Bestellung 001 (Priorität 3) wird bei jeder Vergabe wieder übergangen – sie verhungert. Bedingung 5 Ihrer Karte: Wer dreimal übergangen wurde, rückt eine Prioritätsstufe auf.
Ergänzen Sie Bestellung um einen Zähler uebergangen und eine Methode uebergehe() und schreiben Sie in der Zentrale naechsteBestellungFair(): Nach dem Entnehmen werden alle wartenden Aufträge „übergangen“, dann wird neu sortiert. Testen Sie: zwei normale Bestellungen, danach acht Runden „eine eilige kommt dazu, einmal wird vergeben“. Notieren Sie die Reihenfolge der vergebenen Nummern.
uebergehe(): Zähler erhöhen; erreicht er 3 und ist die Priorität größer als 1, Priorität um 1 senken und Zähler zurücksetzen.sortiere() aufgerufen werden?Food Now! liefert auch Medikamente der Apotheke aus (Priorität 0 im Bestellformat). Sie haben Vorrang vor allem und rücken nicht auf. Entwerfen Sie eine Unterklasse Medikamentenlieferung von Bestellung, die istDringenderAls und alsText überschreibt. Zeichnen Sie das Klassendiagramm mit Vererbungspfeil, passen Sie ausText an und erklären Sie, warum sortiere() nicht geändert werden muss.
super(kundennr, 0, zeit, text) auf.istDringenderAls: Ist die andere auch eine Medikamentenlieferung (Priorität 0), entscheidet die Eingangsnummer, sonst gilt immer true.Ergänzen Sie die Station: (1) Aufträge für die Außenfiliale Hasbergen (das Kundenverzeichnis meldet dafür eine vereinbarte Lage, z. B. Zeile 99) gehen sofort an RELAIS statt in die Auftragsliste. (2) Bestelltexte werden vor der Annahme mit der Klasse Bestellstatus der Abteilung Bestellstatus geprüft; ungültige werden mit STO storniert. Handeln Sie beides mit den Abteilungen aus.
RELAIS meldet sich nicht mit POS frei. Aufträge für Hasbergen werden deshalb direkt nach dem Eintreffen der Adresse gesendet – verwerfeVorderste() liefert die Bestellung, ohne sie in die Liste zu übernehmen.Bestellstatus kommt in Ihren Workspace. Texte ohne Klammern prüft istGueltigerBestelltext(text), Menüs mit Klammern klammernOk(text). Solange die Klasse noch fehlt, schreiben Sie eine Fassung, die immer true liefert.Die Liste ist vor liste.append(b) schon sortiert. Wie viele Vergleiche braucht sortiere() dann im besten und im schlechtesten Fall bei n Aufträgen? Wie viele bräuchte die Einfügesortierung für eine völlig unsortierte Liste?
Ein Mitschüler schlägt vor: „Nehmt drei Queues, eine je Priorität. Vergeben wird immer aus der dringendsten nicht leeren Schlange.“ Beurteilen Sie den Vorschlag – auch im Hinblick auf Bedingung 5 und die Medikamente.
Ausgezeichnet – Alle Aufgaben abgeschlossen!
Die Erweiterung läuft (Meilenstein M4). Prüfen Sie:
Sicherung
Eine Warteschlange, aus der immer das dringendste Element zuerst entnommen wird; bei gleicher Dringlichkeit das älteste. Die Zentrale baut sie aus einer sortierten dynamischen Reihung.
Die Zentrale nutzt eine Schlange (FIFO) für Bestellungen, die auf ihre Adresse warten: Es ist immer nur eine Anfrage unterwegs, und keine Bestellung geht verloren. Eine nach Priorität sortierte dynamische Reihung (Einfügesortierung) liefert den nächsten Auftrag immer an Position 0. Die ADT-Klassen speichern Object; beim Lesen wird umgewandelt ((Bestellung) liste.getItem(i)). Vor head, dequeue, getItem und delete wird geprüft, ob die Struktur leer bzw. der Index gültig ist.
Diese Pakete empfängt und sendet die Zentrale. Die Formate stehen in Ihrem Schnittstellenvertrag.
| Richtung | Typ | Partner | Nutzdaten |
|---|---|---|---|
| empfängt | BST | KUNDE1 | KKKKP Text |
| sendet | ADR | KUNDEN | Anfrage laut Vertrag |
| empfängt | ADR | KUNDEN | Antwort laut Vertrag |
| sendet | BST | KURIRn, eA RELAIS | Lieferauftrag laut Vertrag |
| empfängt | POS | KURIRn | Meldung „frei“ laut Vertrag |
| sendet | STA | ALLE__ | NNN + ANN, KOC oder STO |
Vergleichen Sie Ihren Plan aus dem Einstieg mit Ihrer fertigen Zentrale: Welche Plan-Punkte haben sich bestätigt, welche mussten Sie ändern – und warum?
Mit Schlange und sortierter Auftragsliste wird der eilige Burger zuerst vergeben, obwohl er später kam. Weil immer nur eine Anfrage unterwegs ist und jede Antwort die Bestellnummer trägt, kann die Zentrale jede Antwort zuordnen – eine verspätete oder unpassende Antwort wird verworfen statt falsch verbucht. Ein frei gemeldeter Kurier bekommt sofort den nächsten Auftrag, die Pizza wartet nicht mehr.
Abteilung Kurier
Worum es geht: Der Stadtplan braucht neun Pakete, und nach der Lieferung findet die Kurierin nicht zurück. → Der Kurier überträgt den Plan komprimiert, speichert ihn als 2D-Array und merkt sich den Weg auf einem Stapel.
Einstieg: Kim findet nicht zurück
Erster Arbeitstag von Kurierin Kim (KURIR1). Bevor sie losfahren kann, braucht ihr Programm den Stadtplan. Der Kartendienst KARTE1 schickt ihn als Text – Zeile für Zeile, getrennt durch /. Der Lausch-Client zeigt:
20:00:01 KURIR1 → KARTE1 KRT (Anforderung)
20:00:01 KARTE1 → KURIR1 KRT Teil 01/09 ##.#########…
20:00:03 KARTE1 → KURIR1 KRT Teil 02/09
// Timeout, Wiederholung
20:00:05 KARTE1 → KURIR1 KRT Teil 02/09 ……/##.######…
…
20:00:27 KARTE1 → KURIR1 KRT Teil 09/09 .########.#
20:00:27 ZENTRA → KURIR1 BST Lieferauftrag 017
// wartet seit 20:00:09 auf KURIR1
20:07:40 KURIR1 → ALLE__ STA WIE KOMME ICH ZURUECK?Der Plan hat 12 Zeilen mit je 40 Zeichen, mit Trennzeichen 491 Zeichen – das sind 9 Pakete. Bei Störung dauert das fast eine halbe Minute, und in dieser Zeit wartet schon der erste Auftrag. Dabei besteht der Plan fast nur aus langen Folgen gleicher Zeichen. Auf dem Hinweg wurde Kim außerdem wegen einer Absperrung spontan umgeleitet. Jetzt weiß ihr Programm nicht mehr, wie sie gefahren ist – und nur der gefahrene Weg ist sicher frei.
Leitfrage: Wie kommt der Kurier mit wenigen Paketen zu seinem Plan – und auf genau demselben Weg zurück zur Zentrale?
Nebenfragen:
- Wie kann man den Plan kürzer übertragen, ohne Information zu verlieren?
- In welcher Reihenfolge braucht der Kurier auf dem Rückweg die Positionen, die er sich gemerkt hat?
Sammeln Sie in der Gruppe: Problem → Idee → offene Frage.
- Lesen Sie eine Zeile des Plans laut vor, ohne jedes Zeichen einzeln zu nennen. Was sagen Sie dann?
- Legen Sie den Hinweg mit Karten nach: Auf jede Karte schreiben Sie die Position, von der Kim gerade losfährt. Welche Karte brauchen Sie für den Rückweg zuerst?
- Welche Pakete empfängt und sendet ein Kurier während einer Lieferung? Mit wem müssen Sie dafür etwas vereinbaren?
Tragen Sie den Plan als Protokollblatt v0.1 ein (Abschnitte 2, 3 und 6) und zeigen Sie ihn der Lehrkraft (Plan-Ticket). Danach beginnt Aufgabe 1.
- Ihre Gruppe betreibt auch den Kartendienst
KARTE1. - Störungsprofil beim Test: 20 % Verlust.
- Der Kurier prüft, ob der Plan vollständig ist (12 Zeilen à 40 Zeichen), und fordert ihn sonst neu an.
- Der Kurier zeigt den Plan nach jedem Schritt mit seiner Position an.
- Störungsprofil beim Test: 20 % Fehler.
- Der Rückweg führt exakt über den Hinweg und wird als Positionsfolge ausgegeben.
- Der Kurier meldet alle 5 Schritte seine Position an die Zentrale (Format mit der Zentrale aushandeln).
- Störungsprofil beim Test: 300 ms Verzögerung.
- Die Nutzdaten jedes eigenen Pakets haben höchstens 20 Zeichen.
Material für alle Aufgaben: der Stadtplan von Osnabrück (stark vereinfacht), Zeile 0 oben, Spalte 0 links.
| Zeichen | Bedeutung |
|---|---|
| . | Straße (befahrbar) |
| # | Häuserblock |
| Z | Zentrale (Zeile 5, Spalte 11) |
| N / S | ein Feld nach oben (Zeile − 1) / unten (Zeile + 1) |
| O / W | ein Feld nach rechts (Spalte + 1) / links (Spalte − 1) |
Plan als Text (für das Programm)
String[] plan = {
"##.########.########.########.########.#",
"........................................",
"##.########.########.########.########.#",
"##.########.########.########.########.#",
"##.########.########.########.########.#",
"...........Z............................",
"##.########.########.########.########.#",
"##.########.########.########.########.#",
"##.########.########.########.########.#",
"........................................",
"##.########.########.########.########.#",
"##.########.########.########.########.#"
};Aufgaben: Den Kurier entwerfen
Entwerfen Sie, wie der Plan übertragen wird, wie der Kurier seinen Weg speichert und welche Pakete er austauscht. Halten Sie alles im Protokollblatt fest.
Material: Stadtplan, Ihre Bedingungskarte, Tabelle Ü3 (Ablauf einer Bestellung im Go-Live).
- Wie viele FN/1-Pakete braucht der Plan unkomprimiert (12 Zeilen, mit
/verbunden)? - Codieren Sie die Zeilen 0, 1 und 5 von Hand mit Lauflängencodierung (Notation Anzahl-Wert).
- Der ganze Plan (mit Trennzeichen) ergibt lauflängencodiert 234 Zeichen. Berechnen Sie Kompressionsverhältnis, prozentuale Datenersparnis und die Zahl der Pakete.
- Woran erkennt der Empfänger, wo eine Anzahl endet und wo eine Kartenzeile endet? Was müsste man ändern, wenn im Plan Ziffern (Hausnummern) vorkämen?
rrrssssgrr wird 3r4s1g2r. Auch einzelne Zeichen bekommen eine Anzahl: 1g. Das / wird wie jedes andere Zeichen codiert.40.? Und wie wäre 12 zu lesen, wenn auch Ziffern Werte sein dürften?Die 480 Kartenzeichen kommen so oft vor: # 315-mal, . 164-mal, Z einmal. Erstellen Sie einen Huffman-Baum für die drei Zeichen und bestimmen Sie die Codes. Wie viele Bit braucht der Plan Huffman-codiert, wie viele mit 7-Bit-ASCII, wie viele lauflängencodiert in ASCII (234 Zeichen)? Unser Kanal überträgt allerdings Zeichen, keine einzelnen Bits. Entscheiden Sie begründet, welches Verfahren für KRT sinnvoll ist.
Z (1) und . (164).'0' oder '1' übertragen werden. Wie viele Zeichen wären die Huffman-Bits dann?Kim fährt von der Zentrale (5, 11) zu Kunde 0042 (Hasestraße, Zeile 1, Spalte 6). Fahrtenplan: Liegt das Ziel an einer waagerechten Straße (Zeile 1, 5 oder 9), fährt sie zuerst senkrecht bis zur Zielzeile, dann waagerecht; sonst umgekehrt.
- Geben Sie den Hinweg als Folge aus N, O, S, W an.
- Vor jedem Schritt wird die alte Position auf einen Stapel gelegt. Zeichnen Sie den Stapel nach dem Hinweg (oben = zuletzt abgelegt).
- Geben Sie die Positionen an, die wiederholtes
pop()für den Rückweg liefert.
Stellen Sie den Ablauf einer Tour aus Sicht von KURIR1 als Sequenzdiagramm dar – vom Start des Programms bis zur erneuten Freimeldung. Entwerfen Sie das POS-Format (Formattabelle mit Beispiel) und stimmen Sie es mit der Zentrale ab. Klären Sie mit der Zentrale das Format des Lieferauftrags und mit der Kasse Zahlungsformat und Schlüsselregel.
KARTE1, ZENTRA, ALLE__, KASSE1.Preisliste (Aufgabe 4).POS, um zu wissen, dass der Kurier frei ist? Braucht sie auch seine Position (Bedingungskarte der Zentrale)?Ausgezeichnet – Alle Aufgaben abgeschlossen!
Ihr Entwurf steht. Prüfen Sie ihn:
Aufgaben: Stadtplan und Weg programmieren
Implementieren Sie die Lauflängencodierung und das Fahren in der Klasse Kurier (Datei Kurier.java) und testen Sie ohne Netz.
Material: Auszug der Klasse Kurier. Die beiden Methoden sind static, weil sie keine Attribute des Kuriers brauchen – so kann auch der Kartendienst sie ohne Kurier-Objekt aufrufen.
// ---- Selbsttest ----
// erwartet: 3r4s1g2r
println(Kurier.rleKodiere("rrrssssgrr"));
// erwartet: rrrssssgrr
println(Kurier.rleDekodiere("3r4s1g2r"));
// erwartet: 40
println(Kurier.rleDekodiere("40.").length());
class Kurier {
// ... (Aufgabe 3)
// RLE, Notation Anzahl-Wert: "rrrssssgrr" -> "3r4s1g2r"
public static String rleKodiere(String s) {
// TODO Teil b
return "";
}
// zurück: "3r4s1g2r" -> "rrrssssgrr"; Anzahlen auch mehrstellig
public static String rleDekodiere(String s) {
// TODO Teil c
return "";
}
}Entwerfen Sie auf Papier ein Struktogramm für rleKodiere(s: Zeichenkette): Zeichenkette. Erlaubt sind nur length, charAt, Verkettung und Vergleiche.
Hilfe 2: Ergänzen Sie die Lücken:
Ziel: Ihr Struktogramm läuft als Java-Methode. Fertig, wenn: Der Selbsttest zeigt 3r4s1g2r.
ergebnis = ergebnis + anzahl + wert; hängt die Zahl als Text und dann das Zeichen an.i + anzahl < s.length(), dann s.charAt(i + anzahl) – sonst gibt es am Textende einen Laufzeitfehler.Ziel: Auch mehrstellige Anzahlen (40., 11.) werden richtig gelesen. Fertig, wenn: Der Selbsttest zeigt rrrssssgrr und 40.
4 und 0 wird die Zahl 40 wie in zahlAus: anzahl = anzahl * 10 + ((int) c - 48);anzahl-mal an und setzen anzahl wieder auf 0.Erzeugen Sie einen Kurier mit dem Plan aus Listing K1, lassen Sie mit karteAlsText() den Text erzeugen (Zeilen mit / verbunden), codieren Sie ihn und prüfen Sie rleDekodiere(kodiert).equals(original). Geben Sie das Kompressionsverhältnis aus und vergleichen Sie mit Aufgabe 1 a).
(double) kodiert.length() / original.length().Material: Klassendiagramm, Selbsttest und Gerüst der Datei Kurier.java (Konstruktor, planeRoute, zeigeKarte, karteAlsText und zeilenAus sind fertig).
// ---- Selbsttest (plan wie in Listing K1) ----
Kurier k = new Kurier(plan, 5, 11);
String route = k.planeRoute(1, 6);
// erwartet: NNNNWWWWW
println(route);
// erwartet: true und danach 1 6
println(k.fahre(route));
println(k.getZeile() + " " + k.getSpalte());
// erwartet: false (nördlich liegt ein Häuserblock)
println(k.schritt('N'));
// erwartet: (1/7) (1/8) (1/9) (1/10) (1/11) ... (5/11)
println(k.fahreZurueck());
// erwartet: 5 11
println(k.getZeile() + " " + k.getSpalte());Gerüst der Klassen Punkt und Kurier anzeigen
class Punkt {
private int zeile;
private int spalte;
public Punkt(int zeile, int spalte) {
this.zeile = zeile;
this.spalte = spalte;
}
public int getZeile() { return zeile; }
public int getSpalte() { return spalte; }
}
class Kurier {
private char[][] karte;
private int zeile;
private int spalte;
// bisherige Positionen (Punkt)
private Stack route = new Stack();
public Kurier(String[] plan, int startZeile,
int startSpalte) {
karte = new char[plan.length][plan[0].length()];
for (int z = 0; z < plan.length; z++) {
for (int s = 0; s < plan[z].length(); s++) {
karte[z][s] = plan[z].charAt(s);
}
}
zeile = startZeile;
spalte = startSpalte;
}
public int getZeile() { return zeile; }
public int getSpalte() { return spalte; }
// ein Schritt in Richtung N, O, S oder W; nur über Straßen
public boolean schritt(char richtung) {
// TODO Teil a
return false;
}
// ganze Route fahren; false beim ersten unmöglichen Schritt
public boolean fahre(String richtungen) {
// TODO Teil a
return false;
}
// Rückweg über den Stapel; liefert die Positionen als Text
public String fahreZurueck() {
// TODO Teil b
return "";
}
// Fahrtenplan: erst bis zur Straße des Ziels, dann zum Ziel
public String planeRoute(int zz, int zs) {
String r = "";
int dz = Math.abs(zz - zeile);
int ds = Math.abs(zs - spalte);
if (zz == 1 || zz == 5 || zz == 9) {
r = r + wiederhole(senkrecht(zz - zeile), dz);
r = r + wiederhole(waagerecht(zs - spalte), ds);
} else {
r = r + wiederhole(waagerecht(zs - spalte), ds);
r = r + wiederhole(senkrecht(zz - zeile), dz);
}
return r;
}
private char senkrecht(int d) {
if (d < 0) { return 'N'; }
return 'S';
}
private char waagerecht(int d) {
if (d < 0) { return 'W'; }
return 'O';
}
private String wiederhole(char c, int n) {
String s = "";
for (int i = 0; i < n; i++) {
s = s + c;
}
return s;
}
public void zeigeKarte() {
for (int z = 0; z < karte.length; z++) {
String zeileText = "";
for (int s = 0; s < karte[z].length; s++) {
if (z == zeile && s == spalte) {
zeileText = zeileText + "@";
} else {
zeileText = zeileText + karte[z][s];
}
}
println(zeileText);
}
}
// Karte zeilenweise, getrennt durch '/'
public String karteAlsText() {
String t = "";
for (int z = 0; z < karte.length; z++) {
if (z > 0) {
t = t + "/";
}
for (int s = 0; s < karte[z].length; s++) {
t = t + karte[z][s];
}
}
return t;
}
// "ab/cd/ef" -> {"ab", "cd", "ef"} (ohne split)
public static String[] zeilenAus(String text) {
int anzahl = 1;
for (int i = 0; i < text.length(); i++) {
if (text.charAt(i) == '/') {
anzahl++;
}
}
String[] zeilen = new String[anzahl];
int nr = 0;
String aktuell = "";
for (int i = 0; i < text.length(); i++) {
char c = text.charAt(i);
if (c == '/') {
zeilen[nr] = aktuell;
nr++;
aktuell = "";
} else {
aktuell = aktuell + c;
}
}
zeilen[nr] = aktuell;
return zeilen;
}
// rleKodiere und rleDekodiere aus Aufgabe 2 hier einfügen
}Punkt und KurierZiel: Der Kurier fährt nur über Straßen und legt vor jedem Schritt die alte Position auf den Stapel. Fertig, wenn: Der Selbsttest zeigt true, 1 6 und false.
Implementieren Sie schritt(richtung): Das Zielfeld wird berechnet; liegt es außerhalb des Plans oder ist dort ein #, bleibt der Kurier stehen und liefert false. Sonst wird die alte Position als Punkt auf den Stapel gelegt und der Kurier bewegt sich. fahre(richtungen) fährt alle Schritte nacheinander und bricht beim ersten unmöglichen Schritt ab.
nz, ns für das Zielfeld. Erst nach der Prüfung wird gestapelt und bewegt.nz < 0 || nz >= karte.length || …), erst dann karte[nz][ns].route.push(new Punkt(zeile, spalte)); zeile = nz; spalte = ns;Ziel: Der Rückweg führt exakt über den Hinweg. Fertig, wenn: Der Selbsttest zeigt die Positionen von (1/7) bis (5/11) und danach 5 11.
Implementieren Sie fahreZurueck(): Solange der Stapel nicht leer ist, wird die oberste Position entnommen und der Kurier dorthin gesetzt. Rückgabe ist der Rückweg als Text. Begründen Sie im Protokollblatt, warum der Rückweg nicht noch einmal auf Befahrbarkeit geprüft werden muss.
while (!route.isEmpty()) schützt vor pop auf einem leeren Stapel.pop() liefert ein Object: Punkt p = (Punkt) route.pop();Schreiben Sie einen Selbsttest: Für jede der Zieladressen (1, 6), (3, 20), (5, 30), (9, 8), (7, 38), (10, 2), (0, 11), (2, 29), (1, 35), (9, 24), (6, 2), (5, 3) wird ein neuer Kurier an der Zentrale erzeugt, die Route geplant und gefahren, die Ankunft geprüft und zurückgefahren. Ausgabe: Ziel, Route, „OK“ oder „FEHLER“.
int[] zz = {1, 3, 5, …}; und int[] zs = {6, 20, 30, …}; mit demselben Index.Ausgezeichnet – Alle Aufgaben abgeschlossen!
Ihr Modul besteht den Selbsttest (Meilenstein M2). Prüfen Sie noch:
Aufgaben: KARTE1 und KURIR1 auf Sendung
Jetzt laufen zwei Stationen: der Kartendienst KARTE1 und die Kurierin KURIR1 – zwei Programme mit je eigenem rufzeichen, auf zwei Geräten bzw. mit zwei Konten.
Material: Klasse Preisliste (fertig), Klassen Kasse und Zahlung der Abteilung Kasse (Schnittstellenvertrag; bis dahin eine Ersatzfassung der Lehrkraft), Schlüsselregel der Kasse.
Klasse Preisliste anzeigen
class Preisliste {
// Preis in Cent, 0 = unbekannt
public static int preis(String gericht) {
if (gericht.equals("PIZZA")) { return 850; }
if (gericht.equals("PASTA")) { return 790; }
if (gericht.equals("BURGER")) { return 690; }
if (gericht.equals("SALAT")) { return 590; }
if (gericht.equals("POMMES")) { return 350; }
if (gericht.equals("COLA")) { return 250; }
if (gericht.equals("MENUE")) { return 1290; }
return 0;
}
// "2xPIZZA,1xCOLA" -> 1950; Klammerinhalte zählen nicht
public static int summe(String t) {
int summe = 0;
int i = 0;
while (i < t.length()) {
int anzahl = (int) t.charAt(i) - 48;
// Ziffer und 'x' überspringen
i = i + 2;
String gericht = "";
while (i < t.length() && t.charAt(i) >= 'A'
&& t.charAt(i) <= 'Z') {
gericht = gericht + t.charAt(i);
i++;
}
summe = summe + anzahl * preis(gericht);
// Klammerinhalt bis zum nächsten Komma überspringen
int tiefe = 0;
while (i < t.length()
&& (tiefe > 0 || t.charAt(i) != ',')) {
if (t.charAt(i) == '(') { tiefe++; }
if (t.charAt(i) == ')') { tiefe--; }
i++;
}
// Komma überspringen
i++;
}
return summe;
}
}Preisliste// in der Station KARTE1
private String[] plan = { /* die 12 Zeilen aus Listing K1 */ };
private synchronized void verarbeite(Paket p, String text) {
// TODO Teil a: leere KRT-Anforderung beantworten
}
// in der Station KURIR1 (andere Datei, anderes Gerät)
// null, bis der Plan da ist
private Kurier kurier = null;
private Kasse kasse = new Kasse();
// Schlüssel nach der Schlüsselregel der Kasse
private String schluessel = "";
private synchronized void verarbeite(Paket p, String text) {
String typ = p.getTyp();
if (typ.equals("KRT") && p.getAbsender().equals("KARTE1")) {
// TODO Teil a: Plan auspacken, Kurier erzeugen, frei melden
} else if (typ.equals("BST") && kurier != null) {
liefere(text);
}
}
// TODO Teil b
private void liefere(String text) {
}KARTE1 und KURIR1Ergänzen Sie verarbeite der Station KARTE1: Auf jede KRT-Anforderung mit leeren Nutzdaten antwortet sie dem Absender mit dem lauflängencodierten Plan. Beim Start fordert KURIR1 den Plan an (im Hauptprogramm nach dem Verbinden). Kommt die Antwort, wird der Plan decodiert, in Zeilen zerlegt, die Kurierin an der Zentrale erzeugt und die Freimeldung an die Zentrale gesendet.
p.getAbsender() – so funktioniert der Dienst für beliebig viele Kuriere. Das Zerlegen in Pakete erledigt der Kern.KURIR1: station.sende("KARTE1", "KRT", "");. Solange kein Plan da ist, ist kurier noch null – deshalb meldet sich die Station erst nach dem Plan frei.plan.length und die Länge jeder Zeile; fordern Sie sonst neu an.Implementieren Sie liefere(text): Lieferauftrag nach Ihrem Vertrag zerlegen, ABH melden, Route fahren (nach jedem Schritt 200 ms warten; Karte K-B: Plan zeigen; Karte K-C: Position melden), LIE melden, Zahlung verschlüsselt an die Kasse schicken, zurückfahren, frei melden.
zahlAus (in die Station kopieren). Bei einem unlesbaren Auftrag: Meldung ausgeben, nicht losfahren.char art = 'K'; if (Math.random() < 0.5) { art = 'B'; }. Die Zahlung bauen Sie mit der Klasse Zahlung der Kasse und verschlüsseln sie mit kasse.vigenereVer(…, schluessel).Thread.sleep(200); zwischen den Schritten macht die Fahrt im Go-Live sichtbar.verarbeite kein Thread.sleep stehen. Fahren Sie schrittweise mit Timer.executeLater(() -> naechsterSchritt(), 200); – jeder Schritt plant den nächsten, der letzte meldet LIE.Testen Sie mit der Zentrale und der Kasse im Gruppen-Sitzungscode – erst ohne Störung, dann mit Ihrem Störungsprofil. Prüfen Sie insbesondere: Kommt der Plan trotz Störung vollständig an? Kann die Kasse Ihre Zahlung entschlüsseln und buchen? Halten Sie Testfall – erwartet – beobachtet – Ursache fest.
plan.length und plan[0].length() aus – es müssen 12 und 40 sein.Ausgezeichnet – Alle Aufgaben abgeschlossen!
Ihre Kurierin ist auf Tour (Meilenstein M3). Prüfen Sie:
Aufgaben: Baustellen und sichere Zahlung eA
Die Kurierin findet auch um Baustellen herum ans Ziel und tauscht mit der Kasse einen Schlüssel aus.
Material: Auf dem Neuen Graben ist eine Baustelle: Feld (5, 15) ist mit X gesperrt. Der Fahrtenplan zu Kunde 0007 (5, 30) bleibt nach drei Schritten stecken (fahre liefert false, Kim steht auf (5, 14)).
Ein Verfahren, das immer einen Weg findet, wenn es einen gibt (Backtracking): Probiere die Richtungen in der Reihenfolge N, O, S, W; gehe nur auf befahrbare, noch nicht besuchte Felder und lege dabei die alte Position auf einen Stapel; geht es nicht weiter, nimm die oberste Position vom Stapel und gehe dorthin zurück. Führen Sie die ersten 10 Schritte für Start (5, 11) und Ziel (5, 30) von Hand aus. Ergänzen Sie außerdem schritt so, dass auch X gesperrt ist.
besucht[zeile][spalte] – sonst läuft die Suche im Kreis.Ziel: Eine Route um die Baustelle herum. Fertig, wenn: fahre(sucheWeg(…)) mit Baustelle bei (5, 30) ankommt.
Implementieren Sie public static String sucheWeg(String[] plan, int sz, int ss, int zz, int zs) in einer Klasse Wegsuche. Rückgabe: Route aus N, O, S, W oder "", wenn es keinen Weg gibt. Bauen Sie die Baustelle in den Plan ein und testen Sie.
besucht setzen, Richtung an die Route hängen; sonst – wenn der Stapel leer ist, gibt es keinen Weg – oberste Position vom Stapel holen und das letzte Zeichen der Route entfernen.route = route.substring(0, route.length() - 1); Die Baustelle setzen Sie z. B. mit plan[5] = plan[5].substring(0, 15) + "X" + plan[5].substring(16);Der kürzeste Weg mit Baustelle hat 27 Schritte. Erklären Sie, warum Ihre Tiefensuche einen deutlich längeren Weg findet, und beschreiben Sie, wie eine Breitensuche mit einer Schlange (Queue) den kürzesten Weg findet.
Material: Schnittstellenvertrag mit der Kasse (KEY-Format, Signaturregel), Klasse Kasse mit potenzMod, schluesselAus und signiere (Abteilung Kasse, Aufgabe 6 und 7).
Ergänzen Sie KURIR1: Beim Start wählt die Kurierin eine geheime Zufallszahl a (2 bis 21), sendet KEY mit ihrem öffentlichen Wert an KASSE1 und berechnet aus der Antwort den gemeinsamen Schlüssel. Jede Zahlung wird mit schluesselAus(K) verschlüsselt und nach der Regel der Kasse signiert. Zeigen Sie im Logbuch oder Lausch-Client, dass weder a noch K über Funk gehen.
int a = 2 + (int) (Math.random() * 20);. Den öffentlichen Wert berechnet kasse.potenzMod(5, a, 23).KEY-Antwort fällig werden, warten: Merken Sie sie sich und senden Sie sie, sobald der Schlüssel da ist.Ausgezeichnet – Alle Aufgaben abgeschlossen!
Ihre Erweiterung läuft (Meilenstein M4). Prüfen Sie:
Sicherung
Verlustfreies Kompressionsverfahren, das jede Folge gleicher Zeichen durch ihre Anzahl und das Zeichen ersetzt (Notation Anzahl-Wert, z. B. 3r4s1g2r).
Lauflängencodierung ersetzt Läufe gleicher Werte durch Anzahl-Wert (3r4s1g2r). Sie ist verlustfrei und lohnt sich bei langen Läufen; Kompressionsverhältnis = komprimiert / original. Welches Verfahren am kürzesten ist, hängt vom Kanal ab: In Bit gemessen gewinnt Huffman, im Zeichenkanal RLE. Ein 2D-Array speichert den Plan als karte[zeile][spalte]. Ein Stapel (LIFO) liefert die besuchten Positionen in umgekehrter Reihenfolge – genau die Reihenfolge des Rückwegs. Vor pop wird mit isEmpty geprüft, vor jedem Array-Zugriff die Grenzen.
Diese Pakete tauschen Kartendienst und Kurier aus.
| Station | Richtung | Typ | Partner | Nutzdaten |
|---|---|---|---|---|
| KARTE1 | empfängt / sendet | KRT | jeder Kurier | leer / Zeilen mit /, RLE |
| KURIRn | sendet | POS | ZENTRA | laut Vertrag |
| KURIRn | empfängt | BST | ZENTRA | Lieferauftrag laut Vertrag |
| KURIRn | sendet | STA | ALLE__ | NNN + ABH bzw. LIE |
| KURIRn | sendet | ZAH | KASSE1 | laut Vertrag, verschlüsselt |
eA KURIRn | sendet / empfängt | KEY | KASSE1 | laut Vertrag |
Vergleichen Sie Ihren Plan aus dem Einstieg mit Ihrer fertigen Station: Welche Plan-Punkte haben sich bestätigt, welche mussten Sie ändern – und warum?
Lauflängencodiert passt der Plan in 4 statt 9 Pakete, und der erste Auftrag muss nicht mehr eine halbe Minute warten. Weil Kim vor jedem Schritt ihre alte Position auf den Stapel legt, liefert pop den Rückweg in genau der richtigen Reihenfolge – über die Straßen, die sie wirklich gefahren ist, auch nach einer Umleitung.
Abteilung Kundenverzeichnis
Worum es geht: Die Kundenliste ist zu lang zum Durchsuchen, und über Funk gehen Namen und Telefonnummern. → Das Kundenverzeichnis findet Adressen in einem binären Suchbaum und antwortet nur mit dem, was die Lieferung wirklich braucht.
Einstieg: Kundin 3987 und Pizza Paradiso
Bisher stand die Kundenliste als Textdatei in der Zentrale – mit Namen, Telefonnummern und Adressen. Zwei Vorfälle aus der letzten Woche:
Montag, 18:40 Uhr: Food Now! hat inzwischen 4 000 Kundinnen und Kunden. Die Zentrale geht bei jeder Bestellung die Liste von oben nach unten durch und braucht für Kundin 3987 fast so lange wie für die ganze Liste. Drei Bestellungen warten.
Dienstag, 19:15 Uhr:
19:15:02 ZENTRA → ALLE__ BST M.Schulte,Hasestr.12,2xPIZZA
// dazu Telefonnummer und Kundennummer im zweiten TeilPizza Paradiso hört mit. Am nächsten Tag liegt bei Mia Schulte Werbung im Briefkasten – mit ihrem Namen und ihrer Lieblingspizza.
Leitfrage: Wie kann ein eigenes Kundenverzeichnis Adressen schnell finden und dabei möglichst wenig über die Kundschaft verraten?
Nebenfragen:
- Wie viele Vergleiche braucht man höchstens, um unter 4 000 Kundennummern die richtige zu finden?
- Welche Angaben über die Kundschaft braucht das Liefernetz wirklich?
Sammeln Sie in der Gruppe: Problem → Idee → offene Frage.
- Wie suchen Sie ein Wort im Wörterbuch? Wie viele Seiten schlagen Sie dabei höchstens auf?
- Streichen Sie in der Kundenliste (Tabelle V1) alle Angaben, die für eine Lieferung nicht nötig sind.
- Was müssen eine Adressanfrage und eine Adressantwort enthalten – und was nicht?
Tragen Sie den Plan als Protokollblatt v0.1 ein (Abschnitte 2, 3 und 6) und zeigen Sie ihn der Lehrkraft (Plan-Ticket). Danach beginnt Aufgabe 1.
- Der Suchbaum hat höchstens die Höhe 4 (Einfügereihenfolge selbst festlegen).
- In der Adressantwort stehen nur Daten, die für die Lieferung wirklich nötig sind.
- Unbekannte Kunden werden eindeutig gemeldet.
- eA Kunden können gelöscht werden, ohne dass der Baum neu aufgebaut wird.
- Der Suchbaum hat höchstens die Höhe 4, und die Vielbesteller 0042 und 0815 stehen auf Ebene 1 oder 2.
- Eine Antwort enthält nie die Kundennummer; Anfrage und Antwort werden anders zugeordnet.
- Die Antwort unterscheidet „Kunde unbekannt“ von „Anfrage unlesbar“.
- eA Kunden können gelöscht werden, ohne dass der Baum neu aufgebaut wird.
Material für alle Aufgaben: Kundenliste des Kundenbüros in Anmeldereihenfolge. Das Pseudonym hat sich jede Person in der App selbst gegeben. Die Lage bezieht sich auf den Stadtplan der Abteilung Kurier (Zeile/Spalte).
| Kundennr. | Name | Telefon | Pseudonym | Adresse (Lage) |
|---|---|---|---|---|
| 0042 | Mia Schulte | 0541 000 001 | Hungrig42 | Hasestr. 12 (1/6) |
| 0815 | Jonas Meyer | 0541 000 002 | Pizzafan | Johannisstr. 3 (3/20) |
| 0007 | Lea Hoffmann | 0541 000 003 | Nachtschicht | Neuer Graben 30 (5/30) |
| 0350 | Ben Wagner | 0541 000 004 | Veggie | Iburger Str. 8 (9/8) |
| 1200 | Emma Becker | 0541 000 005 | Sportlerin | Natruper Str. 21 (7/38) |
| 0123 | Paul Schröder | 0541 000 006 | Pastaliebe | Lotter Str. 5 (10/2) |
| 0500 | Hanna Koch | 0541 000 007 | Spaetdienst | Martinistr. 44 (0/11) |
| 0999 | Finn Richter | 0541 000 008 | Burgerboss | Bramscher Str. 2 (2/29) |
| 0271 | Lina Wolf | 0541 000 009 | Salatbar | Hasestr. 40 (1/35) |
| 0640 | Noah Klein | 0541 000 010 | Familie5 | Iburger Str. 27 (9/24) |
| 0077 | Sophie Neumann | 0541 000 011 | Studi77 | Lotter Str. 19 (6/2) |
| 1024 | Elias Braun | 0541 000 012 | Bytehunger | Neuer Graben 3 (5/3) |
| ★ 9001 | Ida Lange | 05405 000 001 | Landluft | Hasbergen, Am Bahnhof 1 (Außenfiliale) |
| ★ 9002 | Tom Krüger | 05405 000 002 | Bahnfahrer | Hasbergen, Lindenstr. 9 (Außenfiliale) |
Die mit ★ markierten Kunden gibt es nur im eA-Kurs: Sie wohnen im Bereich der Außenfiliale Hasbergen (Lage mit der Zentrale vereinbaren, z. B. Zeile 99).
Aufgaben: Das Verzeichnis entwerfen
Planen Sie den Suchbaum und die Schnittstelle zur Zentrale. Halten Sie alles im Protokollblatt fest.
Material: Kundenliste (ohne die ★-Kunden), Ihre Bedingungskarte.
Fügen Sie die zwölf Kundennummern in der Anmeldereihenfolge in einen leeren binären Suchbaum ein. Zeichnen Sie den Baum und geben Sie seine Höhe an.
Geben Sie die Suchwege für 0640 und für 0043 (nicht vorhanden) an und zählen Sie die besuchten Knoten. Wie hoch wird der Baum, wenn die zwölf Nummern aufsteigend sortiert eingefügt werden? Wie viele Knoten besucht eine Suche dann im schlechtesten Fall?
Erfüllen Sie Bedingung 1 Ihrer Karte: Geben Sie eine Einfügereihenfolge der zwölf Nummern an und weisen Sie nach, dass der Baum die Bedingung erfüllt. Begründen Sie, warum mit zwölf Kunden keine kleinere Höhe als 4 möglich ist.
Entscheiden Sie, welche Spalten der Kundenliste ins Verzeichnis gehören und welche Angaben in der Adressantwort über Funk gehen. Entwerfen Sie mit der Zentrale das Format der Antwort (auch für „unbekannt“, Karte V-b zusätzlich „unlesbar“) als Formattabelle (Position, Länge, Inhalt, Wertebereich, Beispiel). Begründen Sie mit den Grundsätzen Datensparsamkeit und Zweckbindung.
Ausgezeichnet – Alle Aufgaben abgeschlossen!
Ihr Entwurf steht. Prüfen Sie ihn:
Aufgaben: Den Suchbaum programmieren
Implementieren Sie Kunde und Kundenverzeichnis als eigene Datei Kundenverzeichnis.java und testen Sie ohne Netz (Bibliothek „Abiturklassen Niedersachsen“ einschalten).
Material: Klassendiagramm, Selbsttest und Gerüst. Tragen Sie vor dem Programmieren die Anfragen und erwarteten Antworten aus Ihrem Schnittstellenvertrag ein.
// ---- Selbsttest (Hauptprogramm) ----
Kundenverzeichnis v = new Kundenverzeichnis();
v.fuegeEin(new Kunde(42, "Hungrig42", "Hasestr. 12", 1, 6));
v.fuegeEin(new Kunde(815, "Pizzafan", "Johannisstr. 3", 3, 20));
v.fuegeEin(new Kunde(7, "Nachtschicht", "Neuer Graben 30", 5, 30));
// wird abgelehnt: Nummer 42 ist schon vergeben
v.fuegeEin(new Kunde(42, "Doppelt", "gibt es schon", 0, 0));
// erwartet: 7, 42, 815 (aufsteigend)
v.zeigeSortiert();
// erwartet: 3 Kunden, Höhe 2
println(v.anzahl() + " Kunden, Höhe " + v.hoehe());
// erwartet: Pizzafan
println(v.suche(815).getPseudonym());
// erwartet: true (0043 gibt es nicht)
println(v.suche(43) == null);
// Anfragen aus Ihrem Schnittstellenvertrag eintragen:
// Bestellung 17, Kunde 0042
String anfrage1 = "________";
// Bestellung 18, Kunde 0043 (unbekannt)
String anfrage2 = "________";
// erwartet laut Protokollblatt: ________
println(v.beantworte(anfrage1));
// erwartet laut Protokollblatt: ________
println(v.beantworte(anfrage2));
// unlesbare Anfrage; erwartet laut Protokollblatt: ________
println("[" + v.beantworte("01X") + "]");Kundenverzeichnis.javaGerüst der Klassen Kunde und Kundenverzeichnis anzeigen
class Kunde {
private int nr;
private String pseudonym;
private String adresse;
private int zeile;
private int spalte;
public Kunde(int nr, String pseudonym, String adresse,
int zeile, int spalte) {
this.nr = nr;
this.pseudonym = pseudonym;
this.adresse = adresse;
this.zeile = zeile;
this.spalte = spalte;
}
public int getNr() { return nr; }
public String getPseudonym() { return pseudonym; }
public String getAdresse() { return adresse; }
public int getZeile() { return zeile; }
public int getSpalte() { return spalte; }
}
class Kundenverzeichnis {
// Feldpositionen Ihres Anfrageformats
// TODO Teil d: Werte laut Schnittstellenvertrag eintragen
private int ANFRAGE_LAENGE = 0;
private int POS_KUNDENNR = 0;
private BinTree wurzel = new BinTree();
public void fuegeEin(Kunde k) {
fuegeEin(wurzel, k);
}
private void fuegeEin(BinTree b, Kunde k) {
// TODO Teil a
}
// Kunde zur Nummer oder null
public Kunde suche(int nr) {
// TODO Teil b
return null;
}
public int anzahl() {
return anzahl(wurzel);
}
private int anzahl(BinTree b) {
if (b.isEmpty()) {
return 0;
}
return 1 + anzahl(b.getLeft()) + anzahl(b.getRight());
}
public int hoehe() {
return hoehe(wurzel);
}
private int hoehe(BinTree b) {
// TODO Teil c
return 0;
}
public void zeigeSortiert() {
println("--- Kundenverzeichnis ---", Color.aquamarine);
inorder(wurzel);
}
private void inorder(BinTree b) {
// TODO Teil c
}
// Antwort im Format laut Schnittstellenvertrag
public String beantworte(String anfrage) {
// TODO Teil d
return "";
}
public String mitNullen(int zahl, int stellen) {
String s = "" + zahl;
while (s.length() < stellen) {
s = "0" + s;
}
return s;
}
}Kunde und KundenverzeichnisZiel: Kunden landen an der richtigen Stelle, doppelte Nummern werden gemeldet. Fertig, wenn: Der doppelte Kunde 42 erzeugt eine Meldung.
Implementieren Sie fuegeEin(b, k) rekursiv. Eine Kundennummer, die schon vorhanden ist, wird nicht noch einmal eingefügt, sondern gemeldet.
b leer ist? Was, wenn nicht?b.setItem(k) den Kunden als Wurzel; laut Abitur-Signatur erhält er dabei zwei leere Teilbäume. Sonst holen Sie den vorhandenen Kunden mit Kunde vorhanden = (Kunde) b.getItem(); und vergleichen die Nummern.fuegeEin(b.getLeft(), k), fuegeEin(b.getRight(), k) oder Meldung „schon vergeben“.Ziel: Eine Suche ohne Rekursion, die nie getItem() auf einem leeren Baum aufruft. Fertig, wenn: Der Selbsttest Pizzafan und true zeigt.
Stellen Sie suche(nr) zuerst auf Papier als Struktogramm dar (mit einer Schleife, die von der Wurzel aus nach unten läuft), und implementieren Sie es dann. Wird die Nummer nicht gefunden, ist das Ergebnis null.
b zeigt auf den aktuellen Teilbaum. Was ist zu tun, solange er nicht leer ist?Hilfe 2: Ergänzen Sie die Lücken:
b.isEmpty() würde getItem() auf einem leeren Baum aufgerufen – das muss laut Abitur-Hinweisen ausgeschlossen werden. Beim Lesen umwandeln: Kunde k = (Kunde) b.getItem();Ziel: Sie können nachweisen, dass Ihr Baum Bedingung 1 erfüllt. Fertig, wenn: Der Selbsttest 3 Kunden, Höhe 2 zeigt und Ihr geplanter Baum aus allen zwölf Kunden die Höhe 4 hat.
Implementieren Sie hoehe(b) (leerer Baum: 0) und inorder(b) (alle Kunden aufsteigend nach Kundennummer: Nummer, Pseudonym, Adresse). Testen Sie mit beiden Einfügereihenfolgen aus Aufgabe 1.
Math.max).Ziel: Die Antwort entspricht genau Ihrem Vertrag. Fertig, wenn: Die drei beantworte-Zeilen Ihre eingetragenen Erwartungen zeigen.
Tragen Sie die Feldpositionen Ihres Anfrageformats ein und implementieren Sie beantworte(anfrage). Anfragen mit falscher Länge oder unlesbarer Kundennummer werden so behandelt, wie Ihr Vertrag es festlegt.
zahlAus und prüfen dabei jedes Zeichen.mitNullen(k.getZeile(), 2).Ausgezeichnet – Alle Aufgaben abgeschlossen!
Ihr Modul besteht den Selbsttest (Meilenstein M2). Prüfen Sie noch:
Aufgaben: Station KUNDEN anbinden
Kopieren Sie Kunde und Kundenverzeichnis ohne das Hauptprogramm in den Workspace mit Ihrer Station und setzen Sie rufzeichen = "KUNDEN".
Material: Ihre Station, Kundenliste, Ihre geplante Einfügereihenfolge.
Beim Start werden die Kunden in Ihrer geplanten Reihenfolge eingefügt. verarbeite beantwortet jede ADR-Anfrage an den Absender.
lade() der Station, die das Hauptprogramm vor dem Verbinden aufruft.p.getAbsender(). Was tun Sie, wenn beantworte laut Ihrem Vertrag nichts liefern soll?Testen Sie im Gruppen-Sitzungscode mit der Zentrale: bekannte Kunden, unbekannter Kunde, mehrere Bestellungen schnell hintereinander, 10 % Verlust. Halten Sie Testfall – erwartet – beobachtet – Ursache fest. Prüfen Sie im Mitschnitt (Lausch-Client oder Logbuch), dass keine Namen, Pseudonyme und Adressen übertragen werden.
ADR), Länge der Anfrage und Reihenfolge der Felder in beiden Programmen überein?rufzeichen = "ZENTRA" und demo = false von Hand – oder testen Sie gegen die Ersatzstation in FN-<Kurs>-TEST.Ausgezeichnet – Alle Aufgaben abgeschlossen!
Ihr Verzeichnis ist auf Sendung (Meilenstein M3). Prüfen Sie:
Aufgaben: Recht auf Löschung und ausgeglichene Bäume eA
Kundinnen und Kunden dürfen verlangen, gelöscht zu werden – und der Baum soll trotzdem flach bleiben.
Material: Lina Wolf (0271) schreibt: „Bitte löschen Sie alle meine Daten.“ Nach Art. 17 DSGVO (Recht auf Löschung) muss Food Now! personenbezogene Daten löschen, sobald sie für den Zweck nicht mehr nötig sind und keine Aufbewahrungspflicht besteht. Bedingung 4 Ihrer Karte: Löschen ohne Neuaufbau des Baums.
Löschen Sie im Baum aus Aufgabe 1 a) nacheinander 0077, dann 1200, dann 0350. Beschreiben Sie für jeden Fall die Regel und zeichnen Sie den Baum danach.
Implementieren Sie loesche(nr) mit einer rekursiven Hilfsmethode. Nutzen Sie nur die Abitur-Operationen von BinTree (setItem, setLeft, setRight, setEmpty, isLeaf …). Testen Sie die drei Fälle aus Teil a) mit zeigeSortiert und hoehe.
Beurteilen Sie: Ist Lina Wolf nach loesche(271) „vergessen“? Beziehen Sie das Logbuch, die Kundenliste des Kundenbüros und die Aufbewahrungspflicht für Rechnungen ein.
KUNDE1 und jede Adressanfrage, die alle Stationen mithören.Nach vielen Neuanmeldungen mit aufsteigenden Nummern wird der Baum hoch. Implementieren Sie ausgleichen(): Alle Kunden werden inorder in eine DynArray gesammelt; daraus wird rekursiv ein neuer Baum gebaut, dessen Wurzel jeweils das mittlere Element ist. Testen Sie mit dem Baum aus Aufgabe 1 a).
baue(liste, von, bis): Ist von > bis, entsteht ein leerer Baum. Sonst ist mitte = (von + bis) / 2 die Wurzel, links steht baue(liste, von, mitte − 1), rechts baue(liste, mitte + 1, bis).new BinTree(inhalt) erzeugt einen Baum mit dieser Wurzel und zwei leeren Teilbäumen.Schätzen Sie für 4 000 Kunden ab: Wie viele Vergleiche braucht eine Suche höchstens (sortiert eingefügt / ausgeglichen / lineare Liste)? Wie oft sollte ausgeglichen werden?
Ausgezeichnet – Alle Aufgaben abgeschlossen!
Ihre Erweiterung läuft (Meilenstein M4). Prüfen Sie:
Sicherung
Ein Binärbaum, in dem für jeden Knoten alle Schlüssel im linken Teilbaum kleiner und alle im rechten Teilbaum größer sind als sein eigener Schlüssel.
In einem binären Suchbaum stehen links kleinere, rechts größere Schlüssel. Einfügen und Suchen gehen von der Wurzel aus; der Aufwand entspricht höchstens der Höhe des Baums – im besten Fall etwa \(\log_2 n\), im schlechtesten n. Die Höhe hängt von der Einfügereihenfolge ab. Jede Operation prüft zuerst isEmpty(); gelesene Inhalte werden mit (Kunde) umgewandelt. Datensparsamkeit beginnt beim Entwurf: Was nicht gespeichert oder gesendet wird, kann niemand mitlesen. Kundennummer und Pseudonym schützen, machen die Daten aber nicht anonym.
Diese Pakete tauscht das Kundenverzeichnis mit der Zentrale aus.
| Richtung | Typ | Partner | Nutzdaten |
|---|---|---|---|
| empfängt | ADR | ZENTRA | Anfrage laut Vertrag |
| sendet | ADR | ZENTRA | Antwort laut Vertrag, auch „unbekannt“ |
Vergleichen Sie Ihren Plan aus dem Einstieg mit Ihrer fertigen Station: Welche Plan-Punkte haben sich bestätigt, welche mussten Sie ändern – und warum?
Ein gut aufgebauter Suchbaum findet Kundin 3987 unter 4 000 Kunden mit höchstens 12 Vergleichen statt bis zu 4 000. Über Funk gehen weder Name noch Telefonnummer, sondern nur, was die Lieferung braucht – Pizza Paradiso kann daraus keine Werbung mehr adressieren. Ganz anonym ist das Liefernetz trotzdem nicht: Wer lange mithört, kann aus der Lage auf Adressen schließen.
Abteilung Kasse
Worum es geht: Jede Station liest die Zahlungen mit – auch nachdem die Kasse verschlüsselt. → Die Kasse entwirft einen Klartext, den Vigenère vollständig verschlüsselt, führt ein Kassenbuch ohne Doppelbuchungen und regelt, wie der Schlüssel zur Kurierin kommt.
Einstieg: Alle lesen mit
Am Ende der ersten Probe zeigt der Lausch-Client am Beamer, was alle Stationen mitgehört haben:
19:21:55 KURIR1 → KASSE1 ZAH ZAHLUNG 19,50 EUR KUNDE 0042
// Fortsetzung: KARTE
19:24:10 KURIR1 → KASSE1 ZAH ZAHLUNG 9,50 EUR KUNDE 1200
// Fortsetzung: BARDie Kasse reagiert sofort und verschlüsselt ab jetzt mit Vigenère (Schlüssel PIZZA), wie auf der Kryptologie-Seite gelernt. Am nächsten Abend:
20:05:31 KURIR1 → KASSE1 ZAH OIGKUCO 19,50 DTR ZCMCE 0042
// Fortsetzung: ZIQSE
20:05:40 PIZPAR → ALLE__ STA Umsatz heute 312,40 EUR :-)Pizza Paradiso kennt weiterhin jeden Betrag und jede Kundennummer. Außerdem steht der Schlüssel PIZZA im Quelltext der Kurier-Gruppe – und den haben schon drei Gruppen gesehen.
Leitfrage: Wie muss eine Zahlung aussehen und übertragen werden, damit Mithörer weder Betrag noch Bestellung erfahren?
Nebenfragen:
- Warum hilft die Vigenère-Verschlüsselung hier fast nichts? Was müsste sich am Klartext ändern?
- Wie kommt der Schlüssel zur Kurierin, ohne dass ihn alle anderen erfahren?
Sammeln Sie in der Gruppe: Problem → Idee → offene Frage.
- Markieren Sie im verschlüsselten Mitschnitt alles, was ein Angreifer noch lesen kann.
- Wie könnte man Ziffern so umschreiben, dass Vigenère sie verschlüsselt? (Verschlüsselt wird nur A–Z.)
- Sammeln Sie Wege, einen Schlüssel zu übergeben. Welche sind sicher, welche bequem? Wie verhindert die Kasse, dass eine Bestellung zweimal gebucht wird?
Tragen Sie den Plan als Protokollblatt v0.1 ein (Abschnitte 2, 3 und 6) und zeigen Sie ihn der Lehrkraft (Plan-Ticket). Danach beginnt Aufgabe 1.
- Vigenère nach Abitur-Konvention (nur A–Z).
- Kein Bestandteil der Zahlung (Bestellnummer, Betrag in Cent, Zahlungsart) ist im Geheimtext lesbar oder an Wortgrenzen erkennbar.
- Eine Bestellung wird nur einmal gebucht.
- eA Kein Schlüssel steht im Quelltext.
- eA Gefälschte Zahlungen werden erkannt.
- Vigenère nach Abitur-Konvention (nur A–Z).
- Die Zahlungsart steht an erster Stelle, der Betrag wird in 10-Cent-Schritten übertragen; kein Bestandteil ist im Geheimtext lesbar.
- Eine Bestellung wird nur einmal gebucht; Zahlungen mit dem Betrag 0,00 € werden abgewiesen.
- eA Kein Schlüssel steht im Quelltext.
- eA Gefälschte Zahlungen werden erkannt.
Aufgaben: Die Zahlung entwerfen
Ergebnis dieses Abschnitts: Zahlungsformat und Schlüsselregel im Protokollblatt und im Schnittstellenvertrag mit den Kurier-Gruppen.
Material: Vigenère-Quadrat (Kryptologie-Seite), Mitschnitte aus dem Einstieg. Konvention nach den Abitur-Hinweisen: Nur A–Z wird verschlüsselt; andere Zeichen bleiben unverändert, und der Schlüssel rückt dabei nicht weiter.
Verschlüsseln Sie ZAHLUNG 19,50 EUR BESTELLUNG 017 mit dem Schlüssel HASE nach dem Vigenère-Verfahren. Markieren Sie, was ein Angreifer danach noch lesen oder erschließen kann.
ZAHLUNG (Schlüssel H A S E H A S) geht es bei EUR mit E weiter.Entwerfen Sie ein Klartextformat für eine Zahlung, das Bedingung 2 Ihrer Karte erfüllt (Bestellnummer, Betrag, Zahlungsart B = bar / K = Karte), als Formattabelle (Position, Länge, Inhalt, Wertebereich, Beispiel). Verschlüsseln Sie das Beispiel „Bestellung 017, 19,50 €, Karte“ mit HASE und prüfen Sie: Was kann ein Angreifer jetzt noch erkennen?
substring.Legen Sie fest, wie der Schlüssel zu den Kurier-Gruppen kommt, wo er im Programm steht und wann er gewechselt wird. Beurteilen Sie Ihre Regel: Wer kann den Schlüssel trotzdem erfahren?
Ausgezeichnet – Alle Aufgaben abgeschlossen!
Ihr Entwurf steht. Prüfen Sie ihn:
Aufgaben: Verschlüsseln und buchen
Implementieren Sie die Klassen Kasse, Zahlung und Kassenbuch als eigene Datei Kasse.java und testen Sie ohne Netz. Die Klassen Kasse und Zahlung geben Sie danach an die Kurier-Gruppen weiter.
Material: Selbsttest und Gerüst. Tragen Sie die erwarteten Werte zu Ihrem Klartextformat vor dem Programmieren ein.
// ---- Selbsttest (Hauptprogramm) ----
Kasse kasse = new Kasse();
// erwartet: REJVS
println(kasse.vigenereVer("HALLO", "KEY"));
// erwartet: GAZPBNY 19,50 IBR
println(kasse.vigenereVer("ZAHLUNG 19,50 EUR", "HASE"));
// erwartet: HALLO
println(kasse.vigenereEnt("REJVS", "KEY"));
Zahlung z = new Zahlung(17, 1950, 'K');
String klar = z.alsKlartext();
// erwartet laut Protokollblatt: ________
println(klar);
String geheim = kasse.vigenereVer(klar, "HASE");
// erwartet laut Protokollblatt: ________
println(geheim);
String zurueckKlar = kasse.vigenereEnt(geheim, "HASE");
Zahlung zurueck = Zahlung.ausKlartext(zurueckKlar);
// erwartet: 17 1950 K
println(zurueck.getBestellnr() + " " + zurueck.getCent()
+ " " + zurueck.getArt());
// erwartet: true (zu kurz für jedes Format)
println(Zahlung.ausKlartext("ABC") == null);Kasse.javaGerüst der Klassen Kasse und Zahlung anzeigen
class Kasse {
// Vigenère verschlüsseln (nur A-Z)
public String vigenereVer(String text, String schluessel) {
// TODO Teil a
return "";
}
// Vigenère entschlüsseln
public String vigenereEnt(String text, String schluessel) {
// TODO Teil b
return "";
}
public String mitNullen(int zahl, int stellen) {
String s = "" + zahl;
while (s.length() < stellen) {
s = "0" + s;
}
return s;
}
}
class Zahlung {
private int bestellnr;
private int cent;
// 'B' bar, 'K' Karte
private char art;
public Zahlung(int bestellnr, int cent, char art) {
this.bestellnr = bestellnr;
this.cent = cent;
this.art = art;
}
public int getBestellnr() { return bestellnr; }
public int getCent() { return cent; }
public char getArt() { return art; }
// Klartext im Format laut Schnittstellenvertrag
public String alsKlartext() {
// TODO Teil c
return "";
}
// Gegenstück; null, wenn der Text nicht ins Format passt
public static Zahlung ausKlartext(String k) {
// TODO Teil c
return null;
}
}Kasse und ZahlungZiel: Verschlüsseln nach Abitur-Konvention. Fertig, wenn: Der Selbsttest REJVS und GAZPBNY 19,50 IBR zeigt.
Stellen Sie den Algorithmus zuerst auf Papier als Struktogramm dar und implementieren Sie dann vigenereVer.
i läuft über den Text, j über den Schlüssel. Wann darf j weiterrücken?int k = (int) schluessel.charAt(j % schluessel.length()) - 65;(char) (((int) c - 65 + k) % 26 + 65); j wird nur bei einem Großbuchstaben erhöht.Ziel: Entschlüsseln ist das Spiegelbild. Fertig, wenn: Der Selbsttest HALLO zeigt.
Implementieren Sie vigenereEnt. Begründen Sie im Protokollblatt, warum man vor % 26 die Zahl 26 addiert, und geben Sie an, zwischen welchen Werten die Zahl vor % 26 dann liegt.
(int) c - 65 - k kann negativ sein; in Java ergibt % dann einen negativen Rest.Ziel: Ihr Klartextformat läuft als Code. Fertig, wenn: Der Selbsttest Ihre eingetragenen Werte und 17 1950 K zeigt.
Implementieren Sie alsKlartext und ausKlartext nach Ihrem Format. ausKlartext liefert null, wenn die Länge nicht stimmt oder ein Zeichen nicht ins Format passt.
/ und %: Für 1950 sind das 1950 / 1000 % 10, 1950 / 100 % 10, 1950 / 10 % 10, 1950 % 10.(char) (ziffer + 65); Buchstabe → Ziffer: (int) c - 65. Prüfen Sie beim Zurückwandeln, ob das Ergebnis zwischen 0 und 9 liegt.Material: Gerüst der Klasse Kassenbuch (in dieselbe Datei)
class Kassenbuch {
private DynArray zahlungen = new DynArray();
// false, wenn die Bestellung schon bezahlt ist
public boolean buche(Zahlung z) {
// TODO Teil a
return false;
}
// 1950 -> "19,50 EUR"
public String alsEuro(int cent) {
// TODO Challenge
return "";
}
// Anzahl der Zahlungen, Umsatz, davon bar
public void tagesabschluss() {
// TODO Challenge
}
}KassenbuchZiel: Keine Bestellung wird zweimal gebucht. Fertig, wenn: buche für 17/1950/K, 18/950/B und noch einmal 17 die Werte true, true, false liefert.
Implementieren Sie buche: Ist die Bestellnummer schon im Kassenbuch, wird nicht gebucht und false zurückgegeben. Erklären Sie im Protokollblatt, warum eine Zahlung überhaupt zweimal ankommen kann, obwohl der Kern Duplikate erkennt. (Karte KA-b: Weisen Sie auch Zahlungen mit dem Betrag 0,00 € ab.)
((Zahlung) zahlungen.getItem(i)).getBestellnr().Implementieren Sie alsEuro und tagesabschluss (Anzahl der Zahlungen, Umsatz, davon bar). Testen Sie mit 17/1950/K, 18/950/B und einer Doppelbuchung von 17.
cent / 100, Rest = cent % 100; ein einstelliger Rest braucht eine führende Null (9,05).Ausgezeichnet – Alle Aufgaben abgeschlossen!
Ihr Modul besteht den Selbsttest (Meilenstein M2). Prüfen Sie noch:
Aufgaben: Station KASSE1 und Angriff
Kopieren Sie Ihre Klassen ohne das Hauptprogramm in den Workspace mit Ihrer Station (rufzeichen = "KASSE1").
Material: Ergänzung der Station
// in der Station KASSE1
private Kasse kasse = new Kasse();
private Kassenbuch buch = new Kassenbuch();
private String schluessel = "";
// Hauptprogramm vor dem Verbinden:
// station.setSchluessel(Input.readString("Schlüssel:"));
public void setSchluessel(String s) {
schluessel = s;
}
private synchronized void verarbeite(Paket p, String text) {
if (p.getTyp().equals("ZAH")) {
// TODO Teil a
}
}KASSE1Ergänzen Sie verarbeite: Bei ZAH entschlüsseln, in eine Zahlung umwandeln, buchen und das Ergebnis ausgeben („gebucht“, „doppelt – nicht gebucht“, „unlesbar“).
vigenereEnt → Zahlung.ausKlartext → bei null „unlesbar“ → sonst buche.ausKlartext null.Testen Sie mit einer Kurier-Gruppe: richtige Zahlung, falscher Schlüssel, dieselbe Zahlung zweimal, 20 % Fehler im Störkanal. Prüfen Sie im Lausch-Client, dass kein Betrag und keine Bestellnummer lesbar sind. Halten Sie Testfall – erwartet – beobachtet – Ursache fest.
rufzeichen = "KURIR1" und demo = false von Hand.Material: Die Kasse des Vorjahres hat ihr Format an die Pinnwand gehängt: Bestellnummer (3 Zeichen), Betrag in Cent (4 Zeichen), Zahlungsart (1 Zeichen), jede Ziffer als Buchstabe (0 = A … 9 = J). Pizza Paradiso hörte damals mit:
21:10:02 KURIR1 → ALLE__ STA 017LIE 21:10:02 KURIR1 → KASSE1 ZAH HBZFQFSO 21:14:40 KURIR1 → ALLE__ STA 018LIE 21:14:41 KURIR1 → KASSE1 ZAH HBAEQFSF
Zeigen Sie, wie Pizza Paradiso aus den Statusmeldungen und den Geheimtexten den Schlüssel bestimmt, und entschlüsseln Sie die zweite Zahlung (Angriff mit bekanntem Klartext). Übertragen Sie den Angriff auf Ihr Format: Welche Teile Ihres Klartexts kann ein Mithörer kennen oder raten?
ABH.Beurteilen Sie drei Vorschläge: (1) längerer Schlüssel, (2) Bestellnummer weglassen, (3) vor den Klartext zwei zufällige Buchstaben setzen. Was hilft wirklich?
Ausgezeichnet – Alle Aufgaben abgeschlossen!
Ihre Kasse ist auf Sendung (Meilenstein M3). Prüfen Sie:
Aufgaben: Schlüsseltausch und Signatur eA
Der Schlüssel soll nicht mehr auf Papier wandern, und gefälschte Zahlungen sollen auffallen.
Material: Kryptologie-Seite (Diffie-Hellman-Verfahren); öffentlich vereinbart: p = 23, g = 5. Fertige Methoden für die Klasse Kasse:
// basis hoch exponent mod m (Zwischenergebnisse klein halten)
public int potenzMod(int basis, int exponent, int m) {
int ergebnis = 1;
for (int i = 0; i < exponent; i++) {
ergebnis = (ergebnis * basis) % m;
}
return ergebnis;
}
// aus der gemeinsamen Zahl einen Schlüssel aus 3 Buchstaben
public String schluesselAus(int zahl) {
String s = "";
int z = zahl;
for (int i = 0; i < 3; i++) {
s = s + (char) (z % 26 + 65);
z = z / 26 + 7 * (i + 1);
}
return s;
}Die Kurierin wählt geheim a = 6, die Kasse b = 15. Berechnen Sie A, B, den gemeinsamen Schlüssel K und schluesselAus(K). Zeichnen Sie ein Sequenzdiagramm des Austauschs mit KEY-Paketen: Was steht öffentlich in den Nutzdaten?
Entwerfen Sie mit den Kurier-Gruppen das KEY-Format und implementieren Sie die Seite der Kasse: Auf jedes KEY wählt die Kasse ein zufälliges b, antwortet mit B und merkt sich K je Kurier (Klasse Schluesselpartner mit Rufzeichen und K in einer DynArray). Bei ZAH sucht sie den Partner zum Absender und entschlüsselt mit schluesselAus(K); ohne Partner: „kein Schlüssel – Zahlung abgelehnt“.
int b = 2 + (int) (Math.random() * 20);. Prüfen Sie die Ziffern im KEY mit zahlAus, bevor Sie rechnen.KEY, ersetzen Sie den vorhandenen Eintrag mit setItem – sonst findet die Suche weiter den alten Schlüssel.Beurteilen Sie den Handshake: (1) Wie viele verschiedene Schlüssel kann schluesselAus bei p = 23 überhaupt liefern? (2) Pizza Paradiso sendet ein KEY-Paket mit Absender KURIR1. Was passiert? (3) Was müsste man ändern?
schluesselAus für einige K aus.Material: Signatur mit gemeinsamem Geheimnis – wie auf der Kryptologie-Seite, aber der Hash beachtet die Reihenfolge der Zeichen. Fachlich heißt diese Art von Signatur MAC.
// einfacher Hash, beachtet die Reihenfolge der Zeichen
public int hash(String s) {
int h = 7;
for (int i = 0; i < s.length(); i++) {
h = (h * 31 + (int) s.charAt(i)) % 1000;
}
return h;
}
// Signatur = Hash(Text + Geheimnis), 3-stellig angehängt
public String signiere(String text, int geheimnis) {
return text + mitNullen(hash(text + geheimnis), 3);
}
// die letzten 3 Zeichen sind die Signatur
public boolean pruefeSignatur(String nutzdaten, int geheimnis) {
if (nutzdaten.length() < 3) {
return false;
}
int ende = nutzdaten.length() - 3;
String text = nutzdaten.substring(0, ende);
String sig = nutzdaten.substring(ende);
return sig.equals(mitNullen(hash(text + geheimnis), 3));
}Die Kurierin verschlüsselt den Klartext ABHBJFAK (Vorjahresformat) mit CHO (K = 2) und signiert den Geheimtext mit dem Geheimnis 2. Geben Sie die ZAH-Nutzdaten an. Pizza Paradiso ändert den Betrag auf 0,50 €, verschlüsselt mit dem erratenen Schlüssel und hängt die alte Signatur an. Was meldet pruefeSignatur? Bauen Sie die Prüfung in Ihre Kasse ein (Geheimnis = K des Partners).
Bisher übernimmt die Kasse jedes KEY, in dessen Absenderfeld KURIR1 steht. Mit der RSA-Idee kann KURIR1 seinen öffentlichen Wert so signieren, dass nur er die Signatur erzeugen, aber jeder sie prüfen kann. Schlüsselpaar von KURIR1 (kleine Zahlen): öffentlich n = 33, e = 3; geheim d = 7.
- Prüfen Sie, dass \(e \cdot d \bmod 20 = 1\) gilt (20 = (3 − 1) · (11 − 1)).
KURIR1sendet A = 8. Berechnen Sie die Signatur \(s = A^d \bmod n\) und zeigen Sie, wie die Kasse mit \(s^e \bmod n\) prüft.- Vereinbaren Sie mit den Kurier-Gruppen ein
KEY-Format mit Signatur und bauen Sie die Prüfung in die Kasse ein (potenzModgenügt). - Beurteilen Sie: Wie schwer ist es für Pizza Paradiso, zu einem gefälschten A eine passende Signatur zu finden – bei n = 33 und bei echten Schlüssellängen? Woher kennt die Kasse (n, e) von
KURIR1sicher?
Pizza Paradiso sendet eine echte, signierte Zahlung einfach noch einmal (Replay). Was passiert? Vergleichen Sie außerdem Prüfsumme (FN/1), MAC und Verschlüsselung: Wogegen schützt jeweils was?
Ausgezeichnet – Alle Aufgaben abgeschlossen!
Ihre Erweiterung läuft (Meilenstein M4). Prüfen Sie:
Sicherung
Bei symmetrischen Verfahren wie Vigenère müssen Sender und Empfänger denselben geheimen Schlüssel besitzen. Ihn sicher zu übergeben, ohne dass Dritte ihn erfahren, ist das Schlüsselproblem.
Vigenère verschiebt jeden Großbuchstaben um den Wert des passenden Schlüsselbuchstabens; andere Zeichen bleiben stehen. Darum muss der Klartext entworfen werden: nur A–Z, feste Längen, keine Wortgrenzen. Mit bekanntem Klartext lässt sich der Schlüssel direkt zurückrechnen – auch Metadaten wie eine Statusmeldung können ihn verraten. Das Kassenbuch verhindert Doppelbuchungen in der Anwendung. eA Diffie-Hellman löst das Schlüsselproblem, aber nur, wenn die öffentlichen Werte echt sind; ein MAC sichert Zahlungen mit gemeinsamem Geheimnis, eine RSA-Signatur sichert Werte ohne gemeinsames Geheimnis.
Diese Pakete und Klassen tauscht die Kasse aus.
| Richtung | Typ | Partner | Nutzdaten |
|---|---|---|---|
| empfängt | ZAH | KURIRn | verschlüsselter Klartext laut Vertrag; eA mit Signatur |
| eA empfängt / sendet | KEY | KURIRn | öffentlicher Wert laut Vertrag, eA mit RSA-Signatur |
| liefert vorab | – | Kurier-Gruppen | Klassen Kasse, Zahlung; Schlüsselregel |
Vergleichen Sie Ihren Plan aus dem Einstieg mit Ihrer fertigen Kasse: Welche Plan-Punkte haben sich bestätigt, welche mussten Sie ändern – und warum?
Mit einem entworfenen Klartext aus festen Längen und Buchstaben statt Ziffern sieht Pizza Paradiso nur noch eine Buchstabenfolge ohne Wortgrenzen – kein Betrag, keine Bestellnummer. Das hilft aber nur, solange der Schlüssel geheim bleibt und keine Metadaten den Klartext verraten. Das Kassenbuch bucht jede Bestellung nur einmal, und im eA-Kurs ersetzt Diffie-Hellman den Schlüsselzettel.
Abteilung Funkstrecke eA
Worum es geht: Auf der Richtfunkstrecke zur Außenfiliale kippt jedes hundertste Bit, und Wiederholen hilft kaum. → Die Funkstrecke komprimiert Aufträge mit Huffman, schützt sie mit Hamming(7,4) und korrigiert Fehler beim Empfänger selbst.
Einstieg: Rauschen nach Hasbergen
Food Now! eröffnet eine Außenfiliale in Hasbergen. Dorthin gibt es nur eine Richtfunkstrecke über die Felder – und die rauscht: Ungefähr jedes hundertste Bit kommt falsch an. Die erste Probe mit FN/1 (Zeichen als 8-Bit-Folgen aus 0 und 1, gesichert mit Prüfsumme, NAK und Wiederholung):
18:00:00 RELAIS → AUSSEN BIT Auftrag 017 (136 Bit)
// NAK
18:00:02 RELAIS → AUSSEN BIT Auftrag 017 (136 Bit)
// NAK
18:00:04 RELAIS → AUSSEN BIT Auftrag 017 (136 Bit)
// ACK
18:00:06 RELAIS → AUSSEN BIT Auftrag 018 (136 Bit)
// NAK
…
18:00:16 RELAIS Auftrag 018: Abbruch nach 5 VersuchenBei 1 % Bitfehlern kommt ein Auftrag mit 136 Bit nur mit der Wahrscheinlichkeit \(0{,}99^{136} \approx 0{,}25\) unverfälscht an. Im Mittel braucht jeder Auftrag vier Versuche, und fast jeder vierte wird nach fünf Versuchen abgebrochen. Mehr Wiederholungen helfen kaum – jede Wiederholung ist wieder genauso gestört.
Leitfrage: Wie kommen Aufträge über eine Strecke, auf der jedes hundertste Bit kippt, trotzdem fast immer beim ersten Versuch richtig an?
Nebenfragen:
- Kann der Empfänger einen Fehler selbst korrigieren, statt um Wiederholung zu bitten? Was kostet das?
- Wie kann man einen Auftrag mit weniger Bits übertragen, damit weniger Fehler passieren können?
Sammeln Sie in der Gruppe: Problem → Idee → offene Frage.
- Erinnern Sie sich an den (7,4)-Hamming-Code (Codierungsseite, Kern Kapitel 4): Wie viele Fehler pro Block kann er korrigieren?
- Welche Zeichen kommen in Bestelltexten häufig vor, welche selten? Was folgt daraus für die Länge ihrer Codes?
- Skizzieren Sie, welche Station was tut: Wer codiert, wer verrauscht, wer decodiert?
Tragen Sie den Plan als Protokollblatt v0.1 ein (Abschnitte 2, 3 und 6) und zeigen Sie ihn der Lehrkraft (Plan-Ticket). Danach beginnt Aufgabe 1.
- Bitfehlerrate der Strecke: 1 % (Klasse
Rauschenmit 10 Promille). - Ein Auftrag braucht mit Fehlerschutz höchstens 1,5-mal so viele Bit wie der ungeschützte Text mit 7 Bit je Zeichen.
- Mindestens 90 % der Aufträge kommen ohne Wiederholung korrekt an.
- Bitfehlerrate der Strecke: 2 % (Klasse
Rauschenmit 20 Promille). - Ein Auftrag braucht mit Fehlerschutz höchstens 1,3-mal so viele Bit wie der ungeschützte Text mit 7 Bit je Zeichen.
- Mindestens 80 % der Aufträge kommen ohne Wiederholung korrekt an.
Aufgaben: Die Strecke entwerfen
Planen Sie Codierung, Fehlerschutz und das Paketformat der Strecke. Halten Sie alles im Protokollblatt fest.
Material: Codierungstheorie-Seite (Hamming, Huffman), Prüfgruppen nach den Abitur-Hinweisen (Reihenfolge p0 p1 d0 p2 d1 d2 d3, gerade Parität).
| Prüfbit | d0 | d1 | d2 | d3 |
|---|---|---|---|---|
| p0 | x | x | – | x |
| p1 | x | – | x | x |
| p2 | – | x | x | x |
- Codieren Sie die Datenbits
1011,0100und1101. - Empfangen wird
0110111. Bestimmen Sie mit den drei Prüfgruppen die Fehlerstelle und die Datenbits. - Begründen Sie mit dem Mindestabstand, wie viele Fehler pro Block erkannt bzw. korrigiert werden.
Erstellen Sie einen Huffman-Baum für PIZZA PIZZA PASTA (das Leerzeichen zählt mit), geben Sie die Codes an und vergleichen Sie die Länge mit 8 Bit je Zeichen. Warum braucht ein präfixfreier Code keine Trennzeichen?
Entwerfen Sie den Pakettyp BIT: Was steht in den Nutzdaten, wie erkennt AUSSEN das Ende des Auftrags, woher kennt AUSSEN den Huffman-Baum? Prüfen Sie Bedingung 2 Ihrer Karte für den Auftrag 0172xPIZZA,1xCOLA (Bestellnummer + Bestelltext, 17 Zeichen) in drei Varianten: (1) ungeschützt mit 7 Bit je Zeichen, (2) 8 Bit je Zeichen mit Hamming, (3) Huffman mit Endezeichen (86 Bit) und dann Hamming. Bestimmen Sie für (2) und (3) die Informationsrate.
Im Liefernetz läuft alles über den zuverlässigen WebSocket; Fehler macht nur der StoerKanal. Für die Funkstrecke verrauscht RELAIS die Hamming-Bits mit der Klasse Rauschen, bevor daraus FN/1-Pakete werden. Erklären Sie, warum die FN/1-Prüfsumme dieses Rauschen nicht bemerkt, und ordnen Sie Hamming, Prüfsumme mit ACK und Huffman den Schichten eines Netzes zu.
Ausgezeichnet – Alle Aufgaben abgeschlossen!
Ihr Entwurf steht. Prüfen Sie ihn:
Aufgaben: Hamming und Huffman programmieren
Implementieren Sie die Klasse Funkstrecke (Datei Funkstrecke.java) und testen Sie ohne Netz (Bibliothek „Abiturklassen Niedersachsen“ einschalten).
Material: Selbsttest und Gerüst
// ---- Selbsttest (Hauptprogramm) ----
Funkstrecke f = new Funkstrecke();
// erwartet: 0110011
println(f.hammingKodiere("1011"));
// erwartet: 1011 (d1 wird korrigiert)
println(f.hammingDekodiere("0110111"));
// erwartet: 01100111001100 (aufgefüllt zu 1011 0100)
println(f.bitsZuHamming("101101"));
// erwartet: 10110100
println(f.hammingZuBits("01100111001100"));Funkstrecke.javaGerüst der Klasse Funkstrecke anzeigen
class Funkstrecke {
// Zeichen '0'/'1' -> Zahl 0/1
private int bit(String s, int i) {
return (int) s.charAt(i) - 48;
}
// 4 Datenbits d0 d1 d2 d3 -> 7 Bit p0 p1 d0 p2 d1 d2 d3
public String hammingKodiere(String daten) {
// TODO Teil a
return "";
}
// 7 Bit -> 4 Datenbits; ein Einzelfehler wird korrigiert
public String hammingDekodiere(String c) {
// TODO Teil b
return "";
}
// mit 0 auf ein Vielfaches von 4 auffüllen, blockweise kodieren
public String bitsZuHamming(String bits) {
// TODO Teil c
return "";
}
// blockweise decodieren; ein unvollständiger Rest entfällt
public String hammingZuBits(String bits) {
// TODO Teil c
return "";
}
}FunkstreckeZiel: 4 Datenbits werden zu einem 7-Bit-Block. Fertig, wenn: Der Selbsttest 0110011 zeigt.
Implementieren Sie hammingKodiere. Statt XOR (in der Online-IDE für int nicht erlaubt) rechnen Sie mit Summe mod 2.
int d0 = bit(daten, 0); usw.return "" + p0 + p1 + d0 + p2 + d1 + d2 + d3;Ziel: Jeder Einzelfehler wird korrigiert. Fertig, wenn: Ein Test über alle 16 Datenblöcke mit jedem möglichen Einzelfehler (112 Fälle) jedes Mal die richtigen Datenbits liefert.
Implementieren Sie hammingDekodiere mit den drei Prüfgruppen (Positionen im 7-Bit-Wort: p0 = 0, p1 = 1, d0 = 2, p2 = 3, d1 = 4, d2 = 5, d3 = 6) und schreiben Sie den Test über alle 112 Fälle.
pos = s0 + 2 * s1 + 4 * s2 ist die Stelle (1 bis 7) des falschen Bits.pos kippen: c = c.substring(0, pos - 1) + richtig + c.substring(pos); Die Datenbits stehen danach an den Positionen 2, 4, 5 und 6.Ziel: Beliebig lange Bitfolgen werden geschützt übertragen. Fertig, wenn: Die letzten beiden Zeilen des Selbsttests stimmen.
Implementieren Sie bitsZuHamming (auffüllen, blockweise kodieren) und hammingZuBits (blockweise decodieren; ein unvollständiger Rest wird ignoriert).
while (bits.length() % 4 != 0) { bits = bits + "0"; }hammingZuBits läuft, solange i + 7 <= bits.length().Material: Klasse HuffKnoten und die fertigen Methoden baueHuffman und fuegeSortiertEin (in die Klasse Funkstrecke übernehmen). Ein Knoten speichert alle Zeichen seines Teilbaums als Text, z. B. "ZA" mit Häufigkeit 8. Beide Stationen bauen den Baum aus demselben Kodierbuch Funkstrecke.kodierbuch():
// Text, aus dem RELAIS und AUSSEN denselben Huffman-Baum bauen
public static String kodierbuch() {
return "2xPIZZA,1xCOLA#1xBURGER,2xPOMMES#3xPIZZA,2xSALAT#"
+ "1xPASTA,1xCOLA#1xMENUE(PIZZA(SALAMI,KAESE),COLA)#"
+ "0123456789ABCDEFGHIJKLMNOPQRSTUVWXYZ";
}Fertiger Code: HuffKnoten, baueHuffman, fuegeSortiertEin
class HuffKnoten {
// alle Zeichen dieses Teilbaums
private String zeichen;
private int haeufigkeit;
public HuffKnoten(String zeichen, int haeufigkeit) {
this.zeichen = zeichen;
this.haeufigkeit = haeufigkeit;
}
public String getZeichen() { return zeichen; }
public int getHaeufigkeit() { return haeufigkeit; }
}
// in der Klasse Funkstrecke:
public BinTree baueHuffman(String text) {
// Bäume, aufsteigend nach Häufigkeit sortiert
DynArray liste = new DynArray();
String gesehen = "";
for (int i = 0; i < text.length(); i++) {
char z = text.charAt(i);
if (!gesehen.contains("" + z)) {
gesehen = gesehen + z;
int anzahl = 0;
for (int j = 0; j < text.length(); j++) {
if (text.charAt(j) == z) {
anzahl++;
}
}
HuffKnoten blatt = new HuffKnoten("" + z, anzahl);
fuegeSortiertEin(liste, new BinTree(blatt));
}
}
while (liste.getLength() > 1) {
BinTree links = (BinTree) liste.getItem(0);
BinTree rechts = (BinTree) liste.getItem(1);
liste.delete(0);
liste.delete(0);
HuffKnoten l = (HuffKnoten) links.getItem();
HuffKnoten r = (HuffKnoten) rechts.getItem();
HuffKnoten k = new HuffKnoten(l.getZeichen() + r.getZeichen(),
l.getHaeufigkeit() + r.getHaeufigkeit());
BinTree neu = new BinTree(k);
neu.setLeft(links);
neu.setRight(rechts);
fuegeSortiertEin(liste, neu);
}
if (liste.isEmpty()) {
return new BinTree();
}
return (BinTree) liste.getItem(0);
}
private void fuegeSortiertEin(DynArray liste, BinTree b) {
int h = ((HuffKnoten) b.getItem()).getHaeufigkeit();
int i = 0;
while (i < liste.getLength() && haeufigkeit(liste, i) <= h) {
i++;
}
liste.insertAt(i, b);
}
// Häufigkeit des Baums an Position i der Liste
private int haeufigkeit(DynArray liste, int i) {
BinTree b = (BinTree) liste.getItem(i);
return ((HuffKnoten) b.getItem()).getHaeufigkeit();
}Erklären Sie im Protokollblatt Schritt für Schritt, wie baueHuffman den Algorithmus von der Codierungsseite umsetzt. Warum enthält das Kodierbuch am Ende alle Ziffern und Buchstaben?
liste ist immer aufsteigend nach Häufigkeit sortiert – die beiden seltensten Bäume stehen vorn.Ziel: Jedes Zeichen bekommt seinen Code aus dem Baum. Fertig, wenn: huffmanKodiere(baum, "0172xPIZZA,1xCOLA#") genau 86 Bit liefert.
Implementieren Sie codeFuer(baum, z) (von der Wurzel aus: links, wenn das Zeichen im linken Teilbaum vorkommt, sonst rechts) und huffmanKodiere(baum, text).
((HuffKnoten) b.getLeft().getItem()).getZeichen().contains("" + z) – prüfen Sie vorher, ob der linke Teilbaum leer ist."0".Ziel: Die Rundreise gelingt. Fertig, wenn: bisEnde(huffmanDekodiere(baum, bits)) wieder 0172xPIZZA,1xCOLA liefert.
Implementieren Sie huffmanDekodiere(baum, bits) (Bits ablaufen, am Blatt Zeichen ausgeben, wieder an die Wurzel) und bisEnde(text) (Text bis vor das erste #).
bisEnde ist eine Schleife mit charAt, die beim ersten # aufhört.Ausgezeichnet – Alle Aufgaben abgeschlossen!
Ihr Modul besteht den Selbsttest (Meilenstein M2). Prüfen Sie noch:
Aufgaben: Die Strecke in Betrieb nehmen
Jetzt laufen zwei Stationen: RELAIS in der Stadt und AUSSEN in Hasbergen (Station extends WebSocket, zwei Geräte bzw. Konten).
Material: Klasse Rauschen (fertig)
class Rauschen {
// jedes Bit kippt mit der Wahrscheinlichkeit promille/1000
public static String verrausche(String bits, int promille) {
String ergebnis = "";
for (int i = 0; i < bits.length(); i++) {
char b = bits.charAt(i);
if (Math.random() * 1000 < promille) {
if (b == '0') { b = '1'; } else { b = '0'; }
}
ergebnis = ergebnis + b;
}
return ergebnis;
}
}RauschenRELAIS empfängt Lieferaufträge der Zentrale (BST im Format der Zentrale). Es baut daraus den Auftragstext „Bestellnummer + Bestelltext“, codiert ihn nach Ihrem BIT-Format (Huffman mit Endezeichen, dann Hamming), verrauscht ihn laut Bedingungskarte und sendet ihn als BIT an AUSSEN.
private BinTree baum = strecke.baueHuffman(Funkstrecke.kodierbuch()); – das Attribut strecke muss davor stehen.substring verwenden.AUSSEN decodiert (Hamming, dann Huffman, dann bis zum Endezeichen), zeigt den Auftrag an und meldet nach einer simulierten Fahrt ABH und LIE für die Bestellnummer.
verarbeite darf kein Thread.sleep stehen. Die Fahrt simulieren Sie mit Timer.executeLater(() -> …, 3000);, das danach LIE meldet.Testen Sie mit der Zentrale (Kunden 9001/9002 im Kundenverzeichnis) und dem Bestellstatus. Wie viele BIT-Pakete erwarten Sie für den Auftrag 0171xPASTA? Vereinbaren Sie, was passiert, wenn trotz Hamming ein Auftrag falsch ankommt (z. B. unlesbare Bestellnummer). Halten Sie Testfall – erwartet – beobachtet – Ursache fest.
0171xPASTA# ergibt Huffman-codiert 53 Bit. Wie viele Zeichen werden daraus nach Auffüllen und Hamming, und wie viele Pakete à 60 Zeichen?Schreiben Sie ein Messprogramm (ohne Netz): 1000-mal 0172xPIZZA,1xCOLA codieren, verrauschen (laut Bedingungskarte), decodieren; zählen Sie die korrekt angekommenen Aufträge – einmal mit Hamming, einmal nur mit Huffman. Vergleichen Sie mit der Rechnung und prüfen Sie Bedingung 3 Ihrer Karte.
Beurteilen Sie für drei Situationen, ob Vorwärtsfehlerkorrektur (FEC, hier Hamming) oder Prüfsumme mit Wiederholung (ARQ) besser ist: (1) Schulnetz, Bitfehlerrate 0,001 %, kurze Laufzeit; (2) unsere Funkstrecke; (3) Raumsonde in 20 Lichtminuten Entfernung. Nutzen Sie Informationsrate und Erfolgswahrscheinlichkeit.
Ausgezeichnet – Alle Aufgaben abgeschlossen!
Ihre Strecke ist in Betrieb (Meilensteine M3 und M4). Prüfen Sie:
Sicherung
Fehlerschutz, bei dem der Sender gezielt Prüfbits hinzufügt, sodass der Empfänger Fehler selbst korrigieren kann, ohne um Wiederholung zu bitten. Gegenstück: Fehlererkennung mit Wiederholung (ARQ).
Der (7,4)-Hamming-Code (Reihenfolge p0 p1 d0 p2 d1 d2 d3, gerade Parität) hat den Mindestabstand 3: Er erkennt zwei und korrigiert einen Fehler je Block; die Informationsrate ist 4/7. Die drei Prüfgruppen ergeben zusammen die Stelle des falschen Bits. Ein Huffman-Code ist präfixfrei und gibt häufigen Zeichen kurze Codes; Sender und Empfänger brauchen denselben Baum. Huffman entfernt Redundanz, Hamming fügt gezielt Redundanz hinzu: Erst komprimieren, dann gegen Fehler schützen.
Diese Pakete verarbeitet die Funkstrecke.
| Station | Richtung | Typ | Partner | Nutzdaten |
|---|---|---|---|---|
| RELAIS | empfängt | BST | ZENTRA | Lieferauftrag laut Vertrag (Außenfiliale) |
| RELAIS | sendet | BIT | AUSSEN | laut Ihrem BIT-Format |
| AUSSEN | sendet | STA | ALLE__ | NNN + ABH bzw. LIE |
Vergleichen Sie Ihren Plan aus dem Einstieg mit Ihrer fertigen Strecke: Welche Plan-Punkte haben sich bestätigt, welche mussten Sie ändern – und warum?
Statt etwa 25 % kommen mit Huffman und Hamming die allermeisten Aufträge beim ersten Versuch richtig in Hasbergen an (bei 1 % Bitfehlern rund 96 %, bei 2 % noch über 80 %) – und jeder Auftrag ist dabei sogar kürzer als der ungeschützte 8-Bit-Text. Der Empfänger korrigiert einzelne Bitfehler selbst; nur Doppelfehler in einem Block bleiben ein Restrisiko, für das Ihr Protokollblatt eine Regel braucht.
Abteilung Bestellstatus
Worum es geht: Statusmeldungen kommen in unmöglicher Reihenfolge, gehen verloren oder widersprechen sich – und niemand merkt es. → Ein Automat je Bestellung prüft jede Meldung, die Statustafel zeigt den Stand aller Bestellungen und warnt bei unzulässigen Abläufen.
Einstieg: Geliefert, bevor abgeholt
Herr B. ruft an: „Wo bleibt mein Essen? Ihre App sagt seit zwanzig Minuten ‚wird gekocht‘!“ Ein Blick in die Statusmeldungen des Abends (alle an ALLE__):
19:40:02 ZENTRA → ALLE__ STA 017ANN
19:40:05 ZENTRA → ALLE__ STA 017KOC
19:48:30 KURIR1 → ALLE__ STA 017LIE
19:47:10 KURIR1 → ALLE__ STA 017ABH
// kam verspätet an
19:52:00 ZENTRA → ALLE__ STA 018ANN
19:53:11 ZENTRA → ALLE__ STA 018STO
19:55:40 KURIR2 → ALLE__ STA 018ABH
20:01:15 ZENTRA → ALLE__ STA 019ANN
20:01:19 ZENTRA → ALLE__ STA 019KOC
// danach nichts mehr zu 019Bestellung 017 wurde angeblich geliefert, bevor sie abgeholt war. Bestellung 018 ist storniert – trotzdem fährt KURIR2 los. Und bei 019 weiß niemand, ob sie unterwegs ist oder ob nur die Meldung verloren ging: Rundrufe werden nicht quittiert.
Leitfrage: Wie kann eine Station automatisch erkennen, ob die Statusmeldungen einer Bestellung in einer zulässigen Reihenfolge kommen?
Nebenfragen:
- In welchen Reihenfolgen dürfen die Meldungen einer Bestellung kommen, in welchen nicht?
- Was soll passieren, wenn eine Meldung verloren gegangen ist?
Sammeln Sie in der Gruppe: Problem → Idee → offene Frage.
- Zeichnen Sie den „Lebenslauf“ einer Bestellung als Kreise (Zustände) und Pfeile (Meldungen).
- Welche Meldung darf in welchem Zustand kommen? Was soll die Anzeige bei jedem Übergang zeigen?
- Erinnern Sie sich an die Automatenseite: Welcher Automatentyp liefert zu jeder Eingabe eine Ausgabe?
Tragen Sie den Plan als Protokollblatt v0.1 ein (Abschnitte 2, 3 und 6) und zeigen Sie ihn der Lehrkraft (Plan-Ticket). Danach beginnt Aufgabe 1.
- Statuscodes nach Vorgabe; jede Statusmeldung enthält die Bestellnummer (
NNNCCC). - Jeder unzulässige Ablauf erzeugt eine Warnung; die Station stürzt nie ab.
- Die Station zeigt eine Anzeigetafel aller Bestellungen.
- eA Bestelltexte – auch Menüs mit verschachtelten Klammern – werden geprüft.
- Statuscodes nach Vorgabe; jede Statusmeldung enthält die Bestellnummer (
NNNCCC). - Eine verlorene Rundrufmeldung löst keine Warnung aus, ein unmöglicher Ablauf (z. B.
ABHnachSTO) dagegen schon. - Die Anzeigetafel zeigt zusätzlich eine Zusammenfassung: geliefert, storniert, offen, fehlerhaft.
- eA Bestelltexte – auch Menüs mit verschachtelten Klammern – werden geprüft.
Aufgaben: Den Automaten entwerfen
Codes nach Vorgabe: ANN angenommen (Zentrale), KOC in Zubereitung (Zentrale, sobald die Adresse da ist), ABH abgeholt (Kurier), LIE geliefert (Kurier), STO storniert (Zentrale). Vor dem Code steht die dreistellige Bestellnummer.
Material: Automatenseite (Mealy, DEA), Mitschnitt S1, Ihre Bedingungskarte.
Geben Sie Eingabealphabet Σ und Ausgabealphabet Ω an und zeichnen Sie den Übergangsgraphen des Mealy-Automaten (Beschriftung „Eingabe / Ausgabe“). Stornieren ist nur möglich, solange noch nicht gekocht wird. Jede nicht vorgesehene Eingabe führt in einen Zustand FEHLER mit der Ausgabe „ungültig“; aus GELIEFERT, STORNIERT und FEHLER führt jede Eingabe nach FEHLER. Geben Sie zusätzlich die Übergangstabelle an.
NEU. Der „normale“ Weg hat vier Übergänge.FEHLER und eine Schleife an FEHLER.Verfolgen Sie mit Ihrem Automaten die Meldungen aus dem Einstieg für 017 und 018 und geben Sie Zustände und Ausgaben an. Betrachten Sie den Graphen dann als DEA mit dem Endzustand GELIEFERT: Welche Wörter über Σ beschreiben eine erfolgreiche Lieferung? Ist ANN STO ein solches Wort?
LIE im Zustand IN_KUECHE an.STA an ALLE__ wird nicht quittiert. Geht KOC verloren und kommt dann ABH, landet der strenge Automat in FEHLER, obwohl alles in Ordnung ist. Entwerfen Sie eine Lösung, die zu Ihrer Bedingungskarte passt, vergleichen Sie mindestens zwei Varianten und begründen Sie Ihre Wahl im Protokollblatt.
STATUS (dann quittiert).Ausgezeichnet – Alle Aufgaben abgeschlossen!
Ihr Entwurf steht. Prüfen Sie ihn:
Aufgaben: Automat und Statustafel programmieren
Implementieren Sie die Klassen Bestellstatus, Auftrag und Statustafel als eigene Datei Bestellstatus.java und testen Sie ohne Netz.
Material: Selbsttest und Gerüst. Die Zustandsnamen und Ausgaben übernehmen Sie aus Ihrem Entwurf.
// ---- Selbsttest (Hauptprogramm) ----
Bestellstatus s = new Bestellstatus();
String[] eingaben = {"ANN", "KOC", "ABH", "LIE"};
for (int i = 0; i < eingaben.length; i++) {
// verarbeite in eigener Zeile aufrufen, nicht in der Verkettung
String ausgabe = s.verarbeite(eingaben[i]);
println(eingaben[i] + " / " + ausgabe + " -> " + s.getZustand());
}
// erwartet: vier Zeilen, zuletzt im Zustand GELIEFERT
// erwartet: true
println(s.pruefeFolge("ANNKOCABHLIE"));
// erwartet: false
println(s.pruefeFolge("ANNLIE"));
// erwartet: false (nach STO ist Schluss)
println(s.pruefeFolge("ANNSTOABH"));Bestellstatus.javaGerüst der Klasse Bestellstatus anzeigen
class Bestellstatus {
private String zustand = "NEU";
// Mealy: Eingabe verarbeiten, Ausgabe zurückgeben
public String verarbeite(String eingabe) {
// TODO Teil a
return "";
}
public String getZustand() {
return zustand;
}
public boolean istGeliefert() {
return zustand.equals("GELIEFERT");
}
// zurück auf NEU (Nummer wird nach 999 neu vergeben)
public void zuruecksetzen() {
zustand = "NEU";
}
// DEA-Sicht: Folge aus 3er-Eingaben, Endzustand GELIEFERT
public boolean pruefeFolge(String folge) {
// TODO Teil b
return false;
}
}BestellstatusZiel: Der Automat aus Aufgabe 1 läuft als Code. Fertig, wenn: Die vier Zeilen des Selbsttests mit GELIEFERT enden.
Implementieren Sie verarbeite mit switch (zustand): zuerst neu = "FEHLER" und ausgabe = "ungültig" annehmen, dann je Zustand die erlaubten Eingaben behandeln.
FEHLER / „ungültig“.equals, nicht mit ==. Am Ende: zustand = neu; return ausgabe;Ziel: Derselbe Automat dient als DEA. Fertig, wenn: Der Selbsttest true, false, false zeigt.
Implementieren Sie pruefeFolge(folge): Die Folge besteht aus Dreiergruppen (ANNKOCABHLIE). Der Automat startet in NEU, verarbeitet alle Gruppen und akzeptiert, wenn er in GELIEFERT endet. Danach wird er wieder auf NEU gesetzt.
for (int i = 0; i + 3 <= folge.length(); i = i + 3) mit folge.substring(i, i + 3).Material: Gerüst (in dieselbe Datei)
class Auftrag {
private int nr;
private Bestellstatus status = new Bestellstatus();
public Auftrag(int nr) {
this.nr = nr;
}
public int getNr() { return nr; }
public Bestellstatus getStatus() { return status; }
}
class Statustafel {
private DynArray auftraege = new DynArray();
// Nutzdaten eines STA-Pakets, z. B. "017ANN";
// liefert die Anzeige bzw. eine Warnung
public String verarbeite(String text) {
// TODO Teil a
return "";
}
private Auftrag finde(int nr) {
// TODO Teil a
return null;
}
public void zeige() {
// TODO Teil b
}
}Auftrag und StatustafelZiel: Jede Meldung landet beim Automaten ihrer Bestellung. Fertig, wenn: Die Meldungen aus Mitschnitt S1 die erwarteten Anzeigen und Warnungen liefern und 01 nicht zum Absturz führt.
Implementieren Sie finde (lineare Suche nach der Bestellnummer) und verarbeite: Länge 6 und drei Ziffern prüfen, sonst „WARNUNG: unlesbare Statusmeldung“; Auftrag suchen oder neu anlegen; den Code an dessen Automaten geben; landet er in FEHLER, eine Warnung zurückgeben, sonst z. B. „Bestellung 17: geliefert“. Kommt ANN für eine Nummer, die es schon gibt, beginnt eine neue Bestellung (die Zentrale vergibt nach 999 wieder ab 1): Setzen Sie den Automaten mit zuruecksetzen() zurück.
zahlAus; den Code liefert text.substring(3, 6).Auftrag a = (Auftrag) auftraege.getItem(i);Ziel: Alle Bestellungen auf einen Blick. Fertig, wenn: Nach den Meldungen aus Mitschnitt S1 eine Zeile je Bestellung mit ihrem Zustand erscheint.
Implementieren Sie zeige() (eine Zeile je Bestellung mit Nummer und Zustand; Karte S-b zusätzlich die Zusammenfassung) und testen Sie mit den Meldungen aus dem Einstieg sowie mit 01 (zu kurz).
println(a.getNr() + ": " + a.getStatus().getZustand());Ziel: Ihre Entwurfsentscheidung aus Aufgabe 1 c) ist umgesetzt. Fertig, wenn: 017ANN, 017ABH (ohne KOC) sich so verhält, wie Ihr Protokollblatt es festlegt.
Setzen Sie Ihre Regel aus Aufgabe 1 c) im Automaten oder in der Tafel um und ergänzen Sie den Selbsttest um zwei Fälle mit verlorener Meldung und einen unmöglichen Ablauf.
if-Zeilen in einzelnen case-Blöcken. Unterscheiden Sie dabei die Ausgabe „übersprungen“ von „ungültig“.Ausgezeichnet – Alle Aufgaben abgeschlossen!
Ihr Modul besteht den Selbsttest (Meilenstein M2). Prüfen Sie noch:
Aufgaben: Station STATUS anbinden
Kopieren Sie Ihre Klassen ohne das Hauptprogramm in den Workspace mit Ihrer Station (rufzeichen = "STATUS").
Material: Ihre Station
Ergänzen Sie verarbeite: Jede STA-Meldung wird an die Tafel gegeben; die Ausgabe wird angezeigt (Warnungen in Orange), nach jeder fünften Meldung die ganze Tafel.
ALLE__ kommen bei jeder Station in verarbeite an – auch bei Ihnen.substring aufrufen – oder nutzen Sie contains("WARNUNG").Testen Sie mit Zentrale und Kurier im Gruppen-Sitzungscode: normaler Ablauf, Stornierung, unbekannter Kunde, eine absichtlich falsche Meldung, Störkanal mit 20 % Verlust. Halten Sie Testfall – erwartet – beobachtet – Ursache fest und zählen Sie, wie oft Warnungen nur wegen verlorener Rundrufe entstehen.
demo = false startet und an ALLE__ den Typ STA mit 017LIE sendet.Ausgezeichnet – Alle Aufgaben abgeschlossen!
Ihre Statustafel ist auf Sendung (Meilenstein M3). Prüfen Sie:
Aufgaben: Gültige Bestelltexte eA
Die Zentrale soll Bestellungen mit unsinnigem Bestelltext gleich stornieren. Ihre Abteilung liefert der Zentrale dafür die Prüfungen.
Material: Bestelltexte ohne Klammern (z. B. 2xPIZZA,1xCOLA) beschreibt diese rechtsreguläre Grammatik (Nichtterminale in spitzen Klammern, G steht für einen beliebigen Großbuchstaben A–Z):
N = {⟨S⟩, ⟨A⟩, ⟨B⟩, ⟨K⟩} Startsymbol ⟨S⟩
T = {1, 2, …, 9, x, Komma, A, B, …, Z}
⟨S⟩ → 1⟨A⟩ | 2⟨A⟩ | … | 9⟨A⟩
⟨A⟩ → x⟨B⟩
⟨B⟩ → G⟨B⟩ | G⟨K⟩ | G für jedes G aus A … Z
⟨K⟩ → ,⟨S⟩Leiten Sie 2xPIZZA,1xCOLA ab. Prüfen Sie, ob 0xCOLA, 2xpizza, 2xPIZZA, und 3xPASTA zur Sprache gehören. Zeichnen Sie einen DEA, der genau diese Sprache erkennt, mit Übergangstabelle.
⟨B⟩ → G) führt in einen Endzustand. Fassen Sie die Zustände so zusammen, dass nach mindestens einem Großbuchstaben ein Endzustand erreicht ist, von dem ein Komma zurück zum Start führt.Implementieren Sie in der Klasse Bestellstatus die Methode istGueltigerBestelltext(text: Zeichenkette): Wahrheitswert als DEA mit Zustandsvariable und switch. Testen Sie mit den Wörtern aus Teil a) und einem leeren Text.
verarbeite: Zustand als Zeichenkette, für jedes Zeichen ein Übergang, alles Unerwartete führt in einen Fehlerzustand, aus dem es kein Zurück gibt.c >= '1' && c <= '9'; Großbuchstabe: c >= 'A' && c <= 'Z'. Akzeptiert wird, wenn der Zustand am Ende der Endzustand ist.Material: Menüs dürfen verschachtelt sein: 1xMENUE(PIZZA(SALAMI,KAESE),COLA). Eine rechtsreguläre Grammatik kann nicht prüfen, ob alle Klammern richtig geschlossen sind (wie bei aⁿbⁿ). Ein Kellerautomat kann es.
Zeichnen Sie einen Kellerautomaten (Notation der Abitur-Hinweise: Übergang „(oberstes Kellerzeichen, Eingabe) : abgelegte Zeichen“, Vorbelegung #), der genau die Wörter mit korrekt geschachtelten Klammern akzeptiert. Fassen Sie alle Zeichen außer ( und ) zur Eingabe a zusammen und verwenden Sie für eine offene Klammer das Kellerzeichen K. Geben Sie die Kellerinhalte für a(a(a)a) an.
( wird ein K auf den Keller gelegt, bei ) eines entfernt – aber nur, wenn oben eines liegt.# im Keller liegt: ε-Übergang in den Endzustand.Implementieren Sie klammernOk(text) in der Klasse Bestellstatus mit einem Stack (Vorbelegung "#"). Testen Sie 1xMENUE(PIZZA(SALAMI,KAESE),COLA), 1xMENUE(PIZZA(SALAMI,COLA), PIZZA)( und 2xPIZZA. Geben Sie die Klasse an die Zentrale weiter (Zentrale, Aufgabe 5 c) und vereinbaren Sie, wann welche Prüfung gilt.
top() und pop() immer prüfen, ob der Stapel leer ist bzw. ob oben # liegt.top() liefert ein Object – Vergleich mit keller.top().equals("#").Ausgezeichnet – Alle Aufgaben abgeschlossen!
Ihre Erweiterung läuft (Meilenstein M4). Prüfen Sie:
Sicherung
Die Menge aller Wörter, nach deren Verarbeitung ein DEA in einem Endzustand ist. Der Graph des Bestellstatus akzeptiert als DEA genau die erfolgreichen Lieferungen.
Ein Mealy-Automat ordnet jedem Zustand und jeder Eingabe einen Folgezustand und eine Ausgabe zu (Schreibweise „Eingabe / Ausgabe“). In Java: eine Zustandsvariable und switch, die Fehlerbehandlung an einer Stelle. Weil Rundrufe verloren gehen können, ist die Strenge des Automaten eine Entwurfsentscheidung. eA Eine rechtsreguläre Grammatik und ein DEA beschreiben dieselbe Sprache; verschachtelte Klammern erkennt erst ein Kellerautomat.
Diese Pakete und Klassen verarbeitet der Bestellstatus.
| Richtung | Typ | Partner | Nutzdaten |
|---|---|---|---|
| empfängt | STA | alle (ALLE__) | NNN + ANN/KOC/ABH/LIE/STO |
| eA liefert vorab | – | Zentrale | Klasse Bestellstatus mit istGueltigerBestelltext und klammernOk |
Vergleichen Sie Ihren Plan aus dem Einstieg mit Ihrer fertigen Station: Welche Plan-Punkte haben sich bestätigt, welche mussten Sie ändern – und warum?
Die Statustafel meldet sofort, dass bei 017 „geliefert“ vor „abgeholt“ kam und dass 018 trotz Stornierung abgeholt wurde. Ob bei 019 nur eine Meldung verloren ging oder wirklich etwas hängt, entscheidet Ihre Regel aus Aufgabe 1 c) – ein strenger Automat warnt, ein toleranter zeigt „übersprungen“.
Abteilung Logbuch
Worum es geht: Nach dem Probelauf streiten die Abteilungen, und im Logbuch stehen alle Bestellungen, Adressen und Zahlungen – mehrfach. → Das Logbuch klärt Streitfragen mit SQL, speichert nur, was es darf, und zeigt im Go-Live die wichtigsten Zahlen.
Einstieg: Wer hat recht?
Nach dem ersten Probelauf gibt es Streit:
KURIR2: „Ich habe nie einen Auftrag bekommen!“ZENTRA: „Doch, ich habe Bestellung 023 dreimal anKURIR2gesendet!“KASSE1: „Bestellung 021 wurde zweimal bezahlt – oder doch nicht?“STATUS: „Wie lange dauert bei uns eigentlich eine Lieferung?“
Zum Glück schreibt jede Station mit der fertigen Klasse Logbuch jedes gesendete und jedes gehörte Paket in die Tabelle logbuch einer Datenbank. Ihre Gruppe schaut hinein – und erschrickt: In der Spalte nutzdaten stehen alle Bestellungen mit Kundennummer, alle Adressen und alle Zahlungen, und das nicht einmal, sondern bei jeder Station noch einmal.
Leitfrage: Wie lassen sich die Streitfragen mit dem Logbuch klären – und was darf ein Logbuch überhaupt speichern?
Nebenfragen:
- Warum steht jedes Paket mehrfach in der Tabelle? Was bedeutet das für das Zählen?
- Wer darf hineinschauen, und wie lange?
Sammeln Sie in der Gruppe: Problem → Idee → offene Frage.
- Lesen Sie die Spaltenliste (Tabelle L1): Wer schreibt wann eine Zeile?
- Formulieren Sie jede Streitfrage als Frage an eine Tabelle („Zähle alle Zeilen, in denen …“).
- Markieren Sie alle Spalten, in denen personenbezogene Daten stehen können.
Tragen Sie den Plan als Protokollblatt v0.1 ein (Abschnitte 2, 3 und 6) und zeigen Sie ihn der Lehrkraft (Plan-Ticket). Danach beginnt Aufgabe 1.
- Keine personenbezogenen Nutzdaten dauerhaft in der Datenbank (Bestellungen mit Kundennummer, Adressen, Zahlungen).
- Mindestens fünf Auswertungsabfragen für das Go-Live, davon zwei mit
GROUP BYund eine mitHAVING. - Eine Löschfrist ist festgelegt und begründet.
- eA Lieferzeiten lassen sich per SQL berechnen.
- Von den Nutzdaten wird nur gespeichert, was für die Auswertung der Statusmeldungen nötig ist; Rufzeichen von Kurieren werden nach dem Go-Live durch Platzhalter ersetzt (Mitarbeiterdatenschutz).
- Mindestens fünf Auswertungsabfragen für das Go-Live, davon je eine für Zentrale, Kurier und Kasse.
- Lese- und Schreibzugriff sind getrennt geregelt und begründet.
- eA Lieferzeiten lassen sich per SQL berechnen.
Material für alle Aufgaben: die Tabelle logbuch in Kurzschreibweise (Primärschlüssel unterstrichen) und ein Beispiel-Logbuch.
logbuch(nr, zeit, station, richtung, absender, empfaenger, typ, seq, teil, gesamt, laenge, nutzdaten, gueltig, roh)
| Spalte | Bedeutung |
|---|---|
| nr | laufende Nummer (Primärschlüssel) |
| zeit | Zeitpunkt in Unix-Sekunden |
| station | wer die Zeile schreibt |
| richtung | AUS (gesendet) oder EIN (gehört) |
| absender … laenge | Felder des FN/1-Kopfs |
| nutzdaten | Nutzdaten des Pakets |
| gueltig | 1 = Prüfsumme in Ordnung, 0 = defekt |
| roh | kompletter Funktext |
Beispiel-Logbuch eines Testlaufs mit den Stationen KUNDE1, ZENTRA, KUNDEN, KURIR1, KASSE1, STATUS (Bestellung 017; eine Adressanfrage ging verloren, ein Lieferauftrag kam verfälscht an). Gezeigt sind nur die AUS-Zeilen; station ist dort gleich absender.
| nr | zeit | absender → empfaenger, typ, seq | nutzdaten | gueltig |
|---|---|---|---|---|
| 1 | 1792000000 | KUNDE1 → ZENTRA BST 4 | 00423 2xPIZZA,1xCOLA | 1 |
| 7 | 1792000000 | ZENTRA → KUNDE1 ACK 4 | 1 | |
| 13 | 1792000001 | ZENTRA → ALLE__ STA 11 | 017ANN | 1 |
| 19 | 1792000001 | ZENTRA → KUNDEN ADR 12 | ‹Anfrage› | 1 |
| 20 | 1792000003 | ZENTRA → KUNDEN ADR 12 | ‹Anfrage› | 1 |
| 26 | 1792000003 | KUNDEN → ZENTRA ACK 12 | 1 | |
| 32 | 1792000003 | KUNDEN → ZENTRA ADR 3 | ‹Antwort› | 1 |
| 38 | 1792000003 | ZENTRA → KUNDEN ACK 3 | 1 | |
| 44 | 1792000004 | ZENTRA → ALLE__ STA 13 | 017KOC | 1 |
| 50 | 1792000004 | ZENTRA → KURIR1 BST 14 | ‹Lieferauftrag› | 1 |
| 56 | 1792000004 | KURIR1 → ZENTRA NAK 14 | 1 | |
| 62 | 1792000004 | ZENTRA → KURIR1 BST 14 | ‹Lieferauftrag› | 1 |
| 68 | 1792000004 | KURIR1 → ZENTRA ACK 14 | 1 | |
| 74 | 1792000005 | KURIR1 → ALLE__ STA 21 | 017ABH | 1 |
| 80 | 1792000007 | KURIR1 → ALLE__ STA 22 | 017LIE | 1 |
| 86 | 1792000007 | KURIR1 → KASSE1 ZAH 23 | ‹Zahlung› | 1 |
| 92 | 1792000007 | KASSE1 → KURIR1 ACK 23 | 1 | |
| 98 | 1792000009 | KURIR1 → ZENTRA POS 24 | ‹frei› | 1 |
| 104 | 1792000009 | ZENTRA → KURIR1 ACK 24 | 1 |
Zu jeder AUS-Zeile gibt es EIN-Zeilen der fünf anderen Stationen, weil alle alles hören – außer bei der verlorenen Anfrage (Nr. 19). Beim verfälschten Lieferauftrag (Nr. 50) steht in den EIN-Zeilen gueltig = 0. Insgesamt hat die Tabelle 109 Zeilen. Die Nutzdaten in ‹…› hängen vom Format ab, das Ihr Kurs vereinbart; in der Beispieldatenbank der Lehrkraft stehen die Formate dieses Testlaufs.
Aufgaben: Das Logbuch verstehen und schützen
Klären Sie, was im Logbuch steht und was darin stehen darf. Halten Sie Ihre Regeln im Protokollblatt fest.
Material: Tabellen L1 und L2. Die Klasse Logbuch wird vom Funkgerät bei jedem Senden mit AUS und bei jedem Empfangen mit EIN aufgerufen.
Erklären Sie, warum zu einem Paket bis zu sechs Zeilen gehören. Wie viele Zeilen gehören zum Lieferauftrag mit Seq 14 (einschließlich der Wiederholung)? Welche Zeilen muss man zählen, um (1) die Anzahl gesendeter Pakete, (2) die Anzahl defekt empfangener Pakete einer Station zu bestimmen?
EIN – noch bevor die Station prüft, ob sie an sie gerichtet ist.Untersuchen Sie für jeden Pakettyp, ob seine Nutzdaten personenbezogen sind, und beurteilen Sie die Spalte roh. Legen Sie nach den Grundsätzen Datensparsamkeit, Zweckbindung und Speicherbegrenzung fest, was das Logbuch speichern darf und wann gelöscht wird. Regeln Sie, wer den Schreib-Code und wer nur einen Lese-Code bekommt. Beachten Sie Ihre Bedingungskarte.
DELETE ausführen.Legen Sie in der SQL-IDE die Datenbank des Kurses an (das CREATE TABLE steht im Kopfkommentar der Datei Logbuch.java) und prüfen Sie, ob ein Testeintrag ankommt.
Material: Beispieldatenbank in der SQL-IDE (Lese-Code von der Lehrkraft). Nur der Sprachumfang der Abitur-Hinweise: keine Unterabfragen; mehrere Tabellen über FROM t1, t2 WHERE …. Schreiben Sie jede Abfrage ins Protokollblatt.
Fertig, wenn: Ihre Abfrage für ACK die Anzahl 6 liefert und absteigend sortiert ist.
Wie viele Pakete jedes Typs wurden gesendet? Sortieren Sie absteigend nach Anzahl.
COUNT(*) zählt die Zeilen einer Gruppe; ORDER BY anzahl DESC sortiert absteigend, wenn Sie die Spalte mit AS anzahl benennen.Fertig, wenn: Ihre Abfrage genau zwei Zeilen liefert.
Welche Datenpakete (also nicht ACK/NAK) wurden mehrfach gesendet? Geben Sie Absender, Typ, Seq und Anzahl der Versuche aus. Erklären Sie, wie dieselbe Abfrage im Go-Live den Streit zwischen Zentrale und KURIR2 klärt.
HAVING, nicht in WHERE.Fertig, wenn: Ihre Abfrage sechs Zeilen liefert und ZENTRA 0 defekte Pakete hat.
Geben Sie für jede Station die Anzahl gehörter Pakete und die Anzahl defekter Pakete aus. Erklären Sie, warum die Zentrale keinen Defekt hat.
gueltig ist 1 oder 0. Die Summe von gueltig zählt die heilen Pakete.Fertig, wenn: Sie für Bestellung 017 eine Dauer von 6 Sekunden und insgesamt eine Lieferung erhalten.
Geben Sie die Statusmeldungen der Bestellung 017 in zeitlicher Reihenfolge aus und berechnen Sie die Dauer von der ersten bis zur letzten Meldung in Sekunden. Wie viele Lieferungen wurden insgesamt gemeldet?
LIKE '017%' findet alle Nutzdaten, die mit 017 beginnen; _ steht für genau ein Zeichen.MAX(zeit) - MIN(zeit).Formulieren Sie zwei Abfragen, die ohne Nutzdaten etwas über das Verhalten im Liefernetz verraten (z. B. „Wer funkt wie oft mit wem?“), und eine, die zeigt, welche Stationen die Bestellung von Kunde 0042 gehört haben.
absender und empfaenger; lassen Sie Quittungen und Rundrufe weg.Ausgezeichnet – Alle Aufgaben abgeschlossen!
Die Streitfragen sind geklärt. Prüfen Sie:
Aufgaben: Logbuch und Leitstand programmieren
Ihre Regeln werden zu Code: ein datensparsames Logbuch für alle Stationen und ein Leitstand für das Go-Live.
Material: Datei Logbuch.java, Methode speichere (Auszug)
einfuegen.setString(11, p.getNutzdaten());
// ...
einfuegen.setString(13, text);Logbuch Nutzdaten und Rohtext speichertZiel: Das Logbuch hält Ihre Datenschutzregel ein. Fertig, wenn: Ein Probelauf mit ZAH und STA nur die erlaubten Nutzdaten speichert und roh leer bleibt.
Ändern Sie speichere nach Ihrer Regel aus Aufgabe 1 b): Nutzdaten nur für erlaubte Typen, roh nie. Schreiben Sie dazu eine Methode darfNutzdatenSpeichern(typ). Geben Sie die geänderte Klasse allen Gruppen (neue Version im Schnittstellenvertrag).
p.getNutzdaten() speichern Sie bei nicht erlaubten Typen "".Entwerfen Sie die Auswertungsabfragen für das Go-Live nach Bedingung 2 Ihrer Karte – mindestens Lieferquote, Wiederholungen und Defekte je Station, Lieferdauer – und testen Sie sie auf der Beispieldatenbank. Notieren Sie zu jeder Abfrage, welche Frage sie beantwortet und welche Abteilung sie braucht. Prüfen Sie, ob Ihre Datenschutzregel eine der Abfragen unmöglich macht.
…LIE / Anzahl …ANN aus den STA-Meldungen. Zeiträume schränken Sie mit zeit BETWEEN … AND … ein.nutzdaten NOT LIKE '999%' aus.Ziel: Im Go-Live zeigt ein Programm laufend die wichtigsten Zahlen. Fertig, wenn: Ihre Abfragen alle 30 Sekunden neu in der Konsole erscheinen.
Schreiben Sie eine Klasse Leitstand, die mit dem Lese-Code eine Verbindung aufbaut und mit zeige(titel, sql) eine Abfrage mit zwei Ergebnisspalten (Text, Zahl) ausgibt. Das Hauptprogramm zeigt Ihre Go-Live-Abfragen alle 30 Sekunden neu an.
PreparedStatement st = verbindung.prepareStatement(sql); ResultSet rs = st.executeQuery(); while (rs.next()) { … } – die Werte liefern rs.getString(1) und rs.getInt(2).Thread.sleep(30000).Verteilen Sie den Schreib-Code an zwei Partnergruppen, lassen Sie einen kurzen Probelauf laufen (Störkanal 10 %) und prüfen Sie: Kommen Einträge an? Stimmen die Zeitstempel? Werden Ihre Datenschutzregeln eingehalten? Lassen Sie Ihre Go-Live-Abfragen auf den echten Daten laufen. Halten Sie Testfall – erwartet – beobachtet – Ursache fest.
SELECT typ, COUNT(*) FROM logbuch WHERE nutzdaten != '' GROUP BY typ; – hier dürfen nur erlaubte Typen erscheinen.Ausgezeichnet – Alle Aufgaben abgeschlossen!
Ihr Logbuch ist einsatzbereit (Meilensteine M2 und M3). Prüfen Sie:
Aufgaben: Datenmodell und sichere Abfragen eA
Eine Tabelle für alles ist bequem, aber redundant. Und Texte aus dem Funk dürfen nie zu SQL-Befehlen werden.
Entwerfen Sie ein ER-Modell mit den Entitätstypen Station, Paket, Bestellung und Statusmeldung (Attribute, Schlüssel, Beziehungen mit Kardinalitäten) und setzen Sie es in ein relationales Schema in Kurzschreibweise um (Primärschlüssel unterstrichen, Fremdschlüssel mit ↑).
Beurteilen Sie die Tabelle logbuch: Welche Redundanzen gibt es, und welche Änderungs- oder Löschanomalien können auftreten? Was spricht trotzdem für eine einzige Tabelle?
Material: neue Tabelle statusmeldung(nr, bestellnr, code, zeit, station). Ihre eigene Station LOGBUC (Station extends WebSocket) hört alle Rundrufe mit und trägt jede Statusmeldung ein.
Ergänzen Sie das Logbuch um meldeStatus(int bestellnr, String code, String station) und Ihre Station LOGBUC um den Aufruf für jede STA-Meldung. Erklären Sie an einem Beispiel, warum die Werte über Platzhalter ? übergeben werden und nicht in den SQL-Text geklebt (SQL-Injection).
prepareStatement("INSERT INTO statusmeldung (bestellnr, code, zeit, station) VALUES (?, ?, ?, ?)"), dann setInt, setString, executeUpdate()."… VALUES (" + bestellnr + ", '" + code + "', …" aus einem Code wie X'); DELETE FROM statusmeldung; -- machen? Wer kann solche Texte in den Funk schicken?Berechnen Sie für jede gelieferte Bestellung die Zeit von ANN bis LIE und die durchschnittliche Lieferzeit (Bedingung 4 Ihrer Karte).
FROM statusmeldung a, statusmeldung b WHERE a.bestellnr = b.bestellnr AND ….Ausgezeichnet – Alle Aufgaben abgeschlossen!
Ihre Erweiterung läuft (Meilenstein M4). Prüfen Sie:
Sicherung
Grundsatz des Datenschutzes: Personenbezogene Daten werden nur so lange gespeichert, wie es für den Zweck nötig ist; danach werden sie gelöscht (Löschfrist).
Ein Logbuch protokolliert aus der Sicht jeder Station; im gemeinsamen Medium erscheint ein Paket deshalb mehrfach. Für Auswertungen nutzt man GROUP BY mit Aggregatfunktionen (COUNT, SUM, MAX, MIN, AVG), HAVING für Bedingungen an Gruppen und LIKE mit _ und % für Muster. Datenschutz heißt: nur speichern, was für den Zweck nötig ist (Datensparsamkeit, Zweckbindung), rechtzeitig löschen (Speicherbegrenzung) und den Zugriff regeln. Auch Metadaten sind personenbezogen. eA Werte aus dem Netz kommen nur über PreparedStatement in SQL.
Das liefert das Logbuch an alle Abteilungen.
| Was | an wen | Inhalt |
|---|---|---|
| Datenbank, Schreib-Code | alle Stationen | Tabelle logbuch (eA zusätzlich statusmeldung) |
geänderte Klasse Logbuch | alle Gruppen | datensparsames Speichern (eA meldeStatus) |
| Lese-Code, Leitstand, Abfragen | alle Gruppen, Beamer | Auswertung im Go-Live |
Vergleichen Sie Ihren Plan aus dem Einstieg mit Ihrem fertigen Logbuch: Welche Plan-Punkte haben sich bestätigt, welche mussten Sie ändern – und warum?
Die Wiederholungsabfrage zeigt, ob die Zentrale den Auftrag wirklich mehrfach gesendet hat und ob KURIR2 ihn je gültig gehört hat. Die ZAH-Zeilen klären, ob eine Zahlung zweimal ankam, und die Statusmeldungen liefern die Lieferzeit. Dafür muss das Logbuch weder Bestellungen noch Adressen noch Zahlungen dauerhaft speichern.
Go-Live: Der erste echte Abend
Worum es geht: Jede Abteilung hat ihren Schnittstellentest bestanden – trotzdem läuft das Ganze nicht von selbst. → Mit Startcheck, Rauchtest und einem Bestelllauf unter Störung zeigt der Kurs, dass das Liefernetz im Verbund arbeitet, und belegt Erfolge und Fehler mit SQL.
Einstieg: 6 Bestellungen, 1 geliefert
Generalprobe am Ende der letzten Abteilungsstunde: Alle starten gleichzeitig ihre Stationen, KUNDE1 schickt sechs Bestellungen. Die Ausgaben der Stationen am Beamer:
ZENTRA Abbruch: KUNDEN antwortet nicht. ZENTRA 001: wartet auf Adresse … KURIR1 BST verworfen – noch kein Stadtplan KASSE1 Zahlung von KURIR2 unlesbar: QWBTMEKS STATUS WARNUNG Bestellung 3: ABH ist hier nicht erlaubt STATUS WARNUNG Bestellung 4: LIE ist hier nicht erlaubt LOGBUC 0 Einträge Ergebnis: 6 Bestellungen, 1 geliefert.
Jede Abteilung hatte ihren Schnittstellentest bestanden – trotzdem funktioniert das Ganze nicht.
Leitfrage: Warum scheitert ein Netz aus lauter getesteten Stationen – und was muss geprüft sein, bevor der erste Kunde bestellt?
Nebenfragen:
- Welche Fehler liegen an der Spezifikation, welche an der Implementierung, welche nur am Betrieb (Startreihenfolge, Codes, Schlüssel, Versionen)?
- Woran messen wir, ob der Abend ein Erfolg war?
Sammeln Sie im Kurs: Ausgabe → vermutete Ursache → Kategorie.
- Ordnen Sie jeder Zeile der Generalprobe eine vermutete Ursache zu.
- Zeichnen Sie die Abhängigkeiten als Startreihenfolge: Wer muss schon laufen, damit eine Station sinnvoll arbeiten kann?
- Legen Sie drei bis fünf Kennzahlen fest, die Sie hinterher per SQL bestimmen.
Die Lehrkraft hält die Startreihenfolge des Kurses an der Tafel fest; sie gilt für den Startcheck.
Ablauf des Abends. gA: Startcheck und Rauchtest → ein Bestelllauf mit Störung (scheitert der Rauchtest, vorher ein kurzer Lauf ohne Störung) → Auswertung per SQL → Sicherung; Fehlerprotokoll als Hausaufgabe. eA: wie gA, danach Hotfix der wichtigsten Fehler → zweiter Lauf mit Angriffen der Konkurrenz und vielen Bestellungen → Auswertung mit der Tabelle statusmeldung. Jede Gruppe teilt sich auf: Betrieb der Station und Beobachtung. Zwei Freiwillige können als Integrationsteam den Rauchtest leiten und die Tafelliste führen.
Wenn eine Station ausfällt: Die Lehrkraft startet für jede Abteilung eine Ersatzstation mit den Referenzformaten. Fällt Ihre Station aus und lässt sie sich nicht in wenigen Minuten wieder starten, übernimmt die Ersatzstation Ihr Rufzeichen, und der Lauf geht weiter. Ihre Gruppe beobachtet weiter und analysiert den Ausfall im Fehlerprotokoll – ein Ausfall ist kein Scheitern, sondern Material.
Aufgaben: Startklar
Vor dem ersten Kunden muss klar sein, dass jede Station läuft und ihre Partner versteht.
Material: Startreihenfolge an der Tafel, Ihre Station, Schnittstellenvertrag.
Gehen Sie vor dem Start diese Liste durch und haken Sie ab: Rufzeichen (6 Zeichen, eindeutig); Sitzungscode FN-<Kurs>-LIVE; Datenbank-Code; Störprofil laut Ansage; Schlüssel (Kasse, Kurier); aktuelle Klassenversionen (Logbuch, Partnerklassen); demo = false; Geschwindigkeitsregler der IDE auf Maximum. Starten Sie erst, wenn Sie laut Startreihenfolge dran sind, und tragen Sie „gestartet“ in die Tafelliste ein. Legen Sie außerdem einen Beobachtungsbogen an.
Schicken Sie Ihren Partnerabteilungen je ein Testpaket nach Schnittstellenvertrag und prüfen Sie die Reaktion (z. B. Zentrale → Kundenverzeichnis: Anfrage zu Bestellung 999; Kurier → Kasse: Testzahlung für Bestellung 999 über 1 Cent). Melden Sie dem Integrationsteam „Rauchtest bestanden“ oder den Fehler.
nutzdaten NOT LIKE '999%').Ausgezeichnet – Alle Aufgaben abgeschlossen!
Ihre Station ist startklar. Prüfen Sie:
Aufgaben: Der Bestelllauf
Jetzt bestellt die Kundschaft – und der Störkanal ist an.
Betreiben Sie Ihre Station während des Laufs mit dem angesagten Störprofil und führen Sie den Beobachtungsbogen. Notieren Sie die Unix-Zeit von Start und Ende des Laufs. Achten Sie besonders auf Wiederholungen, Abbrüche, Warnungen der Statustafel und Doppelbuchungen. Ordnen Sie nach dem Lauf jede Auffälligkeit einer Kategorie zu: Spezifikation (Absprache unklar oder widersprüchlich), Implementierung (Programm hält sich nicht an die Absprache) oder Betrieb (falscher Code, falsche Reihenfolge, alte Version).
println((int) (System.currentTimeMillis() / 1000)); – oder die Lehrkraft schreibt beide Werte an die Tafel.STA) verloren – Warnungen der Statustafel sind dann nicht unbedingt ein Programmfehler.Ausgezeichnet – Alle Aufgaben abgeschlossen!
Der Lauf ist vorbei. Prüfen Sie:
Aufgaben: Auswertung im Logbuch
Messen statt vermuten: Belegen Sie Erfolg und Probleme des Abends mit Abfragen.
Material: Lese-Code der Kurs-Datenbank, Start- und Endzeit des Laufs, die Go-Live-Abfragen der Abteilung Logbuch (Leitstand). Notieren Sie jede Abfrage mit ihrem Ergebnis.
Bestimmen Sie für den Lauf, wie viele Bestellungen angenommen (ANN), geliefert (LIE) und storniert (STO) wurden, und berechnen Sie die Lieferquote. Deuten Sie das Ergebnis: Welche nicht gelieferten Bestellungen sind ein Fehler des Liefernetzes, welche nicht?
AUS-Zeile genau einmal im Logbuch – bei der Station, die sie gesendet hat.nutzdaten LIKE '___LIE' passt auf jede Bestellnummer mit dem Code LIE; den Zeitraum begrenzt zeit BETWEEN … AND ….Formulieren und beantworten Sie eine Frage zu Ihrer Abteilung, z. B. Zentrale: „Wie lange warteten Aufträge auf einen Kurier?“ (KOC bis ABH); Kurier: „Wie viele KRT-Pakete wurden gesendet?“; Kasse: „Wie viele Zahlungen gingen ein?“; Kundenverzeichnis: „Wie viele Anfragen kamen an?“; Bestellstatus: „Bei welchen Bestellungen fehlen Meldungen?“; Logbuch: „Hält sich jede Station an die Datenschutzregel?“.
Bestimmen Sie für den Lauf (1) die Anzahl gesendeter Datenpakete je Station, (2) die defekt empfangenen Pakete je Station, (3) die Pakete, die mehr als zweimal gesendet wurden. Welche davon wurden abgebrochen?
ACK und NAK. Pakete mit fünf Versuchen sind Abbrüche.Bestimmen Sie für drei Bestellungen Ihrer Wahl die Dauer von ANN bis LIE. Dauern eilige Bestellungen im Mittel kürzer?
MAX(zeit) - MIN(zeit) über alle AUS-Statusmeldungen mit nutzdaten LIKE '005%'.Ausgezeichnet – Alle Aufgaben abgeschlossen!
Die Kennzahlen stehen. Prüfen Sie:
Aufgaben: Fehler analysieren
Aus den Kennzahlen werden Verbesserungen. Diese Aufgaben erledigen Sie als Hausaufgabe im Protokollblatt.
Wählen Sie die zwei wichtigsten Probleme, die Ihre Abteilung betreffen (auch einen Ausfall Ihrer Station), und halten Sie je fest: Symptom, Beleg (Abfrage mit Ergebnis oder Logbuch-Zeilen), Ursache, Kategorie (Spezifikation / Implementierung / Betrieb), Verbesserung.
Ergänzen Sie im Protokollblatt die Regeln, die gefehlt haben, erhöhen Sie die Versionsnummer und informieren Sie betroffene Partnerabteilungen.
Ausgezeichnet – Alle Aufgaben abgeschlossen!
Ihre Analyse ist fertig. Prüfen Sie:
Aufgaben: Hotfix, Angriff und Last eA
Der zweite Abend: Die wichtigsten Fehler sind behoben, die Konkurrenz greift an, und es wird voll.
Beheben Sie die zwei wichtigsten Fehler aus dem ersten Lauf. Ändern Sie nur, was nötig ist, erhöhen Sie die Versionsnummer und informieren Sie die Partner, bevor der nächste Lauf startet.
Betreiben Sie Ihre Station in einem Lauf, in dem die Konkurrenz PIZPAR angreift und KUNDE1 viele Bestellungen in kurzer Zeit schickt (zwei Kuriere, Außenfiliale aktiv). Halten Sie für jeden Vorfall fest: Was haben Sie beobachtet? Welche Station hat ihn bemerkt, und wie (Ausgabe, Logbuch)? Welches Schutzziel war betroffen (Vertraulichkeit, Integrität, Authentizität, Verfügbarkeit)?
Wählen Sie zwei Angriffe, die im Lauf nicht abgewehrt wurden, und schlagen Sie je eine Abwehr vor, die mit Mitteln aus dem Unterricht umsetzbar ist. Beurteilen Sie den Aufwand.
Bestimmen Sie per SQL, wie viele Datenpakete pro Minute das Liefernetz im Lastlauf gesendet hat und wie lange Aufträge im Mittel auf einen Kurier warteten (KOC bis ABH, mit der Tabelle statusmeldung). Wo liegt der Engpass – im Funkprotokoll oder anderswo?
AUS-Datenpakete / Dauer in Minuten.statusmeldung mit sich selbst (Logbuch, Aufgabe 6).Die Zentrale sendet jedes Paket mit Stop-and-Wait. Schätzen Sie ab: Bei 200 ms Laufzeit hin und zurück und 20 % Verlust – wie viele Pakete pro Sekunde schafft eine Station höchstens? Beschreiben Sie, was ein Schiebefenster (mehrere unquittierte Pakete) ändern würde.
Ausgezeichnet – Alle Aufgaben abgeschlossen!
Der zweite Abend ist vorbei. Prüfen Sie:
Sicherung
Ein kurzer Test unmittelbar vor dem Betrieb: Jede Partnerschaft tauscht ein Testpaket aus und prüft die Reaktion. Er findet Betriebsfehler (falsche Codes, Reihenfolge, Versionen) in Minuten statt erst im laufenden Betrieb.
Ein Protokoll bewährt sich erst im Zusammenspiel: Neben Spezifikation und Implementierung braucht es geregelten Betrieb – Startreihenfolge, Rauchtest, gleiche Versionen. Prüfsumme, Quittung, Wiederholung und Sequenznummer fangen Störungen im Kanal auf; was dann noch schiefgeht, liegt meist an Nutzdaten, unquittierten Rundrufen oder am Betrieb. Fehler belegt man mit Daten (Logbuch, SQL) und ordnet sie Spezifikation, Implementierung oder Betrieb zu. Jede Regel, die im Go-Live fehlte, gehört danach ins Protokollblatt.
Vergleichen Sie Ihre Startreihenfolge und Ihre Kennzahlen aus dem Einstieg mit dem Abend: Was hat gestimmt, was hat gefehlt? Beantworten Sie danach die Leitfrage der Einheit in fünf Sätzen mit Beispielen aus Ihrem Go-Live: Wie können sich Zentrale, Kurierinnen und Kuriere, Kasse und Kundschaft über einen gemeinsamen, gestörten Funkkanal eindeutig und zuverlässig verständigen – und wer legt die Regeln dafür fest?
Aus „6 Bestellungen, 1 geliefert“ wird ein Abend, dessen Lieferquote, Dauer und Fehler Sie mit SQL belegen können. Die Fehler der Generalprobe lagen fast alle im Betrieb – Startreihenfolge, Codes, Schlüssel – und verschwinden mit Startcheck und Rauchtest. Was im Lauf trotzdem schiefging, steht jetzt mit Beleg und Verbesserung im Protokollblatt, das damit auch den Fehlerfall regelt.
Präsentation und Reflexion eA
Worum es geht: Nächstes Jahr soll ein anderer Kurs das Liefernetz übernehmen – ohne Quelltext, nur mit den Protokollblättern. → Sie prüfen gegenseitig Ihre Protokollblätter, verteidigen eine zentrale Entwurfsentscheidung und ordnen das Liefernetz in echte Netze ein.
Einstieg: Der Probeleser
Ein Probeleser aus dem Parallelkurs hat drei Protokollblätter gelesen und schreibt zurück:
- Zentrale: „Was machen Sie, wenn die Adressanfrage abbricht? Steht nirgends.“
- Kasse: „Ist der Betrag in Euro oder in Cent? Ihr Beispiel passt nicht zur Tabelle.“
- Kurier: „Warum RLE und nicht Huffman? Sie schreiben nur ‚weil es geht‘.“
Leitfrage: Was muss in einem Protokollblatt stehen, damit eine andere Gruppe ohne Rückfrage eine passende Station bauen kann?
Nebenfragen:
- Welche Ihrer Entscheidungen waren wirklich Entwurfsentscheidungen – mit Alternativen und Begründung?
- Wo findet man die Ideen unseres Liefernetzes in echten Netzen wieder, und was haben wir nicht gelöst?
Sammeln Sie im Kurs: Was fehlt dem Probeleser → was muss im Protokollblatt stehen?
- Lesen Sie Ihr eigenes Protokollblatt so, als müssten Sie danach programmieren. Wo müssten Sie raten?
- Suchen Sie die drei Entscheidungen, auf die Sie am meisten stolz sind – und eine, die Sie heute anders treffen würden.
Ablauf. Probelesen und Vortragsvorbereitung erledigen Sie als Hausaufgabe; die Protokollblätter werden vorher getauscht. In der Präsentationsstunde halten alle Gruppen ihren Vortrag, direkt danach folgt das Kolloquium Ihrer Gruppe. Danach vergleicht der Kurs das Liefernetz mit echten Netzen. Die Reflexion schreiben Sie einzeln als Hausaufgabe.
Aufgaben: Vorbereitung
Diese Aufgaben erledigen Sie vor der Präsentationsstunde.
Material: das Protokollblatt einer anderen Gruppe (Tausch nach Losverfahren), Ihr eigenes Protokollblatt, Vorlage Tabelle Ü8.
Lesen Sie das fremde Blatt so, als müssten Sie danach eine kompatible Station bauen. Notieren Sie jede Stelle, an der Sie raten müssten, und prüfen Sie die Beispiele gegen die Formattabellen. Geben Sie Ihre Rückmeldung schriftlich an die Gruppe.
Bereiten Sie einen Kurzvortrag vor: (1) das Problem Ihrer Abteilung in einem Satz, (2) eine zentrale Entwurfsentscheidung mit Alternativen und Begründung, (3) einen Beleg aus Test oder Go-Live (Abfrage mit Ergebnis), (4) was Sie in Version 2 ändern würden. Jede Person spricht.
Ausgezeichnet – Alle Aufgaben abgeschlossen!
Sie sind vorbereitet. Prüfen Sie:
Aufgaben: Präsentation und Kolloquium
Jede Gruppe stellt ihre Entscheidung vor und beantwortet anschließend Fragen.
Halten Sie Ihren Vortrag. Danach zieht jedes Gruppenmitglied eine Fragekarte der Lehrkraft (Kolloquium) und beantwortet sie am Protokollblatt oder am Code.
Stellen Sie einer anderen Gruppe mindestens eine „Was passiert, wenn …?“-Frage zu deren Protokollblatt und notieren Sie die Antwort.
Ausgezeichnet – Alle Aufgaben abgeschlossen!
Die Präsentationen sind gehalten. Prüfen Sie:
Aufgaben: Unser Liefernetz und das Internet
Unser Liefernetz ist ein kleines Modell echter Netze. Ordnen Sie es ein.
Material: Ein Schichtenmodell in vereinfachter Form: Bitübertragung, Sicherung, Vermittlung, Transport, Anwendung.
Ordnen Sie die Bausteine unseres Liefernetzes den Schichten zu und nennen Sie jeweils ein echtes Protokoll mit einer ähnlichen Aufgabe: Rauschen und Hamming (Funkstrecke); Prüfsumme mit NAK und Wiederholung; Rufzeichen und ALLE__; Sequenznummer; Teil/Gesamt; ADR (Kundenverzeichnis); Vigenère, Diffie-Hellman und Signatur (Kasse); BST, STA, ZAH.
Nennen Sie drei Dinge, die echte Netze anders oder besser lösen als FN/1, und begründen Sie, warum wir sie im Unterricht weggelassen haben.
Ausgezeichnet – Alle Aufgaben abgeschlossen!
Der Vergleich steht. Prüfen Sie:
Aufgaben: Reflexion
Diese Aufgaben bearbeiten Sie einzeln als Hausaufgabe und geben sie mit dem Protokollblatt ab.
Beurteilen Sie auf einer halben Seite: Welche personenbezogenen Daten fallen im Liefernetz an (auch Metadaten und die Klarnamen der Online-IDE)? Was haben wir geschützt, was nicht? Was müsste ein echter Lieferdienst zusätzlich tun?
getFirstName() und getLastName() des WebSocket-Clients, an das Logbuch, an Kurierpositionen und an Pizza Paradiso.Beschreiben Sie in fünf bis acht Sätzen Ihren eigenen Beitrag (konkret: welche Methode, welcher Test, welcher Fehler), Ihre wichtigste fachliche Erkenntnis und eine überprüfbare Verbesserung für Version 2.
Ausgezeichnet – Alle Aufgaben abgeschlossen!
Ihre Reflexion ist fertig. Prüfen Sie:
Sicherung
Aufteilung der Aufgaben eines Netzes auf übereinanderliegende Schichten (vereinfacht: Bitübertragung, Sicherung, Vermittlung, Transport, Anwendung). Jede Schicht löst ein Teilproblem und nutzt die Dienste der Schicht darunter.
Entwerfen heißt, unter vorgegebenen Bedingungen begründet zwischen Alternativen zu entscheiden und das Ergebnis so zu beschreiben, dass andere es umsetzen können – Formattabellen mit Beispielen, Regeln für Normal- und Fehlerfall, begründete Entscheidungen, Versionen. Die Ideen unseres Liefernetzes finden sich in echten Netzen in verschiedenen Schichten wieder – dort schneller, sicherer und sauber getrennt.
Vergleichen Sie Ihre Liste „Was ein gutes Protokollblatt braucht“ mit den Rückmeldungen, die Ihre Gruppe beim Probelesen bekommen hat: Was hat gefehlt? Was ändern Sie bis zur Abgabe?
Mit vollständigen Formattabellen samt passenden Beispielen, einer Regel für jeden Fehlerfall und Entscheidungen, die gegen Alternativen begründet sind, hätte der Probeleser keine seiner drei Fragen stellen müssen. Die Ideen unseres Liefernetzes – Fehlerkorrektur, Prüfsumme, Quittung, Sequenznummer, Fragmentierung, Namensdienst, Verschlüsselung – stecken in jedem echten Netz, dort nur schneller, sicherer und in Schichten getrennt.
Abiturtraining: Ein fremdes Protokoll
Worum es geht: Sie übertragen, was Sie an FN/1 gelernt haben, auf ein Protokoll, das Sie nicht kennen – mit Aufgaben im Abiturformat (Papier, ohne IDE).
Einstieg: Das Datenblatt der Wetterstation
Das GSG baut auf dem Schuldach und im Schulgarten ein Netz aus Wetterstationen auf. Jede Station funkt ihre Messwerte an einen Schulserver. Der Hersteller liefert das Protokoll WS/1 mit – unten steht sein Datenblatt. Ein Mitschüler meint: „Das ist doch dasselbe wie FN/1, nur kürzer.“
Leitfrage: Ist WS/1 so zuverlässig wie FN/1? Legen Sie sich nach dem ersten Lesen des Datenblatts fest und nennen Sie einen Grund.
- Welche Fragen haben Sie an FN/1 gestellt, bevor Sie ihm vertraut haben?
| Nr. | Plan-Punkt | Aufgabe |
|---|---|---|
| 1 | Pakete zerlegen und bauen | 1 |
| 2 | Prüfverfahren an Fehlerarten testen | 2 |
| 3 | Zerlegen und Prüfen programmieren bzw. als Struktogramm | 3 |
| 4 | Abläufe mit Verlust darstellen, Entwurf bewerten und mit FN/1 vergleichen | 4, 5 |
Material: Datenblatt WS/1
Ein WS/1-Paket ist ein Text aus genau 19 Zeichen mit festen Feldern.
| Feld | Pos. | Länge | Inhalt |
|---|---|---|---|
| Kennung | 0–2 | 3 | immer WS1 |
| Station | 3–4 | 2 | Nummer der Wetterstation 01–99 |
| Typ | 5 | 1 | M Messung (Station → Server), Q Quittung (Server → Station) |
| Seq | 6 | 1 | laufende Nummer 0–9, nach 9 folgt 0 |
| Temperatur | 7–10 | 4 | Vorzeichen und Zehntelgrad: +215 = 21,5 °C, -035 = −3,5 °C |
| Feuchte | 11–13 | 3 | relative Luftfeuchte in % 000–100 |
| Druck | 14–17 | 4 | Luftdruck in hPa, z. B. 1013 |
| Prüfziffer | 18 | 1 | siehe unten |
Prüfziffer: Betrachtet werden die Positionen 3 bis 17. Jede Ziffer wird mit ihrem Gewicht multipliziert: Gewicht 3 an geraden Positionen, Gewicht 1 an ungeraden Positionen. Zeichen, die keine Ziffern sind, zählen nicht. Die Prüfziffer ist die Summe dieser Produkte mod 10.
Ablauf: Station und Server halten sich an folgende Regeln.
- Die Station sendet eine Messung
Man alle (geteiltes Medium) und wartet höchstens 5 Sekunden auf eine QuittungQmit ihrer Stationsnummer und derselben Seq. Sonst sendet sie dasselbe Paket erneut, höchstens dreimal insgesamt. - Der Server quittiert jede gültige Messung – auch eine Wiederholung. Er speichert eine Messung nur, wenn die Seq von der zuletzt gespeicherten Seq dieser Station abweicht.
- Ein ungültiges Paket ignoriert der Server; eine negative Quittung gibt es nicht.
- Quittungen tragen die Messwerte
+0000000000, z. B.WS107Q3+00000000000.
Aufgaben: Pakete und Prüfziffer
Bearbeiten Sie die Aufgaben auf Papier. Die Bewertungseinheiten (BE) dienen der Orientierung wie im Abitur.
AFB I · 7 BE
Zerlegen Sie das Paket WS107M3+21507210134 in seine Felder und geben Sie die Messwerte mit Einheiten an.
Station 7 meldet mit Seq 3: 21,5 °C, 72 % Luftfeuchte, 1013 hPa, Prüfziffer 4.
Erstellen Sie das vollständige Paket: Station 12 meldet mit Seq 4 eine Temperatur von −3,5 °C, 88 % Luftfeuchte und 998 hPa. Berechnen Sie die Prüfziffer nachvollziehbar.
Vor dem Vergleich: Prüfen Sie, ob Ihr Paket genau 19 Zeichen hat.
Ohne Prüfziffer: WS112M4-0350880998.
| Feld (Positionen) | Ziffern · Gewicht | Summe |
|---|---|---|
Station 12 (3–4) | 1·1 + 2·3 | 7 |
Typ M (5) | keine Ziffer | 0 |
Seq 4 (6) | 4·3 | 12 |
Temperatur -035 (7–10) | Vorzeichen zählt nicht; 0·3 + 3·1 + 5·3 | 18 |
Feuchte 088 (11–13) | 0·1 + 8·3 + 8·1 | 32 |
Druck 0998 (14–17) | 0·3 + 9·1 + 9·3 + 8·1 | 44 |
Summe 113, Prüfziffer 3. Paket: WS112M4-03508809983.
AFB II · 6 BE
Gesendet wurde WS107M3+21507210134 (Summe 84, Prüfziffer 4). Untersuchen Sie, ob der Server die folgenden Verfälschungen erkennt. Begründen Sie jeweils mit der Änderung der Summe.
| Nr. | empfangen | Fehlerart |
|---|---|---|
| (1) | WS107M3+22507210134 | eine Ziffer verfälscht |
| (2) | WS107M3+12507210134 | zwei Ziffern vertauscht |
| (3) | WS107M3+21502710134 | zwei Ziffern vertauscht |
| (4) | WS107M3-21507210134 | Vorzeichen verfälscht |
1 in eine 2. Um wie viel ändert sich die Summe?Vor dem Vergleich: Formulieren Sie für jede Variante, was der Server speichern würde.
| Nr. | Änderung der Summe | neue Prüfziffer | erkannt? |
|---|---|---|---|
| ✓ (1) | +1 → 85 | 5 ≠ 4 | ja |
| ✓ (2) | (3·1 + 2) − (3·2 + 1) = −2 → 82 | 2 ≠ 4 | ja |
| ✗ (3) | (3·2 + 7) − (3·7 + 2) = −10 → 74 | 4 = 4 | nein: 27 % statt 72 % |
| ✗ (4) | 0 (Vorzeichen zählt nicht) | 4 = 4 | nein: −21,5 °C statt 21,5 °C |
Allgemein: Eine Vertauschung benachbarter Ziffern a, b ändert die Summe um 2(a − b). Sie bleibt unerkannt, wenn a − b durch 5 teilbar ist (z. B. 7 und 2).
Ausgezeichnet – Alle Aufgaben abgeschlossen!
Sie können WS/1-Pakete lesen, bauen und prüfen.
Aufgaben: Programmieren und Abläufe
Die folgenden Methoden gehören zu einer Klasse WS1 (alle public static). Verwenden Sie nur die im Abitur zugelassenen String-Operationen (length, charAt, substring, equals, ASCII-Umwandlung, Integer.parseInt).
AFB II · 11 BE
Implementieren Sie temperatur(String paket): int, die die Temperatur in Zehntelgrad mit Vorzeichen liefert (+215 → 215, -035 → −35). Das Paket hat sicher 19 Zeichen.
paket.substring(8, 11) liefert den Betrag als Text; Integer.parseInt macht daraus eine Zahl.public static int temperatur(String paket) {
int betrag = Integer.parseInt(paket.substring(8, 11));
if (paket.charAt(7) == '-') {
return -betrag;
}
return betrag;
}Stellen Sie die Methode pruefziffer(String paket): int als Struktogramm dar. Sie berechnet die Prüfziffer nach dem Datenblatt aus den Positionen 3 bis 17.
zahlAus aus Kapitel 2.)Hilfe 2: Ergänzen Sie:
Implementieren Sie istGueltig(String paket): boolean. Ein Paket ist gültig, wenn es genau 19 Zeichen hat, mit WS1 beginnt, den Typ M oder Q hat und die Prüfziffer an Position 18 mit pruefziffer(paket) übereinstimmt. Laufzeitfehler müssen ausgeschlossen sein.
charAt(18) keinen Laufzeitfehler auslöst?(int) paket.charAt(18) - 48. Was ergibt das, wenn dort keine Ziffer steht – und ist das ein Problem?Vor dem Vergleich: Testen Sie Ihre Methode gedanklich mit "WS1" (zu kurz) und mit Variante (4) aus Aufgabe 2.
public static boolean istGueltig(String paket) {
if (paket == null || paket.length() != 19) {
return false;
}
if (!paket.substring(0, 3).equals("WS1")) {
return false;
}
char typ = paket.charAt(5);
if (typ != 'M' && typ != 'Q') {
return false;
}
int pz = (int) paket.charAt(18) - 48;
return pz == pruefziffer(paket);
}Die Längenprüfung steht zuerst, sonst droht bei kurzen Texten ein Laufzeitfehler. Steht an Position 18 keine Ziffer, liegt pz außerhalb von 0–9 und ist nie gleich der berechneten Prüfziffer – das Paket ist ungültig. Variante (4) gilt als gültig.
AFB II · 7 BE
Station 07 sendet die Messung mit Seq 3. Der erste Versuch geht verloren. Der zweite kommt an, aber die Quittung geht verloren. Der dritte kommt an, die Quittung auch. Stellen Sie den Ablauf als Sequenzdiagramm dar (Zeit von oben nach unten) und beschreiben Sie, was der Server jeweils tut.
Als Tabelle notiert; gezeichnet stehen die Station und der Server nebeneinander.
| Zeit | Station 07 | Kanal | Server |
|---|---|---|---|
| ✗ 0 s | sendet M 3 (Versuch 1), wartet | → ✗ verloren | |
| 5 s | Timeout → M 3 (Versuch 2) | → | |
| ✗ 5,1 s | ✗ verloren ← | gültig, Seq 3 neu → speichern, Q 3 | |
| 10 s | Timeout → M 3 (Versuch 3) | → | |
| 10,2 s | gültig, Seq 3 = letzte Seq von 07 → Duplikat: nicht speichern, aber Q 3 | ||
| 10,3 s | Q 3 passt → fertig | ← |
Beschreiben Sie, was dann bei Station und Server passiert, und beurteilen Sie die Folge.
Nach dem dritten Versuch und weiteren 5 s gibt die Station auf und meldet einen Fehler. Die Messung ist trotzdem gespeichert (seit Versuch 2). Die Station kann nicht unterscheiden, ob die Messung oder nur die Quittungen verloren gingen. Für Wetterdaten ist das unkritisch: Die nächste Messung kommt ohnehin.
Ausgezeichnet – Alle Aufgaben abgeschlossen!
Sie können ein fremdes Protokoll auf Papier analysieren und umsetzen.
Aufgaben: Bewerten und vergleichen
Zum Schluss beurteilen Sie WS/1 als Ganzes und vergleichen es mit FN/1.
AFB III · 10 BE
Beurteilen Sie das Prüfverfahren von WS/1 im Vergleich zur Prüfsumme von FN/1. Gehen Sie auf einzelne Fehler, Vertauschungen und ungeschützte Zeichen ein und schlagen Sie eine begründete Verbesserung vor.
Vor dem Vergleich: Haben Sie ein Urteil formuliert (nicht nur Unterschiede aufgezählt)?
| Fehlerart | WS/1 | FN/1 |
|---|---|---|
| eine Ziffer verfälscht | immer erkannt (Gewicht 1 oder 3 mal Änderung 1–9 ist nie durch 10 teilbar) | immer erkannt |
| ein Buchstabe/Vorzeichen verfälscht | nie erkannt (zählt nicht mit) | immer erkannt |
| Nachbarn vertauscht | erkannt, außer bei Differenz 5 | nie erkannt |
| zufällige Mehrfachfehler | etwa jeder zehnte unerkannt (eine Prüfziffer) | etwa jeder tausendste (drei Stellen) |
Urteil: WS/1 ist bei Vertauschungen besser, hat aber eine gefährliche Lücke: Ein verfälschtes Vorzeichen macht aus 21,5 °C unbemerkt −21,5 °C, und Kennung und Typ sind ungeschützt. Mit nur einer Prüfziffer ist der Schutz insgesamt schwächer. Verbesserung z. B.: Vorzeichen als Ziffer kodieren (0 = +, 1 = −) und mitzählen, oder eine gewichtete Summe der ASCII-Werte aller Zeichen mod 97 als zweistellige Prüfzahl.
Bewerten Sie (1) die einstellige Seq und (2) den Verzicht auf negative Quittungen.
(1) Bei Stop-and-Wait vergleicht der Server nur mit der zuletzt gespeicherten Seq derselben Station; eine Wiederholung trägt dieselbe Seq, die nächste Messung eine andere. Dafür reichen sogar zwei Werte (0/1, Alternating-Bit-Verfahren) – eine Ziffer genügt. Problematisch wird es nur, wenn eine Station neu startet und mit der zuletzt gespeicherten Seq beginnt. (2) Ohne NAK wartet die Station bei einem verfälschten Paket den Timeout von 5 s ab, statt sofort zu wiederholen: langsamer, aber einfacher, und ein Quittungs-Pingpong ist ausgeschlossen. Bei Messwerten im Minutentakt ist die Verzögerung unerheblich – die Entscheidung passt zum Einsatzzweck.
Ausgezeichnet – Alle Aufgaben abgeschlossen!
Sie haben WS/1 begründet bewertet.
Sicherung
Ein fremdes Protokoll untersuchen Sie mit vier Fragen: (1) Format: Welche Felder stehen wo, fest oder variabel? (2) Fehlererkennung: Welche Zeichen sind geschützt, welche Fehlerarten fallen auf? (3) Zuverlässigkeit: Quittung, Seq, Timeout, Wiederholung, Duplikaterkennung? (4) Zweck: Passen die Abwägungen zum Einsatz?
Lesen Sie Ihre Festlegung aus dem Einstieg. Wo lag Ihr Mitschüler richtig, wo nicht?
WS/1 benutzt dieselben Ideen wie FN/1 – feste Felder, Prüfwert, Stop-and-Wait mit Seq und Duplikaterkennung –, wägt aber anders ab: kürzer, kein NAK, eine Prüfziffer. „Genauso zuverlässig“ stimmt nicht: Vertauschungen erkennt WS/1 besser, ein verfälschtes Vorzeichen oder einen falschen Typ gar nicht.