+ * Die konkreten Unterklassen können verschiedene Arten von Gefäßen erstellen, + * die von der abstrakten Klasse Gefaess abgeleitet sind. + *
+ * 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). + *
+ * 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);
}
diff --git a/src/main/java/musterklausur/HausTausenderWunder.java b/src/main/java/musterklausur/HausTausenderWunder.java
index b9edb2c..621a1fc 100644
--- a/src/main/java/musterklausur/HausTausenderWunder.java
+++ b/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
+ * 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.
+ *
+ * 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.
+ *
+ * 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.
+ *
+ * LagerBeobachter meinBeobachter = new MeinBeobachter();
+ * hausTausenderWunder.beobachterHinzufuegen(meinBeobachter);
+ *
+ * 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.
+ *
+ * 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();
}
-
diff --git a/src/main/java/musterklausur/NichtVorhandenException.java b/src/main/java/musterklausur/NichtVorhandenException.java
index e8c584f..d8f6f3c 100644
--- a/src/main/java/musterklausur/NichtVorhandenException.java
+++ b/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 {
diff --git a/src/main/java/musterklausur/Pyramide.java b/src/main/java/musterklausur/Pyramide.java
index ffbf99f..1f54459 100644
--- a/src/main/java/musterklausur/Pyramide.java
+++ b/src/main/java/musterklausur/Pyramide.java
@@ -1,36 +1,52 @@
package musterklausur;
/**
- * Pyramidenförmiges Gefäß mit quadratischer Grundfläche
- * @author Doro
+ * Die Klasse Pyramide stellt ein pyramidenförmiges Gefäß mit quadratischer Grundfläche dar.
+ * Sie erbt von der abstrakten Klasse Gefaess und implementiert die abstrakte Methode getVolumen,
+ * um das Volumen der Pyramide zu berechnen.
+ * Die Klasse enthält die Länge einer Seite der Grundfläche und die Höhe der Pyramide.
+ *
+ * Der Konstruktor ermöglicht die Erstellung eines Pyramiden-Gefäßes mit den angegebenen Werten
+ * für den Preis des Inhalts, die Seitenlänge und die Höhe.
+ *
+ * Das Volumen der Pyramide wird basierend auf den angegebenen Werten für die Seitenlänge und die Höhe berechnet.
+ *
*
+ * @author Doro
*/
-public class Pyramide extends Gefaess {
+public final class Pyramide extends Gefaess {
+
+ /**
+ * Die Länge einer Seite der Grundfläche in cm.
+ */
+ private final double seitenlaenge;
- /**
- * Länge einer Seite der Grundfläche in cm
- */
- private double seitenlaenge;
- /**
- * Höhe der Pyramide in cm
- */
- private double hoehe;
+ /**
+ * Die Höhe der Pyramide in cm.
+ */
+ private final double hoehe;
- /**
- * erstellt ein Pyramiden-Gefäß mit den angegegeben Werten
- * @param preisInhalt
- * @param seitenlaenge
- * @param hoehe
- */
- public Pyramide(double preisInhalt, double seitenlaenge, double hoehe) {
- super(preisInhalt);
- this.seitenlaenge = seitenlaenge;
- this.hoehe = hoehe;
- }
+ /**
+ * Erstellt ein Pyramiden-Gefäß mit den angegebenen Werten für den Preis des Inhalts,
+ * die Seitenlänge und die Höhe.
+ *
+ * @param preisInhalt Der Preis pro cm³ des Inhalts der Pyramide.
+ * @param seitenlaenge Die Länge einer Seite der Grundfläche der Pyramide.
+ * @param hoehe Die Höhe der Pyramide.
+ */
+ public Pyramide(double preisInhalt, double seitenlaenge, double hoehe) {
+ super(preisInhalt);
+ this.seitenlaenge = seitenlaenge;
+ this.hoehe = hoehe;
+ }
- // TODO: JavaDoc
- @Override
- double getVolumen() {
- return (1./3) * Math.pow(this.seitenlaenge, 2) * this.hoehe;
- }
+ /**
+ * Berechnet das Volumen der Pyramide basierend auf den angegebenen Werten für die Seitenlänge und die Höhe.
+ *
+ * @return Das Volumen der Pyramide.
+ */
+ @Override
+ double getVolumen() {
+ return (1. / 3) * Math.pow(this.seitenlaenge, 2) * this.hoehe;
+ }
}
diff --git a/src/main/java/musterklausur/Quader.java b/src/main/java/musterklausur/Quader.java
index c7b912a..8efc246 100644
--- a/src/main/java/musterklausur/Quader.java
+++ b/src/main/java/musterklausur/Quader.java
@@ -1,35 +1,51 @@
package musterklausur;
+
/**
- * Quaderförmiges Gefäß mit quadratischer Grundfläche
- * @author Doro
+ * Die Klasse Quader stellt ein quaderförmiges Gefäß mit quadratischer Grundfläche dar.
+ * Sie erbt von der abstrakten Klasse Gefaess und implementiert die abstrakte Methode getVolumen,
+ * um das Volumen des Quaders zu berechnen.
+ * Die Klasse enthält die Länge einer Seite der Grundfläche und die Höhe des Quaders.
+ *
+ * Der Konstruktor ermöglicht die Erstellung eines Quader-Gefäßes mit den angegebenen Werten
+ * für den Preis des Inhalts, die Seitenlänge und die Höhe.
+ *
+ * Das Volumen des Quaders wird basierend auf den angegebenen Werten für die Seitenlänge und die Höhe berechnet.
*
+ * @author Doro
*/
-public class Quader extends Gefaess {
+public final class Quader extends Gefaess {
+
+ /**
+ * Die Länge einer Seite der Grundfläche in cm.
+ */
+ private final double seitenlaenge;
- /**
- * Länge einer Seite der Grundfläche in cm
- */
- private double seitenlaenge;
- /**
- * Höhe des Quaders in cm
- */
- private double hoehe;
+ /**
+ * Die Höhe des Quaders in cm.
+ */
+ private final double hoehe;
- /**
- * erstellt ein Quader-Gefäß mit den angegebenen Werten
- * @param preisInhalt
- * @param seitenlaenge
- * @param hoehe
- */
- public Quader(double preisInhalt, double seitenlaenge, double hoehe) {
- super(preisInhalt);
- this.seitenlaenge = seitenlaenge;
- this.hoehe = hoehe;
- }
+ /**
+ * Erstellt ein Quader-Gefäß mit den angegebenen Werten für den Preis des Inhalts,
+ * die Seitenlänge und die Höhe.
+ *
+ * @param preisInhalt Der Preis pro cm³ des Inhalts des Quaders.
+ * @param seitenlaenge Die Länge einer Seite der Grundfläche des Quaders.
+ * @param hoehe Die Höhe des Quaders.
+ */
+ public Quader(double preisInhalt, double seitenlaenge, double hoehe) {
+ super(preisInhalt);
+ this.seitenlaenge = seitenlaenge;
+ this.hoehe = hoehe;
+ }
- // TODO: JavaDoc
- @Override
- double getVolumen() {
- return Math.pow(this.seitenlaenge, 2) * this.hoehe;
- }
+ /**
+ * Berechnet das Volumen des Quaders basierend auf den angegebenen Werten für die Seitenlänge und die Höhe.
+ *
+ * @return Das Volumen des Quaders.
+ */
+ @Override
+ double getVolumen() {
+ return Math.pow(this.seitenlaenge, 2) * this.hoehe;
+ }
}
diff --git a/src/main/java/musterklausur/WunderController.java b/src/main/java/musterklausur/WunderController.java
index d5f5915..38239ce 100644
--- a/src/main/java/musterklausur/WunderController.java
+++ b/src/main/java/musterklausur/WunderController.java
@@ -14,7 +14,15 @@
import javafx.scene.control.TextField;
import javafx.stage.Stage;
-public class WunderController extends Application implements LagerBeobachter {
+/**
+ * Die Klasse WunderController ist der Controller für die Benutzeroberfläche des "Haus Tausender Wunder".
+ * Sie erbt von der JavaFX Application-Klasse und implementiert das LagerBeobachter-Interface.
+ * Der Controller ermöglicht die Interaktion mit der Benutzeroberfläche und die Steuerung der Anwendung.
+ * Er verwaltet das "Haus Tausender Wunder" und stellt die Verbindung zwischen der Benutzeroberfläche und dem Modell her.
+ *
+ * @author Doro
+ */
+public final class WunderController extends Application implements LagerBeobachter {
@FXML
private TextArea txtGefaesse;
@@ -31,27 +39,42 @@ public class WunderController extends Application implements LagerBeobachter {
@FXML
private TextField txtGesamtpreis;
- private HausTausenderWunder htw = new HausTausenderWunder();
+ private final HausTausenderWunder htw = new HausTausenderWunder();
+ /**
+ * Initialisiert die Benutzeroberfläche nach dem Laden des FXML-Dokuments.
+ * Wird automatisch von JavaFX aufgerufen.
+ * Fügt die möglichen Gefäßformen zur ChoiceBox hinzu und fügt den Controller als LagerBeobachter hinzu.
+ * Bindet das Property für den Gesamtpreis an das Textfeld für die Anzeige.
+ */
@FXML
private void initialize() {
ObservableList
+ * Diese Fabrik erstellt zufällig Gefäße der verschiedenen Typen (Zylinder, Quader oder Pyramide) mit den
+ * angegebenen Maßen und dem Preis. Die Erstellung der Gefäße dauert eine bestimmte Zeit, um den asynchronen
+ * Charakter der Fabrik zu demonstrieren.
+ *
+ * Die Klasse enthält die statischen Konstanten `ANZAHL_SEKUNDEN`, `MILLISEKUNDEN_PRO_SEKUNDE` und
+ * `ANZAHL_AN_GEFAESSTYPEN`, die für die Verzögerung und die Auswahl des Gefäßtyps verwendet werden.
+ *
+ * Die Methode `erstelleGefaess` überschreibt die abstrakte Methode aus der Klasse `Gefaessfabrik` und
+ * erzeugt ein zufälliges Gefäß vom Typ Zylinder, Quader oder Pyramide basierend auf den übergebenen Maßen
+ * und dem Preis. Die Erstellung des Gefäßes dauert die in den Konstanten definierte Zeit, um den Effekt
+ * der Verzögerung zu erzeugen.
+ *
+ * Wenn die Erstellung des Gefäßes durch die Verzögerung unterbrochen wird (z. B. wenn der Thread unterbrochen
+ * wird), wird `null` zurückgegeben.
+ *
+ * Beachte: Die Klasse implementiert das Abstract Factory Pattern, indem sie die abstrakte Methode
+ * `erstelleGefaess()` überschreibt, um konkrete Gefäße basierend auf den übergebenen Parametern zu erzeugen.
+ *
+ * @author frievoe97
+ * @see Gefaessfabrik
+ * @see Gefaessfabrik#erstelleGefaess(double, double, double)
+ * @see Zylinder
+ * @see Quader
+ * @see Pyramide
+ */
+final class Zufallsgefaessfabrik extends Gefaessfabrik {
+ /**
+ * Die Zeitdauer, die benötigt wird, um ein Gefäß zu erzeugen.
+ */
public static final int ANZAHL_SEKUNDEN = 10;
+
+ /**
+ * Die Konstante für die Umrechnung von Sekunden in Millisekunden.
+ */
public static final int MILLISEKUNDEN_PRO_SEKUNDE = 1000;
- public static final int ANZAHL_AN_GEFAESTYPEN = 3;
- // TODO: JavaDoc
+ /**
+ * Die Anzahl der verschiedenen Gefäßtypen (Zylinder, Quader, Pyramide).
+ */
+ public static final int ANZAHL_AN_GEFAESSTYPEN = 3;
+
+ /**
+ * Erstellt ein zufälliges Gefäß basierend auf den angegebenen Maßen und dem Preis.
+ * Die Methode überschreibt die abstrakte Methode `erstelleGefaess()` aus der Klasse `Gefaessfabrik`.
+ *
+ * @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 Ein zufälliges Gefäß (Zylinder, Quader oder Pyramide) oder null, wenn die Erstellung
+ * durch die Verzögerung unterbrochen wurde.
+ */
@Override
Gefaess erstelleGefaess(double laenge, double hoehe, double preis) {
try {
+ // Verzögerung, um den asynchronen Charakter der Fabrik zu demonstrieren
Thread.sleep(ANZAHL_SEKUNDEN * MILLISEKUNDEN_PRO_SEKUNDE);
Random random = new Random();
- switch (random.nextInt(ANZAHL_AN_GEFAESTYPEN)) {
- case 0:
+ // Zufällig einen Gefäßtyp auswählen und das entsprechende Gefäß erzeugen
+ switch (random.nextInt(ANZAHL_AN_GEFAESSTYPEN)) {
+ case 0 -> {
return new Zylinder(preis, laenge, hoehe);
- case 1:
+ }
+ case 1 -> {
return new Quader(preis, laenge, hoehe);
- case 2:
+ }
+ case 2 -> {
return new Pyramide(preis, laenge, hoehe);
+ }
}
} catch (InterruptedException ignored) {
-
+ // Wenn die Erstellung des Gefäßes durch die Verzögerung unterbrochen wurde, wird null zurückgegeben.
}
return null;
}
-}
\ No newline at end of file
+}
diff --git a/src/main/java/musterklausur/Zylinder.java b/src/main/java/musterklausur/Zylinder.java
index 060bbe8..b0d3a36 100644
--- a/src/main/java/musterklausur/Zylinder.java
+++ b/src/main/java/musterklausur/Zylinder.java
@@ -1,35 +1,43 @@
package musterklausur;
/**
- * Zylindrisches Gefäß
- * @author Doro
+ * Die Klasse Zylinder stellt ein zylindrisches Gefäß dar.
+ * Sie erbt von der abstrakten Klasse Gefaess.
*
+ * @author Doro
*/
-public class Zylinder extends Gefaess {
- /**
- * Durchmesser in cm
- */
- private double durchmesser;
- /**
- * Höhe des Zylinders in cm
- */
- private double hoehe;
+public final class Zylinder extends Gefaess {
+ /**
+ * Durchmesser des Zylinders in cm.
+ */
+ private final double durchmesser;
+
+ /**
+ * Höhe des Zylinders in cm.
+ */
+ private final double hoehe;
- /**
- * erstellt einen Zylinder mit den angegebenen Werten
- * @param preisInhalt
- * @param durchmesser
- * @param hoehe
- */
- public Zylinder(double preisInhalt, double durchmesser, double hoehe) {
- super(preisInhalt);
- this.durchmesser = durchmesser;
- this.hoehe = hoehe;
- }
+ /**
+ * Erzeugt einen Zylinder mit den angegebenen Werten.
+ *
+ * @param preisInhalt Der Preis pro cm³ des Inhalts des Zylinders.
+ * @param durchmesser Der Durchmesser des Zylinders in cm.
+ * @param hoehe Die Höhe des Zylinders in cm.
+ */
+ public Zylinder(double preisInhalt, double durchmesser, double hoehe) {
+ super(preisInhalt);
+ this.durchmesser = durchmesser;
+ this.hoehe = hoehe;
+ }
- // TODO: JavaDoc
- @Override
- double getVolumen() {
- return (Math.PI/4) * Math.pow(this.durchmesser, 2) * this.hoehe;
- }
+ /**
+ * Berechnet das Volumen des Zylinders basierend auf den angegebenen Werten
+ * für den Durchmesser und die Höhe.
+ *
+ * @return Das Volumen des Zylinders.
+ */
+ @Override
+ double getVolumen() {
+ return (Math.PI / 4) * Math.pow(this.durchmesser, 2) * this.hoehe;
+ }
}