Dokumentation: Zugfahrten-Simulationssystem

Diese Dokumentation erklärt das objektorientierte Zugfahrten-Simulationssystema> für angehende Fachinformatiker für Anwendungsentwicklung (FIAE).

1. Systemübersicht

Das System simuliert verschiedene Zugfahrten mit ihren Komponenten (Triebfahrzeuge, Waggons, Abteile) und Routen (Bahnhöfe). Es demonstriert grundlegende Prinzipien der objektorientierten Programmierung (OOP) in JavaScript.

Hauptfunktionen:

Modellierung verschiedener Zugtypen (Regionalexpress, ICE, S-Bahn, Güterzug)
Darstellung der Zugkomposition (Triebfahrzeuge, Waggons, Abteile)
Visualisierung von Fahrtrouten zwischen Bahnhöfen
Generierung eines Fahrplans mit allen Zugfahrten

2. Klassenmodell

Das System basiert auf einem objektorientierten Klassenmodell mit Vererbung und Komposition.

Klassendiagramm (textuelle Darstellung)

Waggon

+ typ: string

+ constructor(typ: string)

↑ Waggon ist die Basisklasse für:

Personenwagen

- abteile: Abteil[]

+ constructor()

+ abteilHinzufuegen(abteil: Abteil): void

Speisewagen

+ constructor()

Gitterwaggon

+ constructor()

Triebfahrzeug

+ typ: string

+ constructor(typ: string)

↑ Triebfahrzeug ist die Basisklasse für:

DieselLok

+ constructor()

ELok

+ constructor()

Zug

- name: string

- triebfahrzeuge: Triebfahrzeug[]

- steuerwagen: boolean

- waggons: Waggon[]

+ constructor(name: string, triebfahrzeuge: Triebfahrzeug[], steuerwagen: boolean)

+ waggonHinzufuegen(waggon: Waggon): void

Fahrt

- zug: Zug

- bahnhoefe: Bahnhof[]

+ constructor(zug: Zug, bahnhoefe: Bahnhof[])

Fahrplan

- fahrten: Fahrt[]

+ constructor()

+ fahrtHinzufuegen(fahrt: Fahrt): void

+ anzeigen(htmlElement: HTMLElement): void

3. Detaillierte Klassendokumentation

3.1 Bahnhof

Repräsentiert einen Bahnhof mit Namen.

    class Bahnhof {
      constructor(name) {
        this.name = name; // Name des Bahnhofs
      }
    }
  

3.2 Abteil

Repräsentiert ein Abteil in einem Personenwagen.

    class Abteil {
      constructor(nummer) {
        this.nummer = nummer; // Nummer des Abteils
      }
    }
  

3.3 Waggon und spezialisierte Waggons

Basisklasse für alle Waggontypen mit spezialisierten Unterklassen.

    // Basisklasse
    class Waggon {
      constructor(typ) {
        this.typ = typ; // Typ des Waggons
      }
    }
    
    // Personenwagen mit Abteilen
    class Personenwagen extends Waggon {
      constructor() {
        super("Personenwagen");
        this.abteile = []; // Array für Abteile
      }
      
      abteilHinzufuegen(abteil) {
        this.abteile.push(abteil);
      }
    }
    
    // Speisewagen ohne Abteile
    class Speisewagen extends Waggon {
      constructor() {
        super("Speisewagen");
      }
    }
    
    // Gitterwaggon für Güter
    class Gitterwaggon extends Waggon {
      constructor() {
        super("Gitterwaggon");
      }
    }
  

3.4 Triebfahrzeug und spezialisierte Loks

Basisklasse für Triebfahrzeuge mit spezialisierten Unterklassen.

    // Basisklasse
    class Triebfahrzeug {
      constructor(typ) {
        this.typ = typ; // Typ des Triebfahrzeugs
      }
    }
    
    // Diesel-Lokomotive
    class DieselLok extends Triebfahrzeug {
      constructor() {
        super("Diesel-Lok");
      }
    }
    
    // Elektro-Lokomotive
    class ELok extends Triebfahrzeug {
      constructor() {
        super("E-Lok");
      }
    }
  

3.5 Zug

Repräsentiert einen kompletten Zug mit Triebfahrzeugen und Waggons.

    class Zug {
      constructor(name, triebfahrzeuge, steuerwagen) {
        this.name = name; // Zugname/Nummer
        this.triebfahrzeuge = triebfahrzeuge; // Array von Triebfahrzeugen
        this.steuerwagen = steuerwagen; // Hat der Zug einen Steuerwagen?
        this.waggons = []; // Array für Waggons
      }
      
      waggonHinzufuegen(waggon) {
        this.waggons.push(waggon);
      }
    }
  

3.6 Fahrt

Repräsentiert eine Zugfahrt mit Route (mindestens 2 Bahnhöfe).

    class Fahrt {
      constructor(zug, bahnhoefe) {
        if (bahnhoefe.length < 2) {
          throw new Error("Eine Fahrt muss mindestens zwei Bahnhöfe enthalten.");
        }
        this.zug = zug; // Zug-Objekt
        this.bahnhoefe = bahnhoefe; // Array von Bahnhöfen
      }
    }
  

3.7 Fahrplan

Verwaltet eine Sammlung von Fahrten und stellt sie dar.

    class Fahrplan {
      constructor() {
        this.fahrten = []; // Array für Fahrten
      }
      
      fahrtHinzufuegen(fahrt) {
        this.fahrten.push(fahrt);
      }
      
      anzeigen(htmlElement) {
        if (this.fahrten.length === 0) {
          htmlElement.innerHTML = "<p>Keine Fahrten im Fahrplan.</p>";
          return;
        }
        
        this.fahrten.forEach(fahrt => {
          // Erstellt die HTML-Darstellung für jede Fahrt
          // (Details siehe Originalcode)
        });
      }
    }
  

4. Objektbeziehungen

4.1 Vererbung (Generalisierung/Spezialisierung)

Personenwagen, Speisewagen, Gitterwaggon erben von Waggon
DieselLok, ELok erben von Triebfahrzeug

4.2 Komposition (Teil-Ganzes-Beziehungen)

Zug besteht aus:
- 1..n Triebfahrzeugen
- 0..1 Steuerwagen (als boolean-Flag)
- 0..n Waggons
Personenwagen besteht aus:
- 0..n Abteilen
Fahrt besteht aus:
- 1 Zug
- 2..n Bahnhöfen
Fahrplan besteht aus:
- 0..n Fahrten

4.3 Assoziationen

Bahnhof ist assoziiert mit Fahrt über die Route
Abteil ist assoziiert mit Personenwagen
Waggon ist assoziiert mit Zug
Triebfahrzeug ist assoziiert mit Zug

4.4 Abhängigkeiten

Fahrt ist abhängig von Zug und Bahnhof
Fahrplan ist abhängig von Fahrt
Zug ist abhängig von Triebfahrzeug und Waggon
Personenwagen ist abhängig von Abteil

5. Dateninitialisierung

Das System verwendet vordefinierte Zugdaten im JSON-Format:

    const zugdaten = [
      {
        name: "RE1",
        triebfahrzeuge: ["ELok"],
        steuerwagen: true,
        waggons: ["Personenwagen", "Personenwagen", "Personenwagen"],
        abteile: [[1, 2], [3, 4], [5, 6]],
        route: ["Hamm", "Dortmund", "Essen", "Düsseldorf", "Köln", "Aachen"]
      },
      // Weitere Zugdefinitionen...
    ];
  

Initialisierungsprozess:

Erstellung eines neuen Fahrplans
Verarbeitung jeder Zugdefinition:
- Erstellung der Triebfahrzeuge
- Erstellung des Zug-Objekts
- Hinzufügen der Waggons (mit Abteilen bei Personenwagen)
- Erstellung der Bahnhofs-Objekte für die Route
- Erstellung einer Fahrt mit Zug und Route
- Hinzufügen der Fahrt zum Fahrplan
Anzeige des Fahrplans im HTML-DOM

6. OOP-Prinzipien im System

6.1 Kapselung

Jede Klasse kapselt ihre Eigenschaften und Methoden:

Eigenschaften sind direkt in den Objekten gespeichert
Methoden arbeiten auf den internen Daten

6.2 Vererbung

Spezialisierte Klassen erweitern Basisklassen:

Waggon als Basis für Personenwagen, Speisewagen, Gitterwaggon
Triebfahrzeug als Basis für DieselLok und ELok

6.3 Polymorphie

Unterschiedliche Waggontypen werden einheitlich behandelt:

Alle Waggons haben einen typ
Personenwagen haben zusätzlich Abteile

6.4 Komposition

Komplexe Objekte setzen sich aus Teilobjekten zusammen:

Zug besteht aus Triebfahrzeugen und Waggons
Personenwagen bestehen aus Abteilen
Fahrplan besteht aus Fahrten

7. Lernziele für FIAE Umschüler

7.1 Verständnis der OOP-Konzepte

Klassen und Objekte
Vererbung und Polymorphie
Komposition vs. Vererbung
Kapselung und Datenkapselung

7.2 JavaScript-spezifische Konzepte

Klassendefinitionen in ES6
Verwendung von constructor()
super()-Aufruf in abgeleiteten Klassen
Array-Methoden (map, forEach, join)
DOM-Manipulation

7.3 Modellierung realer Systeme

Abbildung realer Objekte auf Klassen
Strukturierung komplexer Systeme
Datenmodellierung mit JSON-ähnlichen Strukturen

Tipp für Umschüler: Experimentieren Sie mit dem Code! Fügen Sie neue Zugtypen hinzu, erweitern Sie die Klassen oder ändern Sie die Darstellung. Praktische Übung ist der beste Weg, OOP zu verstehen.