Added Comments and JavaDoc

src/main/java/musterklausur/Gefaess.java

@@ -3,73 +3,98 @@
 import java.text.NumberFormat;
 
 /**
- * stellt ein Gefäß für den Verkauf dar
+ * Die abstrakte Klasse Gefaess stellt ein Gefäß für den Verkauf dar.
+ * Sie enthält den Preis pro cm³ des Inhalts des Gefäßes und Methoden
+ * zum Abrufen des Namens, Vergleichen, Berechnen des Preises und
+ * Berechnen des Volumens. Konkrete Unterklassen müssen die abstrakte
+ * Methode getVolumen implementieren, um das Volumen des Gefäßes zu
+ * berechnen. Die Klasse dient als Basisklasse für die konkreten
+ * Gefäßtypen Zylinder, Quader und Pyramide.
  *
  * @author Doro
  */
 public abstract class Gefaess {
     /**
-     * Preis pro cm³ des Inhalts des Gefäßes
+     * Der Preis pro cm³ des Inhalts des Gefäßes.
      */
-    private double preisInhalt;
+    private final double preisInhalt;
 
     /**
-     * erzeugt ein Gefäß mit dem angegebenen Inhaltspreis
+     * Erzeugt ein Gefäß mit dem angegebenen Inhaltspreis.
      *
-     * @param preisInhalt
+     * @param preisInhalt Der Preis pro cm³ des Inhalts des Gefäßes.
      */
     public Gefaess(double preisInhalt) {
         this.preisInhalt = preisInhalt;
     }
 
     /**
-     * liefert den Namen des Gefäßes zurück
+     * Liefert den Namen des Gefäßes zurück.
      *
-     * @return Name des Gefäßes
+     * @return Der Name des Gefäßes.
      */
     public String getName() {
         return this.getClass().getSimpleName() + "(" + this.preisInhalt + ")";
     }
 
     /**
      * Vergleich von this mit other; Zwei Gefäße gelten als gleich,
-     * wenn sie vom gleichen Subtyp sind und den gleichen Preis haben
+     * wenn sie vom gleichen Subtyp sind und den gleichen Preis haben.
      *
-     * @param other
-     * @return true, wenn beide Gefäße als gleich gelten
+     * @param other Das andere Objekt, mit dem verglichen wird.
+     * @return true, wenn beide Gefäße als gleich gelten, sonst false.
      */
     @Override
     public boolean equals(Object other) {
         if (this == other)
             return true;
-        if (other == null)
-            return false;
-        if (this.getClass() != other.getClass())
+        if (other == null || getClass() != other.getClass())
             return false;
         Gefaess g = (Gefaess) other;
-        if (this.getPreis() == g.getPreis())
-            return true;
-        else
-            return false;
+        return Double.compare(g.preisInhalt, preisInhalt) == 0;
     }
 
+    /**
+     * Berechnet den Hashcode des Gefäßes, basierend auf dem Klassentyp und dem Preis des Inhalts.
+     *
+     * @return Der Hashcode des Gefäßes.
+     */
     @Override
     public int hashCode() {
-        return this.getClass().hashCode() * 59 + Double.hashCode(this.getPreis());
+        return getClass().hashCode() * 59 + Double.hashCode(preisInhalt);
     }
 
+    /**
+     * Gibt eine textuelle Darstellung des Gefäßes zurück,
+     * die den Klassennamen und den Preis des Inhalts enthält.
+     *
+     * @return Die textuelle Darstellung des Gefäßes.
+     */
     @Override
     public String toString() {
         NumberFormat nf = NumberFormat.getCurrencyInstance();
         return this.getClass().getSimpleName() + " zum Preis von "
                 + nf.format(this.getPreis());
     }
 
-    // TODO: JavaDoc
-	public double getPreis() {
-		return this.getVolumen() * this.preisInhalt;
-	}
+    /**
+     * Berechnet den Preis des Inhalts des Gefäßes basierend auf dem Volumen
+     * und dem Preis pro cm³ des Inhalts.
+     * Diese Methode arbeitet nach dem Template Method Pattern, da sie die abstrakte Methode
+     * getVolumen aufruft, die von den konkreten Unterklassen implementiert werden muss,
+     * um das Volumen zu berechnen.
+     *
+     * @return Der Preis des Inhalts des Gefäßes.
+     */
+    public double getPreis() {
+        return this.getVolumen() * this.preisInhalt;
+    }
 
-    // TODO: JavaDoc
-	abstract double getVolumen();
+    /**
+     * Diese abstrakte Methode muss von den konkreten Unterklassen implementiert werden,
+     * um das Volumen des Gefäßes zu berechnen.
+     *
+     * @return Das Volumen des Gefäßes.
+     */
+    abstract double getVolumen();
 }

src/main/java/musterklausur/Gefaessfabrik.java

@@ -1,17 +1,32 @@
 package musterklausur;
 
 /**
- * Abstrakte Gefässfabrik zum Erzeugen eines neuen Gefäßes.
+ * Abstrakte Gefäßfabrik zum Erzeugen eines neuen Gefäßes.
+ * Diese Klasse arbeitet nach dem Abstract Factory Pattern, bei dem eine abstrakte
+ * Methode zum Erstellen eines neuen Gefäßes deklariert ist, die von den konkreten
+ * Unterklassen implementiert werden muss, um das spezifische Gefäß zu erzeugen.
+ * <p>
+ * Die konkreten Unterklassen können verschiedene Arten von Gefäßen erstellen,
+ * die von der abstrakten Klasse Gefaess abgeleitet sind.
+ * <p>
+ * Die Parameter der erstelleGefaess-Methode sind die erforderlichen Eigenschaften,
+ * die zur Erzeugung des Gefäßes benötigt werden (z. B. Länge, Höhe und Preis).
+ * <p>
+ * Beachte: Da dies eine abstrakte Klasse ist, können keine Objekte dieser Klasse
+ * direkt erzeugt werden. Stattdessen müssen die konkreten Unterklassen erstellt werden,
+ * die die abstrakte Methode implementieren und tatsächlich Gefäße erzeugen können.
+ *
+ * @author frievoe97
  */
 abstract class Gefaessfabrik {
 
     /**
      * Abstrakte Implementierung der Methode zum Erstellen eines neuen Gefäßes.
      *
-     * @param laenge
-     * @param hoehe
-     * @param preis
-     * @return Produziertes Gefäß
+     * @param laenge Die Länge des neuen Gefäßes.
+     * @param hoehe Die Höhe des neuen Gefäßes.
+     * @param preis Der Preis pro cm³ des Inhalts des neuen Gefäßes.
+     * @return Produziertes Gefäß, das von der abstrakten Klasse Gefaess abgeleitet ist.
      */
     abstract Gefaess erstelleGefaess(double laenge, double hoehe, double preis);
 }

src/main/java/musterklausur/HausTausenderWunder.java

@@ -10,27 +10,33 @@
 import java.util.stream.Collectors;
 
 /**
- * Diese Klasse stellt den Laden "Haus Tausender Wunder" dar, der
- * viele tolle Gefäße produziert und aus dem Lager heraus verkauft.
+ * Die Klasse HausTausenderWunder repräsentiert den Laden "Haus Tausender Wunder", der viele
+ * tolle Gefäße produziert und aus dem Lager heraus verkauft. Das HausTausenderWunder-Objekt
+ * verwaltet die Lagerverwaltung, startet und stoppt die Produktion von Gefäßen und benachrichtigt
+ * Beobachter über Änderungen im Lagerbestand. Die Klasse implementiert das Observer Pattern
+ * mit dem LagerBeobachter-Interface, um auf Änderungen im Lagerbestand zu reagieren. Sie ist
+ * ein wichtiger Bestandteil des Abstract Factory Patterns, da sie die Gefäßproduktion und
+ * Lagerverwaltung steuert. Die Gesamtsumme des Lagerbestands wird über ein DoubleProperty
+ * gespeichert, um Beobachtern die Aktualisierung zu ermöglichen.
  *
  * @author Doro
  */
 public class HausTausenderWunder {
 
     /**
-     * Anzahl der Gefäße nach der Art des Gefäßes.
+     * Eine Map, die die Anzahl der Gefäße nach der Art des Gefäßes speichert.
      */
     private final Map<Gefaess, Integer> lagerverwaltung = new HashMap<>();
 
     /**
-     * Gesamtpreis des Lagerbestands.
+     * Das DoubleProperty, das den Gesamtpreis des Lagerbestands speichert.
      */
     private final DoubleProperty gesamtpreis = new SimpleDoubleProperty(0);
 
     /**
-     * Property des Gesamtpreises.
+     * Gibt das DoubleProperty des Gesamtpreises zurück.
      *
-     * @return Property des Gesamtpreises.
+     * @return Das DoubleProperty des Gesamtpreises.
      */
     public DoubleProperty gesamtpreisProperty() {
         return this.gesamtpreis;
@@ -42,19 +48,18 @@ public DoubleProperty gesamtpreisProperty() {
     private Thread produktionsThread;
 
     /**
-     * Liste aller Beobachter.
+     * Eine Liste aller Beobachter, die auf Änderungen im Lagerbestand reagieren.
      */
     private final List<LagerBeobachter> beobachter = new ArrayList<>();
 
     /**
-     * startet die Endlosproduktion von Gefäßen der angegebenen Größe
-     * mithilfe der Fabrik und fügt die erstellten Gefäße in die
-     * Lagerverwaltung ein
+     * Startet die Endlosproduktion von Gefäßen der angegebenen Größe mithilfe
+     * der Fabrik und fügt die erstellten Gefäße in die Lagerverwaltung ein.
      *
-     * @param fabrik
-     * @param preisInhalt
-     * @param laenge
-     * @param hoehe
+     * @param fabrik      Die Gefäßfabrik, die zum Erstellen der Gefäße verwendet wird.
+     * @param preisInhalt Der Preis pro cm³ des Inhalts der Gefäße.
+     * @param laenge      Die Länge der zu produzierenden Gefäße.
+     * @param hoehe       Die Höhe der zu produzierenden Gefäße.
      */
     public void produktionStarten(Gefaessfabrik fabrik, double preisInhalt,
                                   double laenge, double hoehe) {
@@ -68,17 +73,17 @@ public void produktionStarten(Gefaessfabrik fabrik, double preisInhalt,
     }
 
     /**
-     * stoppt alle laufenden Produktionen
+     * Stoppt alle laufenden Produktionen.
      */
     public void produktionStoppen() {
         produktionsThread.interrupt();
     }
 
     /**
-     * entnimmt das Gefäß g aus der Lagerverwaltung
+     * Entnimmt das Gefäß g aus der Lagerverwaltung.
      *
-     * @param gefaess
-     * @throws NichtVorhandenException, wenn g nicht im Lager vorhanden ist
+     * @param gefaess Das Gefäß, das aus dem Lager entnommen werden soll.
+     * @throws NichtVorhandenException Wenn das Gefäß nicht im Lager vorhanden ist.
      */
     public void gefaessKaufen(Gefaess gefaess) throws NichtVorhandenException {
 
@@ -96,9 +101,9 @@ public void gefaessKaufen(Gefaess gefaess) throws NichtVorhandenException {
     }
 
     /**
-     * fügt das Gefäß g in die Lagerverwaltung ein
+     * Fügt das Gefäß g in die Lagerverwaltung ein.
      *
-     * @param gefaess
+     * @param gefaess Das Gefäß, das in das Lager eingefügt werden soll.
      */
     protected void gefaessEinfuegen(Gefaess gefaess) {
         if (gefaess != null) {
@@ -110,9 +115,9 @@ protected void gefaessEinfuegen(Gefaess gefaess) {
     }
 
     /**
-     * liefert einen textuelle Liste aller Gefäße mit ihrer Anzahl zurück
+     * Liefert eine textuelle Liste aller Gefäße mit ihrer Anzahl im Lager zurück.
      *
-     * @return
+     * @return Textuelle Liste aller Gefäße mit ihrer Anzahl.
      */
     public String getGefaessliste() {
         // TODO: Map Streams zu Beispielen hinzufügen
@@ -125,7 +130,7 @@ public String getGefaessliste() {
     /**
      * Fügt einen neuen Beobachter hinzu.
      *
-     * @param lagerBeobachter
+     * @param lagerBeobachter Der hinzuzufügende LagerBeobachter.
      */
     public void beobachterHinzufuegen(LagerBeobachter lagerBeobachter) {
         beobachter.add(lagerBeobachter);
@@ -134,14 +139,14 @@ public void beobachterHinzufuegen(LagerBeobachter lagerBeobachter) {
     /**
      * Entfernt einen Beobachter aus der Liste.
      *
-     * @param lagerBeobachter
+     * @param lagerBeobachter Der zu entfernende LagerBeobachter.
      */
     public void beobachterEntfernen(LagerBeobachter lagerBeobachter) {
         beobachter.remove(lagerBeobachter);
     }
 
     /**
-     * Benachrcihtigt alle Beobachter über eine Änderung in der Lagerverwaltung.
+     * Benachrichtigt alle Beobachter über eine Änderung in der Lagerverwaltung.
      */
     public void benachrichtigen() {
         for (LagerBeobachter lagerBeobachter : beobachter) {

src/main/java/musterklausur/LagerBeobachter.java

@@ -1,6 +1,43 @@
 package musterklausur;
 
+/**
+ * Das Interface `LagerBeobachter` dient dem Observer Pattern, bei dem Objekte
+ * Änderungen an einem bestimmten Subjekt (Lager) verfolgen können.
+ * <p>
+ * Ein Objekt, das dieses Interface implementiert, kann als Beobachter für das Lager
+ * dienen und wird über Änderungen im Lagerbestand informiert, indem die Methode
+ * `lagerGeaendert()` aufgerufen wird.
+ * <p>
+ * Die Klasse `HausTausenderWunder` enthält eine Liste von LagerBeobachter-Objekten,
+ * die über Änderungen im Lager informiert werden, wenn neue Gefäße hinzugefügt oder
+ * vorhandene Gefäße gekauft werden.
+ * <p>
+ * Um das Observer Pattern zu implementieren, muss eine Klasse dieses Interface
+ * implementieren und die gewünschten Aktionen in der Methode `lagerGeaendert()` ausführen,
+ * wenn sie benachrichtigt wird.
+ * <p>
+ * LagerBeobachter meinBeobachter = new MeinBeobachter();
+ * hausTausenderWunder.beobachterHinzufuegen(meinBeobachter);
+ * <p>
+ * Wenn nun das Lager aktualisiert wird (z.B. durch Hinzufügen oder Kaufen von Gefäßen),
+ * wird die `lagerGeaendert()`-Methode des `MeinBeobachter`-Objekts aufgerufen und die
+ * entsprechenden Aktionen werden ausgeführt.
+ * <p>
+ * Beachte: Das Interface enthält nur eine Methode, die die Beobachter informiert,
+ * ohne zusätzliche Argumente. Bei Bedarf können weitere Informationen im Lagerbeobachter
+ * implementiert werden, indem zusätzliche Parameter an die `lagerGeaendert()`-Methode
+ * hinzugefügt werden.
+ *
+ * @author frievoe97
+ * @see HausTausenderWunder
+ * @see HausTausenderWunder#beobachterHinzufuegen(LagerBeobachter)
+ * @see HausTausenderWunder#benachrichtigen()
+ * @see LagerBeobachter#lagerGeaendert()
+ */
 interface LagerBeobachter {
+    /**
+     * Wird aufgerufen, wenn Änderungen im Lagerbestand festgestellt werden.
+     * Implementierende Klassen sollten die gewünschten Aktionen in dieser Methode ausführen.
+     */
     void lagerGeaendert();
 }
-

src/main/java/musterklausur/NichtVorhandenException.java

@@ -3,8 +3,8 @@
 /**
  * Diese Exception tritt auf, wenn ein gewünschtes Gefäß
  * nicht im Lager vorhanden ist
- * @author Doro
  *
+ * @author Doro
  */
 public class NichtVorhandenException extends Exception {