Merget.

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.
+ * @author Kai-Niklas Dippold
- * hier wird auch das Objekt Pris erzeugt.
- * RobotFactory hat eine HashMap wo die Roboter gelagert werden.
  *
  */
 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.
+	 * Erstellt neue Roboter nach Anforderungen, speichert diese im Roboterlager und
-	 * Außerdem wird durh die if-Abfrage zweischen R2D2 und C3PO unterschieden.
+	 * gibt die Id des erstellten Roboters zurück
-	 * @param robotType
+	 * 
-	 * @param name
+	 * @param robotType entweder R2D2 oder C3PO
-	 * @return id vom Roboter der gerade erzeugt worden ist.
+	 * @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.
+	 * Duchsucht das Roboterlager nach einem bestimmten Roboter
-	 * @param id
+	 * 
-	 * @return Roboter objekt 
+	 * @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.
+	 * Generiert eine Zahl innerhalb der gegebenen Parameter
-	 * Je nach robotType wird ein anders min und max übergeben. Das gibt
+	 * 
-	 * dann den Bereich an wo die Zahl zufällig vergeben wird.
+	 * @param min Mindestgröße der Zahl
-	 * Wurde diese ID schon vergeben, so ruft sich die Methode von selbst auf.
+	 * @param max Maximalgröße der Zahl
-	 * @param min minimum vom Bereich
+	 * @return Zufallszahl innerhalb der Parameter
-	 * @param max Maximum vom Bereich
-	 * @return randomValue die zufällige und noch nicht vergebene ID
 	 */
 	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.
+	 * Prüft ob ein Roboter ein- oder ausgeschaltet ist
-	 * @param id
+	 * 
-	 * @return zustand vom Roboter
+	 * @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.
+	 * Schaltet einen Roboter ein wenn er ausgeschaltet ist und schaltet ihn aus
-	 * @param id um den richtigen Roboter zu finden
+	 * wenn er eingeschaltet ist
-	 * @return zustand vom Roboter
+	 * 
+	 * @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
+	 * Ruft die Methoden think() und speak() eines Roboters auf und gibt dessen
-	 * Roboter gefunden, dann werden die zahlen von der think()-methode sortiert, und
+	 * Ausgabe wieder.
-	 * anschließend mit den richtigen Trennzeichen mit der speak()-methode ausgegeben.
+	 * 
-	 * @param id
+	 * @param id     Id des Roboters
-	 * @param zahlen
+	 * @param zahlen Int-Array
-	 * @return ausgabe als String Sortiert, mit den richtigen Trennzeichen
+	 * @return String mit dem Inhalt des gegebenen Arrays, nachdem es von dem
-	 * @throws RobotException falls der Roboter Aus ist oder zahlen[] die Zahl 42 enthält.
+	 *         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.
+	 * Gibt den letzten Fehler zurück, auf den der Roboter gestoßen ist
-	 * @param id
+	 * 
-	 * @return RobotException letzte Ausnahme vom Roboter
+	 * @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.
+	 * Gibt die Daten eines Roboters wieder
-	 * @param id
+	 * 
-	 * @return ausgabe als String für die Daten des Roboters
+	 * @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.
+	 * Gibt die Größe des Roboterlagers an.
-	 * Wird für das Testen verwendet.
+	 * 
-	 * @return int größe des Lagers
+	 * @return Größe des Roboterlagers
 	 */
 	public int getRoboterLagerSize() {
 		return roboterLager.size();
 	}
+
 	/**
-	 * Gibt einen boolean zurück um zu schauen ob dieser Roboter schon existiert.
+	 * Überprüft ob das Lager einen bestimmten Roboter enthält.
-	 * @param id um zu schauen ob diese Id schon vergeben wurde
+	 * 
-	 * @return boolean true bedeutet, dass es diesen Roboter gibt
+	 * @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);

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.
+	 * Legt einen neuen Roboter je nach Auswahl mit dem gegebenen Namen an
-	 * Durch die if_Abfrage wird entweder dem Roboter den Typ R2D2 oder C3pO vergeben.
+	 * 
-	 * @param name des Roboters
+	 * @param name    Name des Roboters
-	 * @param auswahl um den Typ des Roboters zu bestimmen
+	 * @param auswahl Bei 1 wird ein R2D2 erstellt, bei 2 ein C3PO.
-	 * @return id vom Roboter
+	 * @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.
+	 * Ruft die Methode roboterZustand(id) in der RobotFactory auf
-	 * @param id vom Roboter
+	 * 
-	 * @return gibt den Zustand zurück
+	 * @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;