UML-Sequenzdiagramme zeichnen: Der Abitur-Leitfaden

1 · Was ist ein UML-Sequenzdiagramm?

In der objektorientierten Programmierung (OOP) besteht ein Programm aus mehreren Objekten, die miteinander kommunizieren — indem sie gegenseitig Methoden aufrufen. Ein UML-Sequenzdiagramm macht genau diese Kommunikation sichtbar: Es zeigt, wer wen anruft, welche Methode aufgerufen wird und — ganz wichtig — in welcher Reihenfolge das alles passiert. Die Zeit läuft dabei immer von oben nach unten.

Stell dir vor, ein Arzt nimmt einen neuen Patienten in eine Abteilung auf. Intern passiert dabei einiges: Die Abteilung fragt jedes ihrer Zimmer, ob es noch frei ist. Ein freies Zimmer fügt den Patienten zu seiner Patientenliste hinzu und meldet zurück, ob das geklappt hat. Diesen gesamten Ablauf — wer mit wem spricht und in welcher Reihenfolge — visualisiert ein Sequenzdiagramm.

2 · Grundelemente auf einen Blick

Beispiel Grundelemente eines UML-Sequenzdiagramms

Von oben nach unten: Initialer Aufruf (Kreis-Pfeil von links), Aktivierungsbalken auf : A, synchroner Aufruf auf : B (ausgefüllte Dreieckspfeilspitze ▶), Rückgabepfeil (gestrichelt, mit { rueckgabe }), abschließende Rückgabe nach außen.

3 · Notation im Detail

3.1 Teilnehmer & Lebenslinien

Jedes Objekt, das an der Kommunikation beteiligt ist, wird als Teilnehmer dargestellt: ein Rechteck oben mit einem Namen, darunter eine gestrichelte senkrechte Linie. In der Vorlage sind alle Teilnehmer immer bereits vorgegeben — du musst keine eigenen erfinden (außer wenn die Aufgabe ausdrücklich ein neues Objekt verlangt, → Abschnitt 3.6).

3.2 Aktivierungsbalken

Der Aktivierungsbalken (auch Ausführungsbalken) ist ein schmales, hohes Rechteck auf der Lebenslinie. Er zeigt an, dass das Objekt in diesem Zeitraum aktiv ist, also gerade eine Methode ausführt.

3.3 Synchroner Methodenaufruf

Alle Methodenaufrufe im Abitur sind synchron — das aufrufende Objekt wartet, bis die aufgerufene Methode beendet ist. Dargestellt wird das durch einen durchgezogenen Pfeil mit ausgefüllter, dreieckiger Pfeilspitze (▶) von links nach rechts.

3.4 Rückgabepfeil — immer einzeichnen!

Pflicht Rückgabepfeil — void vs. mit Rückgabewert

Oben: Void-Methode — gestrichelter Pfeil ohne Beschriftung (trotzdem Pflicht!). Unten: Methode mit Rückgabewert — Beschriftung in geschweiften Klammern { ergebnis }.

3.5 Selbstaufruf (Self-Call)

Wenn ein Objekt eine eigene Hilfsmethode aufruft, zeichnet man einen Pfeil, der vom Aktivierungsbalken des Objekts ausgeht und wieder auf ihn zurückzeigt. Ein zweiter, leicht nach rechts versetzter Aktivierungsbalken repräsentiert die aufgerufene Hilfsmethode.

Selbstaufrufe kommen im Abitur häufig vor, wenn eine Klasse komplexere Logik in private Hilfsmethoden auslagert.

Notation Selbstaufruf

Objekt : A ruft seine eigene Methode hilfsMethode() auf. Der Pfeil kehrt auf einen zweiten, leicht rechts versetzten Aktivierungsbalken zurück. Der Rückgabepfeil der Hilfsmethode ist ebenfalls Pflicht.

3.6 Neues Objekt erstellen («create»)

Manchmal muss im Verlauf einer Methode ein komplett neues Objekt erstellt werden, das vorher nicht existierte. Das neue Objekt wird als neues Rechteck auf seiner eigenen Lebenslinie eingezeichnet — auf der Höhe, auf der es erstellt wird, nicht ganz oben. Der Konstruktoraufruf wird durch einen Pfeil mit dem Stereotyp «create» dargestellt.

Notation Neues Objekt erstellen mit «create»

Objekt : A erstellt ein neues : B mit «create» B(param). Das Objektrechteck erscheint auf der Höhe des Pfeils. Der kleine Aktivierungsbalken danach ist Pflicht laut Abitur-Musterlösung.

3.7 Destruktionsmarkierung (X)

In sehr seltenen Fällen wird das Ende der Lebenslinie eines Objekts mit einem X markiert, das anzeigt, dass das Objekt zerstört wurde — beispielweise nach einem close()-Aufruf. Du musst dieses X nur dann selbst einzeichnen, wenn die Aufgabe es explizit verlangt, zum Beispiel durch die Formulierung „Schließlich wird das Objekt geschlossen." In allen anderen Fällen ist die Destruktionsmarkierung nicht erforderlich. Jedoch war dies nur ein einzelnes Mal in den letzten 10 Jahren nötig (2016 A).

4 · Fragmente — Schleifen und Bedingungen

Wenn ein Teil des Ablaufs wiederholt oder nur unter bestimmten Bedingungen ausgeführt wird, verwendet man kombinierte Fragmente. Ein Fragment ist ein rechteckiger Rahmen, der die betroffenen Nachrichten einschließt. In der oberen linken Ecke steht das Schlüsselwort (loop, opt oder alt), danach folgt die Bedingung in eckigen Klammern.

4.1 loop — Wiederholung

Fragment loop — Wiederholung

Alle Methodenaufrufe innerhalb des loop-Rahmens werden für jedes Element der Liste wiederholt. Der Rahmen zeigt klar die Grenzen der Schleife.

4.2 opt — Optionaler Block

Fragment opt — Optionaler Block

Nur wenn ok = true gilt, wird der enthaltene Block ausgeführt. Kein else-Zweig — entweder der Block läuft, oder er wird komplett übersprungen.

4.3 alt — Fallunterscheidung (if/else)

Fragment alt — Fallunterscheidung

Zwei Zweige, getrennt durch eine gestrichelte Linie. Nur einer wird ausgeführt. Im Abitur ist der else-Zweig oft mit „else" beschriftet, da meistens nur ein gewöhnlicher bool für die Bedingung verwendet wird.

5 · Die Vorlage (Zeichenvorlage) verstehen

In jedem Abitur-Vorschlag der letzten 10 Jahre war eine Zeichenvorlage gegeben — du zeichnest nie auf einem leeren Blatt. Die Vorlage (im Material als „Material X" bezeichnet) liefert dir immer Folgendes:

Vorlage Typische Zeichenvorlage — ABI 2025 A

Drei Teilnehmer sind bereits eingezeichnet: : Abteilung, : Zimmer und : List<Patient>. Der initiale Aufruf aufnehmenPatient(patient) und der Aktivierungsbalken des Abteilung-Objekts sind vorgegeben. Alles weitere muss der Schüler selbst ergänzen. Überprüfe auch sofort im Klassendiagramm, ob die Methoden einen Rückgabewert hat.

6 · Aufgabentypen — Wie viel wird dir erklärt?

Nicht jede Aufgabe erklärt dir gleich viel darüber, was die Methode eigentlich tut. Es gibt zwei Grundszenarien:

6.1 Typ A — Die Methode ist beschrieben

6.2 Typ B — Die Methode muss erschlossen werden

7 · Schritt-für-Schritt-Vorgehen

1. Vorlage analysieren. Notiere alle Teilnehmer und ihre Klassen. Welche Methoden haben diese Klassen laut Klassendiagramm? Welche Assoziationen bestehen (wer kennt wen)?
2. Aufgabentext auswerten. Ist die Methode beschrieben (Typ A) oder nur benannt (Typ B)? Bei Typ A: Markiere alle Handlungsschritte im Text. Bei Typ B: Leite den Ablauf aus Methodenname, Vorlage und Klassendiagramm ab.
3. Ablauf in Teilschritte aufteilen. Ordne jedem Schritt den richtigen Teilnehmer und die richtige Methode zu: Wer ruft wen auf? Welche Methode mit welchen Parametern? Gibt die Methode etwas zurück, und wenn ja was?
4. Fragmente identifizieren. Gibt es Schleifen (loop) oder Bedingungen (opt, alt)? Erkennungsworte: „für jedes …" → loop; „sofern …", „falls …" → opt oder alt; „… ansonsten …" → alt.
5. Platz einteilen. Plane vor dem Zeichnen grob, wie viel Platz du für jeden Abschnitt brauchst — besonders bei verschachtelten Fragmenten. Das verhindert, dass du am Ende nicht mehr genug Platz hast.
6. Von oben nach unten zeichnen. Beginne beim initialen Aufruf (bereits vorgegeben) und füge Schritt für Schritt hinzu: erst Aufrufpfeil, dann Aktivierungsbalken des Empfängers, dann ggf. Unteraufrufe, dann Rückgabepfeil.
7. Kontrollieren: Kein offener Balken. Am Ende prüfst du systematisch: Jeder Aktivierungsbalken muss mit einem Rückgabepfeil abschließen — auch void-Methoden. Kein Balken darf ohne Rückgabe enden.
8. Abschließende Rückgabe zeichnen. Ganz am Ende der Methode: Rückgabepfeil nach links aus dem Diagramm heraus, ggf. mit { wert } beschriftet. Auch bei void wird dieser Pfeil gezeichnet.

8 · Vollständige Beispiele aus dem Abitur

ABI 2025 A aufnehmenPatient() · Klasse Abteilung 7 BE

8.1.1 Aufgabenstellung

Aufgabe 1.7 — Typ B (Methode erschließen) Die Methode aufnehmenPatient(patient : Patient) der Klasse Abteilung nimmt einen neuen Patienten in der Abteilung auf, sofern ein freies Zimmer gefunden wurde. Entwickeln und zeichnen Sie ein Sequenzdiagramm für diese Methode.
Hinweis: Eine Vorlage ist in Material 4 zu finden.

8.1.2 Analyse — Was die Aufgabe nicht sagt, aber du weißt

Was sagt die Vorlage?

Drei Teilnehmer: : Abteilung, : Zimmer und : List<Patient>. → Die Methode interagiert mit Zimmer-Objekten und einer Patientenliste.

Was musst du selbst herleiten?

„Aufnehmen" bedeutet: Einem Patienten wird ein Zimmer zugewiesen. Aus dem Klassendiagramm: Zimmer hat - istVoll() : boolean (privat, nicht direkt aufrufbar) und + belegen(patient : Patient) : boolean (öffentlich, direkt aufrufbar), das ist wichtig, denn die istVoll()-Methode kann hier nicht vom Abteilungs-Objekt aufgerufen werden, hier muss man darauf kommen, dass belegen(patient : Patient) bereits diese Methode aufruft, was man auch einzeichnen muss. Da die Abteilung mehrere Zimmer hat, wird per Schleife (loop) über alle Zimmer iteriert. Für jedes Zimmer: Prüfe ob es voll ist (istVoll() → { belegt }). Ist es frei (opt belegt = false): Füge den Patienten zur Liste hinzu (add(patient)). Das Zimmer gibt dann zurück, ob die Aufnahme geklappt hat ({ ok }). Die Methode gibt dies am Ende als { ok : boolean } zurück, aufnehmenPatient() soll ja einen boolean zurückgeben.

8.1.3 Vorlage und Musterlösung

Vorlage Gegebene Vorlage

Musterlösung anzeigen

8.1.4 Aufschlüsselung der Lösung

loop für jedes zimmer aus zimmerListe

Die Abteilung hat mehrere Zimmer (Abteilung kennt mehrere '*' Zimmer, also hat sie eine Liste von Zimmern), daher wird über alle iteriert. Der loop-Rahmen umschließt alle Aufrufe, die pro Zimmer wiederholt werden.

Zimmer ruft sich selbst auf: istVoll()

Das Zimmer-Objekt überprüft mit einem Selbstaufruf (Zimmer → Zimmer: istVoll()), ob es noch freie Plätze hat. Das Ergebnis { belegt } wird als Rückgabepfeil zurück an sich selbst eingezeichnet — und dann weiter aufwärts an : Abteilung als Rückgabe von belegen().

opt belegt = false → Liste: add(patient)

Nur wenn das Zimmer nicht voll ist, wird der Patient der Liste hinzugefügt. Das opt-Fragment enthält den add()-Aufruf auf der Liste. Da add() void zurückgibt, ist der Rückgabepfeil leer (aber trotzdem einzuzeichnen!).

ABI 2023 C ausfuehrenSpielzug() · Klasse CanastaManager 8 BE

8.2.1 Aufgabenstellung

Aufgabe 1.3 — Typ A (detailliert beschrieben) — Selber die einzelnen Schritte farbig markiert Die Methode ausfuehrenSpielzug(sp : Spieler) der Klasse CanastaManager zieht die oberste Karte vom Haufen (1. Position im Container haufen) und fügt sie sortiert in die Handkarten des Spielers ein. Dann wählt der Spieler eine Karte auf seiner Hand aus, die er ablegen möchte. Dazu wählt er den Index dieser Karte und entfernt sie somit von seiner Hand. Anschließend wird diese Karte als oberste auf den Stapel (stapel) abgelegt.

8.2.2 Analyse — Vier Hauptschritte

Schritt 1: Karte vom Haufen ziehen

Selbstaufruf: CanastaManager → CanastaManager: holeVomHaufen(). Im Innern: haufen.remove(0) (Listen sind 0-Indexed, das heißt sie beginnen bei 0, die 1. Position ist deshalb 0) → gibt die oberste Karte { k } zurück. Die Hilfsmethode gibt dann { k } zurück an den äußeren Aufruf.
Merke: Zusatz Infos in Klammern sind oft sehr hilfreich!

Schritt 2: Karte sortiert einfügen

sp.fuegeSortiertEin(k) → Der Spieler ruft intern aktuelleHandkarten.add(index, k) auf. Beide Rückgabepfeile sind void (leer, aber Pflicht).

Schritt 3: Karte auswählen und entfernen

sp.waehleKarte() → gibt { pos } zurück. Danach: sp.entferneKarte(pos) → intern aktuelleHandkarten.remove(pos) → gibt { karte } zurück. Beides wird aufwärts weitergegeben.

Schritt 4: Karte auf den Stapel legen

Selbstaufruf: CanastaManager → CanastaManager: legeAufStapel(karte). Im Innern: stapel.add(karte). Void-Rückgaben auf beiden Ebenen.

✓ Musterlösung ABI 2023 C — ausfuehrenSpielzug()

Zwei Selbstaufrufe (holeVomHaufen(), legeAufStapel()) mit je einem verschachtelten Listenaufruf im Innern. Alle Rückgabepfeile sind eingezeichnet — auch die leeren void-Rückgaben auf Listenebene. Kein Fragment benötigt (kein loop, kein opt).

ABI 2023 B bearbeiteAuftrag() · Klasse TaxiZentrale 8 BE

8.3.1 Aufgabenstellung

Aufgabe 1.3.2 — Typ A (beschrieben, Vorlage bereits teilweise ausgefüllt) Die Methode bearbeiteAuftrag(von : Adresse, nach : Adresse) der Klasse TaxiZentrale sucht nach freien Taxis, die sich zur angefragten Zeit am nächsten an der Startadresse befinden. Für die ermittelten Taxis wird beim Fahrer angefragt, ob er bereit ist für die Annahme des Auftrags. Signalisiert der Fahrer seine Bereitschaft, wird der Auftrag an ihn vergeben. Konnte ein Taxi ermittelt werden, gibt die Methode true zurück, ansonsten false.

8.3.2 Variante: Code-Skizze vor dem Zeichnen

Idee: Bevor du das Sequenzdiagramm zeichnest, schreibst du die Methode zunächst als explizite Code-Skizze in einer C#/Python-Fusion auf. Das klingt nach mehr Arbeit — aber es trennt die zwei schwierigen Teilaufgaben: erst denken (was macht die Methode?), dann zeichnen (wie sieht das im Diagramm aus?). So machst du beides einzeln, statt beides gleichzeitig.

Warum hilft das?

Beim direkten Zeichnen passiert das: Mitten im Diagramm merkst du, dass du ein Fragment vergessen hast oder ein Objekt fehlt — und fängst von vorne an. Mit der Code-Skizze liest du das Diagramm quasi direkt vom Code ab. Du weißt genau: wie viele Fragmente, welche Selbstaufrufe, welche Rückgabewerte. Weniger Fehler, kein Neuanfang.

Voraussetzung

Diese Variante setzt voraus, dass du Grundkenntnisse in OOP und C# oder Python hast — also zumindest weißt, was eine Schleife, eine Bedingung und ein Methodenaufruf sind. Wer kurz vor dem Abitur steht, hat das normalerweise. Wer die Logik der Implementierung nicht herleiten kann, wird auch mit der Code-Skizze nicht weiter kommen.

Die Regeln der Code-Skizze

1. Explizit, keine Verschachtelung: Methodenaufrufe dürfen nicht geschachtelt werden. Statt if (taxi.getFahrer().isReady()) schreibst du immer zwei separate Zeilen — eine für den Aufruf, eine für das Ergebnis. Jeder Pfeil im Diagramm entspricht genau einer Code-Zeile.

2. Unterstrich = Selbstaufruf: Ein führender Unterstrich (_methode()) markiert, dass dies ein Selbstaufruf ist (TaxiZentrale → TaxiZentrale). So vergisst du ihn beim Zeichnen nicht.

3. Tabs → Fragment-Tiefe: Die Einrückungstiefe verrät direkt, wie viele offene Fragmente an dieser Stelle aktiv sind. 1 Tab = innerhalb 1 Fragments, 2 Tabs = innerhalb 2 geschachtelter Fragmente usw.

4. break ≠ Schleifenende: Wenn die Musterlösung zwei Abbruchbedingungen für eine Schleife verwendet (für jedes taxi + Auftrag nicht vergeben), notiert man das im Code trotzdem als normales break — im Diagramm wird es dann als kombinierte Schleifenbedingung eingetragen.

Herleitung für diese Aufgabe: Aus der Aufgabenbeschreibung + Klassendiagramm lässt sich der Ablauf vollständig ableiten: Die Methode bekommt eine sortierte Taxiliste per Selbstaufruf, iteriert darüber, fragt jeden Fahrer per Selbstaufruf an und vergibt bei Bereitschaft per Selbstaufruf den Auftrag. Jeder dieser Schritte steht direkt im Aufgabentext. Den Tab "Code-Skizze" unten zeigt den fertig abgeleiteten Code.

8.3.3 Besonderheit: Teilweise vorgefertigte Vorlage

Bereits vorgefertigter Schritt: Die Vorlage für diese Aufgabe enthielt bereits den Selbstaufruf TaxiZentrale → TaxiZentrale: getTaxiSortiertNachStandort(von) inklusive Rückgabepfeil { taxiListe } als vorgezeichneten Bestandteil. Dieser Schritt war gegeben — du musstest ihn nicht selbst erfinden, nur fortsetzen. Das ist ein gutes Beispiel dafür, wie eine Vorlage dir schon einen Teil der Lösung verrät.

Vorlage Gegebene Vorlage (mit vorgez. Selbstaufruf)

Vorlage Musterlösung Code-Skizze

bool bearbeiteAuftrag(von, nach):
    // Schritt 1: Selbstaufruf, bereits in Vorlage vorgegeben
    var taxiListe = _getTaxiSortiertNachStandort(von)
    
    foreach (var taxi in taxiListe): // loop: für jedes taxi (+ Auftrag nicht vergeben)
        1 Tab → innerhalb 1 Fragments (loop)
        var f  = taxi.getFahrer()
        var ok = _anfragenBereitschaft(f, von, nach)  // Selbstaufruf → { ok }
        if (ok == true): // opt: ok = true → 2 Tabs = 2 Fragmente (loop + opt)
            _vergebeAuftrag(f, von, nach) // void-Selbstaufruf
            break // ≙ 2. Schleifenbedingung "Auftrag nicht vergeben"

    return ok

Tabs → Fragment-Tiefe lesen: 1 Tab = innerhalb loop · 2 Tabs = innerhalb loop + opt
Unterstrich = Selbstaufruf (TaxiZentrale → TaxiZentrale)
Das break wird im Diagramm nicht explizit gezeichnet — es steckt in der kombinierten Schleifenbedingung „für jedes taxi aus taxis und Auftrag nicht vergeben"

8.3.4 Aufschlüsselung der Lösung

Vorgabe: getTaxiSortiertNachStandort(von)

Dieser Selbstaufruf war bereits auf der Vorlage eingezeichnet — du übernimmst ihn unverändert und baust ab dort weiter.

loop — für jedes taxi, solange Auftrag nicht vergeben

Die Schleifenbedingung kombiniert zwei Teile: Die Iteration über die Liste und eine Abbruchbedingung (Auftrag noch nicht vergeben). Das ist ein typisches Muster im Abitur — die Schleife bricht ab, sobald ein Fahrer gefunden wurde.

getFahrer() → Selbstaufruf anfragenBereitschaft() → opt: vergebeAuftrag()

Erst wird der Fahrer des Taxis abgefragt ({ f }). Dann wird per Selbstaufruf die Bereitschaft beim Fahrer angefragt ({ ok }). Nur wenn ok = true, wird per weiterem Selbstaufruf der Auftrag vergeben. vergebeAuftrag() ist void — leerer Rückgabepfeil.

ABI 2022 B start() · Klasse EBClient (Client-Seite) 8 BE

8.4.1 Aufgabenstellung

Aufgabe 1.6.3 — Typ A (mit Protokoll & Server-Referenzdiagramm) Entwickeln und zeichnen Sie das UML-Sequenzdiagramm für die Client-Seite unter Berücksichtigung des Sitzungsprotokolls sowie des UML-Sequenzdiagramms für die Server-Seite (Material 4).
Hinweis: Die Methode getAnmeldeDaten() der Klasse EBClient liefert einen String in der Form anmelden;[iban];[pin], die Methode getUeberweisungsDaten() liefert einen String ueberweisen;[iban];[betrag] bzw. quit für das Beenden der Sitzung.

8.4.2 Besonderheiten dieser Aufgabe

Objekterstellung war bereits in der Vorlage: Die Vorlage enthielt bereits die Erstellung des : Socket-Objekts mit «create» Socket(hostname : String, port : int). Du musstest dieses Objekt nicht von Grund auf neu hinzufügen — der Erstellungsschritt war vorgegeben. Dein Einstiegspunkt war der Aufruf von connect() auf dem Socket. Normalerweise sollte man jedoch auch selbst darauf kommen.

Destruktionsmarkierung (X): Das Socket-Objekt wird am Ende der Methode mit close() geschlossen und seine Lebenslinie endet mit einem "X". Da das Schließen des Sockets nicht explizit Teil der Aufgabe war (aber auch zu deuten wäre), war es bereits in der Vorlage angegeben, musste also nicht selbst eingezeichnet werden.

Starke Schachtelung: Diese Aufgabe hat mehrere Ebenen von Fragmenten: opt ok = true (äußere Ebene, ob Verbindung aufgebaut) → opt antwort = "+OK..." (ob Anmeldung erfolgreich) → loop daten <> "quit" (Überweisungsschleife). Das ist das komplexeste Beispiel der letzten Jahre — eine gute Übungsaufgabe.

Vorlage Gegebene Vorlage

Vorlage Musterlösung Code-Skizze

void start():
    // socket bereits durch «create» in der Vorlage erstellt
    Socket socket = new(hostname, port)

    var ok = socket.connect()
    if (ok == true): // normalerweise "if (socket.connect())" aber hier trennen!
        var antwort = socket.readLine() // { "+OK E-Banking" }
        var daten = _getAnmeldeDaten()
        socket.write(daten + "\n")
        var antwort = socket.readLine()
        if (antwort.startsWith("+OK")):
            var daten = _getUeberweisungsDaten()
            while (daten != "quit"):
                socket.write(daten + "\n")
                var kontostand = socket.readLine()
                var ergebnis = socket.readLine()
                var daten = _getUeberweisungsDaten()
        socket.write("quit\n")
        socket.close()

    // Lebenslinie endet mit × (bereits in Vorlage)

Tabs → Fragment-Tiefe: 1 Tab = innerhalb opt ok · 2 Tabs = innerhalb opt ok + opt antwort · 3 Tabs = innerhalb aller drei Fragmente
Unterstrich = Selbstaufruf (EBClient → EBClient) · close() und write("quit\n") liegen innerhalb von opt ok, aber außerhalb von opt antwort und loop

8.4.3 Aufschlüsselung der Lösung

Selbstaufrufe: getAnmeldeDaten() und getUeberweisungsDaten()

Der EBClient holt seine eigenen Eingaben per Selbstaufruf — getAnmeldeDaten() gibt einen String zurück, der direkt als Argument für write() verwendet wird. Dasselbe Muster für getUeberweisungsDaten().

Dreifach geschachtelte Fragmente

Äußerer opt ok = true-Block (Verbindungserfolg) enthält einen inneren opt antwort = "+OK..."-Block (Login-Erfolg), der wiederum einen loop daten <> "quit"-Block enthält (Überweisungsschleife). Plane beim Zeichnen genug vertikalen Platz ein.

9 · Häufige Fehler