Analyse und Design objektorientierter Softwaresysteme mit der Unified Modeling Language (UML) - Exam

Aufgabe 1)

Du entwickelst eine neue Softwareanwendung für ein online Buchungssystem. Das Projektteam entschied, UML als Primärwerkzeug für die Modellierung der Systemarchitektur zu verwenden. Im folgenden Abschnitt sollen die verschiedenen Aspekte und Fachgebiete der UML sowie deren Anwendung betrachtet werden.

a)

Erstelle ein Klassendiagramm für das beschriebene Buchungssystem. Das System muss folgende Klassen beinhalten: Benutzer, Buchung, Veranstaltung und Zahlung. Achte dabei auf die richtigen Beziehungen (Assoziationen, Aggregationen, Kompositionen) und die Kardinalitäten.

Lösung:

Um ein UML-Klassendiagramm für das beschriebene Buchungssystem zu erstellen, müssen die folgenden Klassen und deren Beziehungen definiert werden: Benutzer, Buchung, Veranstaltung und Zahlung. Beginnen wir mit der Beschreibung der Klassen und deren Attribute und Methoden, bevor wir zu den Beziehungen übergehen.

• Benutzer:
  • Attribute: BenutzerID, Name, Email
  • Methoden: registrieren(), anmelden(), abmelden()
• Buchung:
  • Attribute: BuchungID, Datum, Status
  • Methoden: erstellen(), stornieren(), anzeigen()
• Veranstaltung:
  • Attribute: VeranstaltungID, Titel, Datum, Ort
  • Methoden: hinzufügen(), aktualisieren(), löschen()
• Zahlung:
  • Attribute: ZahlungID, Betrag, Datum, Zahlungsmethode
  • Methoden: durchführen(), stornieren(), anzeigen()

Im nächsten Schritt definieren wir die Beziehungen zwischen diesen Klassen:

• Benutzer ⟶ Buchung: Eine Assoziation, da ein Benutzer eine oder mehrere Buchungen haben kann. Kardinalität: 1 (Benutzer) zu 0..* (Buchungen).
• Buchung ⟶ Veranstaltung: Eine Assoziation, da eine Buchung sich auf eine bestimmte Veranstaltung bezieht. Kardinalität: 1 (Buchung) zu 1 (Veranstaltung).
• Buchung ⟶ Zahlung: Eine Komposition, da eine Buchung ohne Zahlung nicht existiert. Eine Buchung hat genau eine zugehörige Zahlung. Kardinalität: 1 (Buchung) zu 1 (Zahlung).
• Veranstaltung: Keine spezifischen Beziehungen zu anderen Klassen in diesem Kontext notwendig.

Das resultierende UML-Klassendiagramm sieht vereinfacht folgendermaßen aus:

' 
Klassendiagramm:
+----------------+              +----------------+              +---------------+              +--------------+|    Benutzer    |              |    Buchung     |              | Veranstaltung |              |   Zahlung   |+----------------+              +----------------+              +---------------+              +--------------+| - BenutzerID   |   0..*  <--- | - BuchungID    | 1--+                 | - VeranstaltungID |              | - ZahlungID  || - Name         |              | - Datum        |              | - Titel        |              | - Betrag      || - Email        |              | - Status       |              | - Datum        |              | - Datum       |+----------------+              +----------------+              +---------------+              +--------------+| registrieren() |              | erstellen()    |              | hinzufügen()   |              | durchführen() || anmelden()     |              | stornieren()   |              | aktualisieren()|              | stornieren()  || abmelden()     |              | anzeigen()     |              | löschen()      |              | anzeigen()    |+----------------+              +----------------+              +---------------+              +--------------+' 

b)

Erstellt ein Use-Case-Diagramm, welches die Interaktionen zwischen einem Benutzer und dem System für folgendes Szenario darstellt: Ein Benutzer meldet sich im System an, sucht nach einer Veranstaltung, bucht die Veranstaltung und führt die Zahlung aus. Identifiziere die Akteure und die Haupt-Use-Cases.

Lösung:

Um ein Use-Case-Diagramm für das beschriebene Szenario zu erstellen, müssen wir die Akteure und Haupt-Use-Cases identifizieren. Das Szenario umfasst folgende Schritte:

• Ein Benutzer meldet sich im System an.
• Ein Benutzer sucht nach einer Veranstaltung.
• Ein Benutzer bucht die Veranstaltung.
• Ein Benutzer führt die Zahlung aus.

Akteure:

• Benutzer: Der Hauptakteur, der mit dem System interagiert.

Haupt-Use-Cases:

• Anmelden: Der Benutzer meldet sich im System an, um Zugang zu den Funktionen zu erhalten.
• Veranstaltung suchen: Der Benutzer sucht nach einer Veranstaltung im System.
• Veranstaltung buchen: Der Benutzer bucht eine ausgewählte Veranstaltung.
• Zahlung durchführen: Der Benutzer führt die Zahlung für die gebuchte Veranstaltung durch.

Hier ist das Use-Case-Diagramm:

' 
Use-Case-Diagramm:
+--------------------+                                                                                                                  +--------------------+|       Benutzer       |                                                                                                                  |                        |+--------------------+                                                                                                                  +--------------------+┌──────────┐                           ┤────────────────────────────────────────┏        ┤────────────────────────────────────────┏+--------------------+                                                                                                                  |                       |        |                       +--------------------+                 ├──Anmelden──────────────────────────────────┐                           |                        |   |        |                        +--------------------+                 |                |                |                       |                                                                                   |  Veranstaltung suchen                           |                       |        |                                                                                                                                                                 |                       |+--------------------+        |                                                                                                                                                                 +--------------------+   |                                                                                                                                                                                                                                                                                           |                            |                                                                                                                                                                 |                       |   |                        +--------------------+                 |              ├─Veranstaltung buchen─────────────────────────────────┐                           |                       |+--------------------+        |nun                       |                                                                                                                |                       |      |                           +--------------------+                 ├─Zahlung durchführen─────────────────────────────────┏+--------------------+   |                                                                                                                                                                                                |                       |        ╙┏┐        +--------------------+                 |                                                                                       |                       |   \                                                                                                                                                             |                       |   ㅎㅎ   ╙┐┪        +--------------------+                 |                                                                                       |                       |lol                                                                                                                                                            |                       |                                                  ' 

c)

Zeichne ein Sequenzdiagramm für den Anmeldeprozess im Buchungssystem. Der Prozess soll die Interaktionen zwischen den Objekten Benutzer, Anmeldungssystem und Datenbank enthalten. Zeige, wie Nachrichten zwischen diesen Objekten ausgetauscht werden, um den Anmeldeprozess durchzuführen.

Lösung:

Um ein Sequenzdiagramm für den Anmeldeprozess im Buchungssystem zu erstellen, müssen wir die Interaktionen zwischen den Objekten Benutzer, Anmeldungssystem und Datenbank darstellen. Der Anmeldeprozess umfasst die folgenden Schritte:

1. Der Benutzer gibt seine Anmeldeinformationen ein und sendet eine Anmeldeanforderung an das Anmeldungssystem.
2. Das Anmeldungssystem übermittelt die Anmeldeinformationen an die Datenbank zur Überprüfung.
3. Die Datenbank überprüft die Anmeldeinformationen und gibt das Ergebnis (erfolgreich oder fehlgeschlagen) an das Anmeldungssystem zurück.
4. Das Anmeldungssystem informiert den Benutzer über das Ergebnis der Anmeldung.

Das Sequenzdiagramm zeigt diese Interaktionen und die Nachrichten, die zwischen den beteiligten Objekten ausgetauscht werden:

'
Sequenzdiagramm:
+----------------------++---------------++-------------------+|        Benutzer      |                           |  Anmeldungssystem   |                           |      Datenbank       ||                       |                           |                      |                           |                     ||----------------------|                           |----------------------|                           |---------------------||                       |                           |                      |                           ||     Anmeldedaten      |                           |                      |                           ||        eingeben       +-------------------->       |                      |                           ||                       |                           |  Anmeldedaten        |                           ||                       |                           | weiterleiten   +-------------------->   ||                       |                           |                      |                     Anmeldedaten       ||                       |                           |                      |        überprüfen       ||                       |                           |                      |            +<------------------+          ||                       |                           |                      |                           ||                       |                           |       Ergebnis       |                           ||                       |                           | zurückgeben  +<--------------------   ||                       |                           |                      |                           ||                       |       Ergebnis            |                      |                           ||                       |<--------------------+ anzeigen         ||                       |                           ||                       |                           ||                       |                           ||----------------------|                           |----------------------|                           |                     |+----------------------+                           +----------------------+                           +---------------------+'

Dieses Sequenzdiagramm visualisiert den Ablauf des Anmeldeprozesses:

• Der Benutzer gibt seine Anmeldeinformationen ein und sendet diese an das Anmeldungssystem.
• Das Anmeldungssystem leitet die Anmeldeinformationen an die Datenbank weiter.
• Die Datenbank überprüft die Anmeldeinformationen und sendet das Ergebnis an das Anmeldungssystem zurück.
• Das Anmeldungssystem zeigt das Ergebnis der Anmeldung dem Benutzer an.

d)

Das Projektteam hat sich entschieden, das UML-Aktivitätsdiagramm zu verwenden, um den Ablauf der Zahlung darzustellen. Zeichne ein Aktivitätsdiagramm, das die Schritte eines Benutzers vom Ausfüllen der Zahlungsinformationen bis zur Bestätigung der Zahlung abbildet.

Lösung:

Ein Aktivitätsdiagramm hilft dabei, den Ablauf eines Prozesses in einem System zu visualisieren. In diesem Fall erstellen wir ein Aktivitätsdiagramm, das die Schritte eines Benutzers vom Ausfüllen der Zahlungsinformationen bis zur Bestätigung der Zahlung im online Buchungssystem darstellt.

Hier sind die Schritte dieses Ablaufs:

• Benutzer gibt Zahlungsinformationen ein.
• Zahlungsinformationen werden validiert.
• Falls die Validierung fehlschlägt, wird eine Fehlermeldung angezeigt und der Benutzer gibt die Zahlungsinformationen erneut ein.
• Falls die Validierung erfolgreich ist, wird die Zahlung verarbeitet.
• Falls die Zahlung fehlschlägt, wird dem Benutzer eine Fehlermeldung angezeigt und der Prozess kehrt zur Eingabe der Zahlungsinformationen zurück.
• Falls die Zahlung erfolgreich ist, wird die Zahlung bestätigt und dem Benutzer eine Bestätigung angezeigt.

Hier ist das Aktivitätsdiagramm zu diesem Ablauf:

'
Aktivitätsdiagramm:
[Eingabe Zahlungsinformationen] --> {validate payment info}{validate payment info} --> [Validieren erfolgreich] --> {process payment}{validate payment info} --> [Validieren fehlgeschlagen] --> [Fehlermeldung anzeigen] --> [Eingabe Zahlungsinformationen]{process payment} --> [Zahlung erfolgreich] --> [Zahlung bestätigen] --> [Bestätigung anzeigen]{process payment} --> [Zahlung fehlgeschlagen] --> [Fehlermeldung anzeigen] --> [Eingabe Zahlungsinformationen]

Dieses Aktivitätsdiagramm verdeutlicht den Prozess eines Benutzers, der Zahlungsinformationen eingibt und wie das System diese verarbeitet:

• Der Benutzer gibt die Zahlungsinformationen ein.
• Diese Informationen werden validiert.
• Falls die Validierung fehlschlägt, wird eine Fehlermeldung angezeigt und der Benutzer hat die Möglichkeit, die Informationen erneut einzugeben.
• Falls die Validierung erfolgreich ist, wird die Zahlung verarbeitet.
• Falls die Zahlung fehlschlägt, wird eine Fehlermeldung angezeigt und der Benutzer kann erneut Zahlungsinformationen eingeben.
• Falls die Zahlung erfolgreich ist, wird die Zahlung bestätigt und eine Bestätigung wird dem Benutzer angezeigt.

Aufgabe 2)

Ein Softwareentwicklungsunternehmen möchte ein Bibliothekssystem entwerfen und implementieren, das die Verwaltung von Büchern, Benutzern und Ausleihen ermöglicht. Das System soll die grundlegenden Konzepte der objektorientierten Modellierung anwenden, wie Abstraktion, Kapselung, Modularität, Hierarchie, Komposition, Generalisierung und Spezialisierung sowie Assoziation. Dabei sollen verschiedene UML-Diagramme zur Darstellung des Systemdesigns eingesetzt werden.

a)

Erstelle ein Klassendiagramm, das die folgenden Anforderungen abdeckt. Das System soll folgende Klassen beinhalten:

• Buch: Attribute sind Titel, Autor, ISBN und Verfügbarkeit.
• Benutzer: Attribute sind Benutzer-ID, Name und Adresse.
• Ausleihe: Attribute sind Ausleih-ID, Ausleihdatum und Rückgabedatum. Diese Klasse soll Assoziationen zu den Klassen Buch und Benutzer haben.

Lösung:

Bibliothekssystem Klassendiagramm

Um die Anforderungen des Bibliothekssystems zu erfüllen und die Prinzipien der objektorientierten Modellierung anzuwenden, werden wir ein Klassendiagramm erstellen, das die Klassen Buch, Benutzer und Ausleihe umfasst. Wir berücksichtigen dabei Abstraktion, Kapselung, sowie Assoziationen zwischen den Klassen.

1. Klassendiagramm

Das Klassendiagramm zeigt die Klassen und ihre Beziehungen in einem UML-Diagramm. Hier sind die Details:

• Buch
  • Attribute:
    • Titel: String
    • Autor: String
    • ISBN: String
    • Verfügbarkeit: Boolean
• Benutzer
  • Attribute:
    • Benutzer-ID: String
    • Name: String
    • Adresse: String
• Ausleihe
  • Attribute:
    • Ausleih-ID: String
    • Ausleihdatum: Date
    • Rückgabedatum: Date
  • Assoziationen:
    • Ein Ausleihe ist mit genau einem Buch assoziiert (1:1 Beziehung)
    • Ein Ausleihe ist mit genau einem Benutzer assoziiert (1:1 Beziehung)

2. UML-Klassendiagramm

   +-----------------+    +----------------+      +--------------------+   |      Buch       |    |    Benutzer    |      |      Ausleihe      |   +-----------------+    +----------------+      +--------------------+   | - Titel: String |    | - Benutzer-ID  |      | - Ausleih-ID: String|   | - Autor: String |    | - Name: String |      | - Ausleihdatum: Date|   | - ISBN: String  |    | - Adresse: String|     | - Rückgabedatum: Date|   | - Verfügbar: Boolean| + ----------------|    +--------------------+   +-----------------+*/      |                     1                                                        1 | |               +---------------------------------------+               |               |              Nutzer   +-----------------+    +-----------------+ 

In diesem UML-Klassendiagramm sehen wir die Beziehungen zwischen den Klassen Buch, Benutzer und Ausleihe.

Bücher und Benutzer haben jeweils eine 1:1 Assoziation zu Ausleihe, was bedeutet, dass jede Ausleihe genau ein Buch und einen Benutzer hat.

3. Kapselung und Abstraktion

• Kapselung: Jedes Attribut in den Klassen ist als privat (-) markiert, um die Datenkapselung zu gewährleisten. Dieser Ansatz stellt sicher, dass nur Methoden innerhalb der Klasse Zugriff auf diese Attribute haben.
• Abstraktion: Die Klassen abstrahieren die Konzepte eines Buches, eines Benutzers und einer Ausleihe, indem sie nur relevante Eigenschaften und Beziehungen beibehalten und unnötige Details ausblenden.

Mit diesem Klassendiagramm sind die grundlegenden Komponenten und ihre Beziehungen im Bibliothekssystem definiert. Es stellt die Basis für die Implementierung eines robusten und gut strukturierten Systems dar.

b)

Welcher dieser Konzepte (Abstraktion, Kapselung, Modularität, Hierarchie, Komposition, Generalisierung, Spezialisierung und Assoziation) sind im erstellten Klassendiagramm zu erkennen? Erkläre detailliert, wo und wie diese Konzepte im Diagramm verwendet wurden.

Lösung:

Analyse des Klassendiagramms: Konzepte der Objektorientierung

Im erstellten Klassendiagramm für das Bibliothekssystem sind mehrere grundlegende Konzepte der objektorientierten Modellierung erkennbar. Hier ist eine detaillierte Erklärung, wie und wo diese Konzepte angewendet wurden:

• Abstraktion: Das Diagramm abstrahiert die realen Objekte der Bibliotheksverwaltung in Klassen wie Buch, Benutzer und Ausleihe. Jede dieser Klassen enthält nur die relevanten Attribute, die notwendig sind, um deren Eigenschaften im Kontext der Bibliothek darzustellen.
• Kapselung: Die Attribute der Klassen sind privat (dies wird durch das Minuszeichen vor den Attributnamen angedeutet). Durch die Kapselung wird sichergestellt, dass der direkte Zugriff auf die internen Daten der Klassen auf definierte Methoden beschränkt ist, was zu einer höheren Sicherheit und Datenintegrität führt.
• Modularität: Die Trennung der Funktionalität in verschiedene Klassen zeigt einen modularen Ansatz. Jede Klasse kümmert sich um eine spezifische Aufgabe (z.B. die Klasse Buch verwaltet Informationen über Bücher, die Klasse Benutzer verwaltet Benutzerdaten, usw.). Dies unterstützt die Wartbarkeit und Erweiterbarkeit des Systems.
• Komposition: Während es im aktuellen Diagramm nicht explizit dargestellt ist, könnte eine Komposition verwendet werden, wenn beispielsweise ein Buch Teil einer Ausleihe ist. Wenn die Ausleihe beendet wird, kann das Buch wieder verfügbar gemacht werden. Eine Komposition würde eine starke Lebensdauerabhängigkeit zwischen den beteiligten Klassen darstellen.
• Assoziation: Es gibt klar definierte Assoziationen zwischen den Klassen Ausleihe, Buch und Benutzer. Jede Ausleihe ist mit genau einem Buch und genau einem Benutzer assoziiert, dies wird durch die 1:1 Beziehungen angezeigt.
• Generalisierung und Spezialisierung: Diese Konzepte sind im aktuellen Klassendiagramm nicht dargestellt. Generalisierung und Spezialisierung würden Vererbungsbeziehungen zwischen Klassen beinhalten, die in unserem aktuellen Modell nicht benötigt wurden.
• Hierarchie: Im vorliegenden Diagramm gibt es keine offensichtliche hierarchische Struktur (wie sie durch Vererbungsbeziehungen dargestellt würde). Sollte das System jedoch erweitert werden, könnten Hierarchien eingeführt werden, um spezialisierte Unterklassen von Buch (z.B. Ebook und Kinderbuch) oder Benutzer (z.B. Studierende und Dozenten) zu erstellen.

Diese Konzepte helfen insgesamt, das System robust, wartbar und erweiterbar zu gestalten. Eine klare Anwendung dieser Prinzipien ist entscheidend für den Erfolg eines objektorientierten Designs.

c)

Gegeben sei ein Szenario, in dem es verschiedene Benutzerarten gibt, wie Studenten und Professoren, die unterschiedliche Ausleihbedingungen haben.

• Erweitere das Klassendiagramm, um die Klassen Student und Professor einzuführen und zu spezifizieren. Diese sollen eine Spezialisierung der Klasse Benutzer darstellen.
• Zeige dabei die Generalisierungs- und Spezialisierungsbeziehungen auf.

Lösung:

Erweitertes Klassendiagramm: Benutzerarten in einem Bibliothekssystem

Um die verschiedenen Benutzerarten wie Studenten und Professoren zu berücksichtigen, erweitern wir das bestehende Klassendiagramm durch Einführung der Klassen Student und Professor als Spezialisierungen der Klasse Benutzer.

1. Klassendiagramm-Erweiterung

• Benutzer
  • Attribute:
    • Benutzer-ID: String
    • Name: String
    • Adresse: String
• Student (spezialisiert sich auf Benutzer)
  • Attribute:
    • Studiengang: String
• Professor (spezialisiert sich auf Benutzer)
  • Attribute:
    • Fachgebiet: String

2. UML-Klassendiagramm

    +----------------+    |   Benutzer     |    +----------------+    | - Benutzer-ID  |    | - Name: String |    | - Adresse: String |    +----------------+         /  \            /    \  ______/______\______ /                        \ + ---------------- + + ----------------+ |    Student      | |    Professor    | + ---------------- + + ----------------+ | - Studiengang: String | - Fachgebiet: String | + ----------------+   + -----------------+

Hier sehen wir die Generalisierungs- und Spezialisierungsbeziehungen:

• Generalisierung: Die Klasse Benutzer ist die allgemeine Klasse, die alle gemeinsamen Attribute wie Benutzer-ID, Name und Adresse enthält.
• Spezialisierung: Die Klassen Student und Professor sind spezialisierte Unterklassen von Benutzer und fügen zusätzliche Attribute hinzu, die spezifisch für jede Benutzerart sind (Studiengang für Studenten, Fachgebiet für Professoren).

3. Verbesserte Modularität und Hierarchie

Die erweiterte Struktur des Klassendiagramms verbessert die Modularität und Hierarchie im System folgendermaßen:

• Modularität: Durch die Einführung spezialisierter Klassen werden spezifische Benutzerarten in separate Module organisiert. Damit wird der Code übersichtlicher und leichter wartbar, da Änderungen an einer bestimmten Benutzerart (z.B. Studenten) keine Auswirkungen auf andere Benutzerarten oder die allgemeine Klasse haben.
• Hierarchie: Die Hierarchie im System wird klarer, da die Vererbungsbeziehungen anzeigen, wie spezifische Klassen von allgemeinen Klassen abgeleitet werden. Dies ermöglicht eine einfachere Erweiterung des Systems, indem weitere spezialisierte Benutzerarten hinzufügt werden können, ohne das bestehende System grundlegend zu verändern.

Weitere wichtige objektorientierte Konzepte

Zusätzlich zu den bereits diskutierten Konzepten werden durch dieses Design auch folgende objektorientierte Prinzipien verstärkt:

• Polymorphie: Polymorphie ermöglicht es, dass Instanzen der Unterklassen Student und Professor als Instanzen der super Typenklasse Benutzer behandelt werden können. Dies erlaubt flexiblen und wiederverwendbaren Code, der mit verschiedenen Benutzerarten umgehen kann.
• Komposition: Obwohl es derzeit keine explizite Kompositionsbeziehung gibt, könnte dies leicht eingeführt werden, um zusätzliche Zusammensetzungen innerhalb des Systems zu modellieren (z.B. eine Klasse, die aus mehreren Studenten besteht).

Insgesamt führt dieses erweiterte Design zu einem robusteren, klarer strukturierten und erweiterbaren Bibliothekssystem.

Aufgabe 3)

Angenommen, Du entwirfst ein Softwaresystem für eine Bibliotheksverwaltung. In diesem System sollen Benutzer Bücher ausleihen, zurückgeben und den Katalog durchsuchen können. Es gibt Bibliothekare, die Bücher hinzufügen und entfernen können. Neben den Standardnutzerfunktionen und Bibliothekarfunktionen gibt es auch ein Verwaltungssystem, das Statistiken über die ausgeliehenen Bücher und die Benutzeraktivität sammelt.

a)

(a) Erstelle ein vollständiges Anwendungsfalldiagramm, das die wichtigsten Anwendungsfälle des Bibliothekssystems zeigt. Dazu gehören Benutzer (Member, Bibliothekar) und deren Interaktionen mit dem System. Beschreibe alle wesentlichen Anwendungsfälle.

Lösung:

• Die Erstellung eines Anwendungsfalldiagramms erfordert das Erkennen und Beschreiben der verschiedenen Akteure (Actor) und deren Anwendungsfälle (Use Cases). Für das Bibliothekssystem identifizieren wir zwei Hauptakteure: den Benutzer (Member) und den Bibliothekar.
• Akteure:
• Benutzer (Member): Ein registrierter Benutzer, der Bücher ausleihen und zurückgeben kann. Er kann auch den Katalog durchsuchen.
• Bibliothekar: Ein Bibliothekar ist ein Benutzer mit erweiterten Rechten. Er kann Bücher hinzufügen, entfernen und hat Zugriff auf das Verwaltungssystem.
• Anwendungsfälle für Benutzer (Member):
• Bücher ausleihen: Der Benutzer kann ein Buch aus dem Bestand der Bibliothek ausleihen.
• Bücher zurückgeben: Der Benutzer kann ein zuvor ausgeliehenes Buch zurückgeben.
• Katalog durchsuchen: Der Benutzer kann nach Bücher im Katalog suchen, um zu prüfen, welche Bücher verfügbar sind.
• Anwendungsfälle für Bibliothekar:
• Bücher hinzufügen: Der Bibliothekar kann neue Bücher in den Bestand der Bibliothek aufnehmen.
• Bücher entfernen: Der Bibliothekar kann Bücher aus dem Bestand entfernen.
• Verwaltungssystem nutzen: Der Bibliothekar kann auf das Verwaltungssystem zugreifen, um Statistiken über die ausgeliehenen Bücher und Benutzeraktivitäten einzusehen.
• Anwendungsfall-Diagramm:
• Um das Anwendungsfall-Diagramm korrekt darzustellen, definiere die Beziehungen zwischen den Akteuren und den Anwendungsfällen:
• Der Benutzer (Member) interagiert mit den Anwendungsfällen: „Bücher ausleihen“, „Bücher zurückgeben“, „Katalog durchsuchen“.
• Der Bibliothekar interagiert zusätzlich mit den Anwendungsfällen: „Bücher hinzufügen“, „Bücher entfernen“, „Verwaltungssystem nutzen“.
• Hier ist eine textuelle Darstellung des Anwendungsfall-Diagramms:

 User (Member)  ----|                                    |----------------> Bücher ausleihen                   |                                    |----------------> Bücher zurückgeben                   |                                    |----------------> Katalog durchsuchen                   |                       Librarian (Bibliothekar) ----|                                    |----------------> Bücher hinzufügen                   |                                    |----------------> Bücher entfernen                   |                                    |----------------> Verwaltungssystem nutzen 

b)

(b) Erstelle ein Klassendiagramm, das die Hauptklassen und deren Beziehungen im Bibliotheksverwaltungssystem darstellt. Achte darauf, die Klassen 'Benutzer', 'Buch', 'Bibliothekar' und 'Verwaltung' sowie entsprechende Attribute und Methoden zu integrieren. Gehe dabei detailliert auf die Accessoren, Mutatoren und spezifische Bibliotheksfunktionen ein.

Lösung:

Ein Klassendiagramm gibt Dir eine visuelle Darstellung der Hauptklassen und deren Beziehungen im System. Es zeigt auch die Attribute und Methoden jeder Klasse. Hier sind die Hauptklassen und die Beziehungen für das Bibliotheksverwaltungssystem:

• Klassen:
• Benutzer (User): Repräsentiert einen allgemeinen Benutzer des Systems.
• Buch (Book): Repräsentiert ein Buch in der Bibliothek.
• Bibliothekar (Librarian): Eine spezielle Art von Benutzer, der zusätzliche Privilegien hat.
• Verwaltung (Management): Eine Klasse, die Funktionen zur Erhebung von Statistiken über Bücher und Benutzeraktivitäten bereitstellt.
• Hier ist eine detaillierte Beschreibung der Klassen mit ihren Attributen und Methoden:
• Klasse Benutzer (User):

 Klasse User {   - id: int   - name: String   - borrowedBooks: List   + getId(): int   + getName(): String   + setName(name: String): void   + borrowBook(book: Book): void   + returnBook(book: Book): void   + searchCatalog(keyword: String): List } 

 Klasse Book {   - id: int   - title: String   - author: String   - isAvailable: boolean   + getId(): int   + getTitle(): String   + getAuthor(): String   + isAvailable(): boolean   + setAvailable(status: boolean): void } 

 Klasse Librarian extends User {   + addBook(book: Book): void   + removeBook(book: Book): void   + accessManagement(): Management } 

 Klasse Management {   + generateLoanStatistics(): Map   + generateUserActivityReport(): Map } 

• Ein Benutzer kann mehrere Bücher ausleihen.
• Ein Bibliothekar ist eine spezielle Art von Benutzer, der zusätzliche Methoden hat.
• Die Verwaltung sammelt Daten über alle Benutzer und Bücher.

                |------------|                |   User      |                |------------|                | - id: int    |                | - name: String |                | - borrowedBooks: List |                |------------|                | + getId(): int               |                | + getName(): String           |                | + setName(name: String): void |                | + borrowBook(book: Book): void |                | + returnBook(book: Book): void |                | + searchCatalog(keyword: String): List |                |------------|                       |                     ^                |                     |                | inherits from                |                     |              |----------|              | Librarian |              |----------|              | + addBook(book: Book): void |              | + removeBook(book: Book): void |              | + accessManagement(): Management |              |----------|                         |                      |                     |                      | knows              |---------|              | Book    |              |---------|              | - id: int |              | - title: String |              | - author: String |              | - isAvailable: boolean |              |---------|              | + getId(): int   |              | + getTitle(): String |              | + getAuthor(): String |              | + isAvailable(): boolean |              | + setAvailable(status: boolean): void |              |---------|                         |                      |                      |                         |                    <-- management statistics of users and books                          |________|              Management               |________|               | + generateLoanStatistics(): Map |               | + generateUserActivityReport(): Map |               |________| 

Aufgabe 4)

Angenommen, Du arbeitest an einem Softwareprojekt für eine Bibliotheksverwaltung. Die Klassen in Deinem System umfassen Bibliothek, Buch, Autor und Leser. Beziehungen zwischen diesen Klassen sollen durch Assoziationen, Vererbungen und Aggregationen in einem Klassendiagramm dargestellt werden.

• Die Bibliothek enthält eine Vielzahl von Büchern und Lesern.
• Ein Buch hat einen oder mehrere Autoren und viele Leser können ein Buch ausleihen.
• Die Klasse Autor enthält spezialisierte Unterklassen wie Fachautor und Romanautor.
• Die Klasse Leser ist mit den ausgeliehenen Büchern verbunden.

a)

Erstelle ein UML-Klassendiagramm, das die beschriebenen Klassen (Bibliothek, Buch, Autor, Leser) und deren Beziehungen (Assoziationen, Vererbungen, Aggregationen) zeigt. Achte darauf, die korrekten Symbole zu verwenden und benenne alle relevanten Assoziationen und Multiplikationen (z.B. 1..* für eine 1-viele-Beziehung).

Lösung:

UML-Klassendiagramm für die Bibliotheksverwaltung

Das UML-Klassendiagramm für das beschriebene Szenario würde die Klassen Bibliothek, Buch, Autor und Leser sowie deren Beziehungen zeigen. Hier ist eine Beschreibung der Klassen und Beziehungen, die im Diagramm dargestellt werden sollten:

• Bibliothek: Eine Klasse, die eine Vielzahl von Büchern und Lesern enthält.
• Buch: Eine Klasse, die einen oder mehrere Autoren hat und von vielen Lesern ausgeliehen werden kann.
• Autor: Eine Klasse mit spezialisierten Unterklassen wie Fachautor und Romanautor.
• Leser: Eine Klasse, die mit ausgeliehenen Büchern verbunden ist.

Hier ist eine textuelle Beschreibung des Klassendiagramms:

• Bibliothek
  • 1..1 Beziehungen zur Klasse Buch (Aggregation)
  • 1..1 Beziehungen zur Klasse Leser (Aggregation)
• Buch
  • 0..* Beziehungen zur Klasse Autor (Assoziation)
  • 0..* Beziehungen zur Klasse Leser (Assoziation)
• Autor (abstrakte Klasse)
  • 0..* Beziehungen zur Klasse Buch (Assoziation)
  • Spezialisierte Unterklassen:
    • Fachautor
    • Romanautor
• Leser
  • 0..* Beziehungen zur Klasse Buch (Assoziation)

Das resultierende UML-Klassendiagramm sollte wie folgt aussehen:

In einem UML-Tool oder einer Handskizze würdest Du die Klassen Boxen darstellen und die Beziehungen mit Linien und korrekten Symbolen verbinden:

• Aggregation: Eine Linie mit einer offenen Raute an der Seite der aggregierten Klasse.
• Assoziation: Eine einfache Linie mit Multiplikationen (z.B., 1..*).
• Vererbung: Eine Linie mit einer geschlossenen Pfeilspitze, die zum übergeordneten Element zeigt.

b)

Erläutere für jede der im Diagramm dargestellten Beziehungen (Assoziation, Vererbung, Aggregation), warum diese Beziehungstypen in diesem Fall angemessen und notwendig sind. Nenne dabei konkrete Gründe, die zu Deiner Entscheidung geführt haben.

Lösung:

Darstellung und Begründung der Beziehungstypen im Klassendiagramm

In Deinem Softwareprojekt für eine Bibliotheksverwaltung werden die Klassen Bibliothek, Buch, Autor und Leser verwendet, und es ist wichtig, die Beziehungen zwischen diesen Klassen gemäß den Anweisungen darzustellen. Hier sind die Beziehungstypen (Assoziation, Vererbung, Aggregation) und die Gründe für ihre Angemessenheit und Notwendigkeit in diesem Kontext:

1. Assoziation

• Buch - Autor:

  Die Beziehung zwischen Buch und Autor ist eine Assoziation, weil ein Buch von einem oder mehreren Autoren geschrieben wird, aber ein Autor kann auch mehrere Bücher schreiben. Durch die Assoziation kann diese 1-zu-n Beziehung effektiv dargestellt werden. Diese Beziehung ist notwendig, um die Autorenschaft eines Buches und die Werke eines Autors zu verwalten.

• Buch - Leser:

  Die Beziehung zwischen Buch und Leser ist eine Assoziation, weil viele Leser ein und dasselbe Buch lesen können, und ein einzelner Leser kann auch mehrere Bücher lesen. Diese Beziehung ermöglicht es, die aktuelle Ausleihsituation zu verwalten, indem festgehalten wird, welche Leser welche Bücher ausgeliehen haben.

• Leser - Buch:

  Der Leser hat ebenfalls eine Assoziation zu Büchern, um die von ihm ausgeliehenen Bücher zu verwalten. Dies stellt sicher, dass für jeden Leser festgehalten wird, welche Bücher er zu einem bestimmten Zeitpunkt ausgeliehen hat.

2. Vererbung

• Autor - Fachautor / Romanautor:

  Die Beziehung zwischen Autor und seinen spezialisierten Unterklassen (Fachautor und Romanautor) ist eine Vererbung, weil dies eine Hierarchie darstellt, bei dem der Autor eine allgemeine Klasse ist und Fachautor sowie Romanautor spezialisierte Klassen sind, die zusätzliche Attribute oder Methoden haben können. Durch die Vererbung wird die Wiederherstellung von gemeinsam genutzten Eigenschaften und Methoden von Autoren in spezialisierte Autoren vermieden und ermöglicht eine flexible und wartbare Struktur.

3. Aggregation

• Bibliothek - Buch:

  Die Beziehung zwischen Bibliothek und Buch ist eine Aggregation, weil eine Bibliothek eine Sammlung von Büchern enthält, aber ein Buch kann unabhängig von einer einzelnen Bibliothek existieren. Diese Aggregation unterstreicht, dass Bücher zur Bibliothek dazugehören, aber die Lebenszyklen von Büchern und Bibliothek nicht notwendigerweise voneinander abhängen.

• Bibliothek - Leser:

  Ebenso, die Beziehung zwischen Bibliothek und Leser ist eine Aggregation, denn eine Bibliothek hat viele Leser, aber Leser können unabhängig von der Bibliothek existieren. Diese Beziehung ist notwendig, um die Leser einer bestimmten Bibliothek zu verwalten, ohne dass sie unbedingt für das Überleben der Bibliothek von Bedeutung sind.

Zusammenfassend sind die gewählten Beziehungstypen (Assoziation, Vererbung, Aggregation) angemessen, weil sie die tatsächlichen Beziehungen und Interaktionen zwischen den Klassen korrekt und effektiv darstellen. Diese Beziehungen erleichtern die Verwaltung und Strukturierung der Bibliothek sowie der Beteiligten und ermöglichen eine flexible und wartbare Softwarearchitektur.

c)

Ergänze das Klassendiagramm um eine Methode in der Bibliotheksklasse, die die Anzahl der von einem bestimmten Leser ausgeliehenen Bücher zurückgibt. Definiere diese Methode in pseudocode oder einer Programmiersprache Deiner Wahl und beschreibe, wie sie die Beziehungen im Klassendiagramm nutzt.

Lösung:

Ergänzung des Klassendiagramms und Implementierung einer Methode in der Klasse Bibliothek

Um das UML-Klassendiagramm um eine Methode zu ergänzen, die die Anzahl der von einem bestimmten Leser ausgeliehenen Bücher zurückgibt, fügen wir eine Methode getAusgelieheneBuecher(l: Leser) zur Klasse Bibliothek hinzu.

Hier ist eine mögliche Definition in Pseudocode:

class Bibliothek {    List buecher;    List leser;    // Methode, die die Anzahl der ausgeliehenen Bücher eines bestimmten Lesers zurückgibt    int getAusgelieheneBuecher(Leser l) {        int anzahl = 0;        for (Buch buch : buecher) {            if (buch.ausgeliehenVon.contains(l)) {                anzahl++;            }        }        return anzahl;    }}class Buch {    List ausgeliehenVon;}class Leser {}

Und nun eine Beschreibung, wie diese Methode die Beziehungen im Klassendiagramm nutzt:

Methode: getAusgelieheneBuecher(Leser l)

• Klassen und Beziehungen: Diese Methode nutzt die Assoziation zwischen der Klasse Bibliothek und ihren Büchern sowie zwischen den Büchern und den Lesern. In der Klasse Bibliothek gibt es eine Liste von Büchern. Jedes Buch hat eine Liste von Lesern, die das Buch ausgeliehen haben.
• Schrittweises Vorgehen: Die Methode iteriert durch alle Bücher in der Bibliothek und überprüft, ob das übergebene Leser-Objekt in der Liste der Leser enthalten ist, die das Buch ausgeliehen haben. Falls ja, wird die Zählvariable anzahl erhöht. Am Ende wird die Anzahl der von dem bestimmten Leser ausgeliehenen Bücher zurückgegeben.

Durch diese Methode wird die Beziehung zwischen Bibliothek, Buch und Leser genutzt und verdeutlicht, wie Objekte in der Bibliothek miteinander interagieren. Die Bibliothek enthält die Bücher und weiß, welche Leser welche Bücher ausgeliehen haben, was es ermöglicht, die Anzahl der ausgeliehenen Bücher eines bestimmten Lesers zu berechnen.