From 532f889fd681202bd83fdcb8ccece99cbda8000c Mon Sep 17 00:00:00 2001 From: nikow Date: Sun, 8 Jan 2023 00:00:32 +0100 Subject: [PATCH] Merget. --- Roboterfabrik/src/Domäne/RobotFactory.java | 112 ++++++++++++-------- Roboterfabrik/src/facade/Factorysystem.java | 64 +++++------ 2 files changed, 95 insertions(+), 81 deletions(-) diff --git a/Roboterfabrik/src/Domäne/RobotFactory.java b/Roboterfabrik/src/Domäne/RobotFactory.java index c6084d4..0fdc89a 100644 --- a/Roboterfabrik/src/Domäne/RobotFactory.java +++ b/Roboterfabrik/src/Domäne/RobotFactory.java @@ -3,11 +3,11 @@ package Domäne; import java.util.HashMap; import tpe.exceptions.roboter.exceptions.RobotException; + /** + * Factory-Klasse für R2D2 und C3PO * - * Schnittstelle zwischen Roboter und FactorySystem. - * hier wird auch das Objekt Pris erzeugt. - * RobotFactory hat eine HashMap wo die Roboter gelagert werden. + * @author Kai-Niklas Dippold * */ public class RobotFactory { @@ -15,16 +15,24 @@ public class RobotFactory { private Roboter pris = Nexus6.getInstance(); private HashMap roboterLager = new HashMap<>(); + /** + * Benennt die RobotFactory und setzt Nexus-Roboter "Pris" ins Roboterlager + * + * @param name Name der RobotFactory + */ public RobotFactory(String name) { this.name = name; roboterLager.put(pris.getId(), pris); } + /** - * Hier werden Roboter erzeugt und in die HashMap gespeichert. - * Außerdem wird durh die if-Abfrage zweischen R2D2 und C3PO unterschieden. - * @param robotType - * @param name - * @return id vom Roboter der gerade erzeugt worden ist. + * Erstellt neue Roboter nach Anforderungen, speichert diese im Roboterlager und + * gibt die Id des erstellten Roboters zurück + * + * @param robotType entweder R2D2 oder C3PO + * @param name Name des Roboters + * + * @return Gibt die ID des erstellten Roboters zurück. */ public int addRobot(RobotType robotType, String name) { Roboter roboter; @@ -41,29 +49,32 @@ public class RobotFactory { } else return -1; } + /** + * Gibt den Namen der RobotFactory zurück. * - * @return name um eventuell den Namen der RobotFactory zurückzugeben. + * @return Name der RobotFactory */ public String getName() { return name; } + /** - * gibt den gesuchten Roboter mit der passenden ID zurück. - * @param id - * @return Roboter objekt + * Duchsucht das Roboterlager nach einem bestimmten Roboter + * + * @param id Id des Roboters + * @return Instanz des Roboters mit der gefragten Id */ public Roboter findeRoboter(int id) { return roboterLager.get(id); } + /** - * Diese Methode ist wichtig um die Ids zufällig zur vergeben. - * Je nach robotType wird ein anders min und max übergeben. Das gibt - * dann den Bereich an wo die Zahl zufällig vergeben wird. - * Wurde diese ID schon vergeben, so ruft sich die Methode von selbst auf. - * @param min minimum vom Bereich - * @param max Maximum vom Bereich - * @return randomValue die zufällige und noch nicht vergebene ID + * Generiert eine Zahl innerhalb der gegebenen Parameter + * + * @param min Mindestgröße der Zahl + * @param max Maximalgröße der Zahl + * @return Zufallszahl innerhalb der Parameter */ private int idVergeben(int min, int max) { @@ -74,20 +85,25 @@ public class RobotFactory { return randomValue; } + /** - * gibt anhand der ID den Zustand des Roboters zurück. - * @param id - * @return zustand vom Roboter + * Prüft ob ein Roboter ein- oder ausgeschaltet ist + * + * @param id Id des Roboters + * @return Zustand des Roboters */ public boolean roboterZustand(int id) { Roboter r = findeRoboter(id); boolean zustand = r.isPowerOn(); return zustand; } + /** - * Um den richtigen Roboter anhand der ID An oder Aus zu schalten. - * @param id um den richtigen Roboter zu finden - * @return zustand vom Roboter + * Schaltet einen Roboter ein wenn er ausgeschaltet ist und schaltet ihn aus + * wenn er eingeschaltet ist + * + * @param id Id des Roboters + * @return Zustand des Roboters */ public boolean schalterAnAus(int id) { Roboter r = findeRoboter(id); @@ -95,14 +111,15 @@ public class RobotFactory { boolean zustand = r.isPowerOn(); return zustand; } + /** - * Hier werden beide Methoden aufgerufen. Zuerst wird der richtige - * Roboter gefunden, dann werden die zahlen von der think()-methode sortiert, und - * anschließend mit den richtigen Trennzeichen mit der speak()-methode ausgegeben. - * @param id - * @param zahlen - * @return ausgabe als String Sortiert, mit den richtigen Trennzeichen - * @throws RobotException falls der Roboter Aus ist oder zahlen[] die Zahl 42 enthält. + * Ruft die Methoden think() und speak() eines Roboters auf und gibt dessen + * Ausgabe wieder. + * + * @param id Id des Roboters + * @param zahlen Int-Array + * @return String mit dem Inhalt des gegebenen Arrays, nachdem es von dem + * Roboter sortiert wurde. */ public String aufrufSpeakAndThink(int id, int[] zahlen) throws RobotException { Roboter r = findeRoboter(id); @@ -111,19 +128,23 @@ public class RobotFactory { return ausgabe; } + /** - * Hier wird der letzte Fehler zurückgegeben, den der Roboter geworfen hat. - * @param id - * @return RobotException letzte Ausnahme vom Roboter + * Gibt den letzten Fehler zurück, auf den der Roboter gestoßen ist + * + * @param id Id des Roboters + * @return Die RobotException welche im Roboter gespeichert ist */ public RobotException letzterFehler(int id) { Roboter r = findeRoboter(id); return r.getLastException(); } + /** - * Hier werden anhand der Id Typ, Name und Seriennummer vom Roboter zurückgegeben. - * @param id - * @return ausgabe als String für die Daten des Roboters + * Gibt die Daten eines Roboters wieder + * + * @param id Id des Roboters + * @return String mit Typ, Namen und Id des Roboters */ public String datenDesRoboters(int id) { Roboter r = findeRoboter(id); @@ -134,18 +155,21 @@ public class RobotFactory { return ausgabe; } + /** - * gibt die größe vom roboterLager zurück. - * Wird für das Testen verwendet. - * @return int größe des Lagers + * Gibt die Größe des Roboterlagers an. + * + * @return Größe des Roboterlagers */ public int getRoboterLagerSize() { return roboterLager.size(); } + /** - * Gibt einen boolean zurück um zu schauen ob dieser Roboter schon existiert. - * @param id um zu schauen ob diese Id schon vergeben wurde - * @return boolean true bedeutet, dass es diesen Roboter gibt + * Überprüft ob das Lager einen bestimmten Roboter enthält. + * + * @param id Id des Roboters + * @return true oder false je nachdem ob der Roboter im Lager vorhanden ist */ public boolean istDieserRoboterDa(int id) { return roboterLager.containsKey(id); diff --git a/Roboterfabrik/src/facade/Factorysystem.java b/Roboterfabrik/src/facade/Factorysystem.java index afb0875..9a3757b 100644 --- a/Roboterfabrik/src/facade/Factorysystem.java +++ b/Roboterfabrik/src/facade/Factorysystem.java @@ -3,24 +3,33 @@ package facade; import Domäne.RobotFactory; import Domäne.RobotType; import tpe.exceptions.roboter.exceptions.RobotException; + /** + * Factorysystem agiert als Fassade für RobotFactory + * + * @author Kai-Niklas Dippold + * * - * Ist die Schnittstelle zwischen RobotFactory und Factory. - * Hier wird eine neue RobotFactory erzeugt * */ public class Factorysystem { private RobotFactory robotFactory; + /** + * Erstellt eine neue RobotFactory mit dem gegebenen Namen + * + * @param name Name der RobotFactory + */ public Factorysystem(String name) { this.robotFactory = new RobotFactory(name); } + /** - * Dieser Methode wird der Name des Roboters und ein int 1 oder 2 übergeben. - * Durch die if_Abfrage wird entweder dem Roboter den Typ R2D2 oder C3pO vergeben. - * @param name des Roboters - * @param auswahl um den Typ des Roboters zu bestimmen - * @return id vom Roboter + * Legt einen neuen Roboter je nach Auswahl mit dem gegebenen Namen an + * + * @param name Name des Roboters + * @param auswahl Bei 1 wird ein R2D2 erstellt, bei 2 ein C3PO. + * @return Gibt die ID des erstellten Roboters zurück */ public int roboterAnlegen(String name, int auswahl) { RobotType robottype; @@ -36,55 +45,36 @@ public class Factorysystem { return -1; } + /** - * Um den Zustand des Roboter zurückzugeben. - * @param id vom Roboter - * @return gibt den Zustand zurück + * Ruft die Methode roboterZustand(id) in der RobotFactory auf + * + * @see Domäne.RobotFactory#roboterZustand(int) + * @param id Id des Roboters + * @return Gibt die Wiedergabe von roboterZustand(id) zurück */ public boolean zustandRoboter(int id) { return robotFactory.roboterZustand(id); } - /** - * Um den Roboter An oder Aus zuschalten. - * @param id vom Roboter - * @return boolean True bedeutet An, False bedeutet Aus - */ + public boolean schalterBetätigen(int id) { return robotFactory.schalterAnAus(id); } - /** - * Um die Methoden think() und speak() vom Roboter aufzurufen. - * @param id vom Roboter - * @param zahlen die Zahlen die sortiert werden sollen - * @return als String Sortiert, mit den richtigen Trennzeichen - * @throws RobotException falls der Roboter Aus ist oder zahlen[] die Zahl 42 enthält. - */ + public String sprechenAufruf(int id, int[] zahlen) throws RobotException { String ausgabe = robotFactory.aufrufSpeakAndThink(id, zahlen); return ausgabe; } - /** - * um den letzten Fehler zu lesen den der Roboter geworfen hat. - * @param id vom Roboter - * @return RobotException der letzte Fehler - */ + public RobotException fehlerAuslesen(int id) { return robotFactory.letzterFehler(id); } - /** - * Um die Daten des Roboters an Factory zu übergeben. - * @param id vom Roboter - * @return Daten vom Roboter - */ + public String roboterDaten(int id) { return robotFactory.datenDesRoboters(id); } - /** - * Um den boolean an Factory zu übergeben. - * @param id vom Roboter - * @return boolean ob dieser Roboter existiert oder nicht - */ + public boolean istDieserRoboterDa(int id) { boolean istDa = robotFactory.istDieserRoboterDa(id); return istDa;