2122158
/
PR2-Roboterfabrik
1
0
Fork 0
Code Issues Pull Requests Packages Projects Releases Wiki Activity

Merget.

master
nikow 2023-01-08 00:00:32 +01:00
parent 40ed734a79
commit 532f889fd6
2 changed files with 95 additions and 81 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

112
Roboterfabrik/src/Domäne/RobotFactory.java
View File

@ -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<Integer, Roboter> 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);

64
Roboterfabrik/src/facade/Factorysystem.java
View File

@ -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;