Javadoc wurde geschrieben.

Roboterfabrik/src/Domäne/C3PO.java

@@ -4,6 +4,13 @@ import tpe.exceptions.roboter.exceptions.RobotException;
 import tpe.exceptions.roboter.exceptions.RobotIllegalStateException;
 import tpe.exceptions.roboter.exceptions.RobotMagicValueException;
 
+/**
+ * 
+ * Die Klasse C3PO erbt von Roboter.
+ * @param name wie der Roboter heißen soll.
+ * @param id eine zufällig vergebene Zahl zwischen 9999-19999.
+ *
+ */
 public class C3PO extends Roboter {
 	private int id;
 	private RobotType robotType;
@@ -13,16 +20,24 @@ public class C3PO extends Roboter {
 		this.robotType = RobotType.C3PO;
 		this.id = id;
 	}
-
+	/**
+	 * @see RobotControl#getid(int)
+	 */
 	@Override
 	public int getId() {
 		return id;
 	}
-
+	/**
+	 * @see RobotInstructions#think(int[])
+	 * @throws RobotIllegalStateException wenn der Roboter ausgeschaltet ist.
+	 */
 	@Override
 	public int[] think(int[] zahlen) throws RobotException {
 		int remember;
-
+		/**
+		 * hier wird geschaut ob zahlen die Zahl 42 enthält, wenn true
+		 * wird eine RobotMagicException geworfen.
+		 */
 		if (isPowerOn() == true) {
 			for (int zahl : zahlen) {
 				if (zahl == 42) {
@@ -30,11 +45,17 @@ public class C3PO extends Roboter {
 					throw fehler;
 				}
 			}
-
+			/**
+			 * hier werden die Zahlen absteigend mit dem InsertionSort sortiert.
+			 * hier wird immer die nächste Zahl im Array angeschaut.
+			 */
 			for (int i = 1; i < zahlen.length; i++) {
 				remember = zahlen[i];
 				int k = i;
-
+				/**
+				 * hier wird die Zahl solange nach links getauscht bis die Zahl links nicht mehr kleiner
+				 * ist als die Zahl rechts, oder die Zahl ganz links ist.
+				 */
 				while (k > 0 && zahlen[k - 1] < remember) {
 					zahlen[k] = zahlen[k - 1];
 					k--;
@@ -47,7 +68,10 @@ public class C3PO extends Roboter {
 		throw fehler;
 
 	}
-
+	/**
+	 * @see Roboter#getRobotType(RoboType)
+	 * @return roboTyoe 
+	 */
 	public RobotType getRobotType() {
 		return this.robotType;
 	}

Roboterfabrik/src/Domäne/Nexus6.java

@@ -2,7 +2,10 @@ package Domäne;
 
 import tpe.exceptions.roboter.exceptions.RobotException;
 import tpe.exceptions.roboter.exceptions.RobotIllegalStateException;
-
+/**
+ * Die Klasse Nexus6 hat ein einziges Objekt namens Pris
+ * Pris ist defekt und hat immer die gleiche id:19281982
+ */
 public class Nexus6 extends Roboter {
 
 	private String name;
@@ -16,7 +19,12 @@ public class Nexus6 extends Roboter {
 		robotType = RobotType.NEXUS6;
 
 	}
-
+	/**
+	 * Falls es noch kein Objekt gibt wird eins erzeugt.
+	 * Besteht jedoch schon ein Objekt, so wird das Objekt zurückgegeben
+	 * und kein neues erzeugt.
+	 * @return Pris 
+	 */
 	public static Nexus6 getInstance() {
 		if (PRIS == null) {
 			PRIS = new Nexus6();
@@ -24,18 +32,28 @@ public class Nexus6 extends Roboter {
 		}
 		return PRIS;
 	}
-
+	/**
+	 * @see RobotControl#triggerPowerSwitch()
+	 * hier bleibt jedoch power immer auf false
+	 */
 	@Override
 	public void triggerPowerSwitch() {
 		power = false;
 	}
-
+	/**
+	 * @see RobotControl#getID(int)
+	 * gibt immer die gleiche id zurück: 19281982
+	 */
 	@Override
 	public int getId() {
 		return id;
 	}
 
-	// Methode soll Fehler ausgeben, da der Roboter nicht Funktioniert.
+	/**
+	 * @see RobotInstructions#speak(String)
+	 * @throws RobotIllegalStateException
+	 * Methode soll Fehler ausgeben, da der Roboter nicht Funktioniert.
+	 */
 	@Override
 	public String speak(int[] zahlen) throws RobotException {
 		fehler = new RobotIllegalStateException("Roboter ausgeschaltet und Defekt!", this.name);
@@ -43,14 +61,20 @@ public class Nexus6 extends Roboter {
 
 	}
 
-	// Methode soll Fehler ausgeben, da der Roboter nicht Funktioniert.
+	/**
+	 * @see RoboInstructions
+	 * @throws RobotIllegalStateException
+	 * Methode soll Fehler ausgeben, da der Roboter nicht Funktioniert.
+	 */
 	@Override
 	public int[] think(int[] zahlen) throws RobotException {
 		fehler = new RobotIllegalStateException("Roboter ausgeschaltet und Defekt!", this.name);
 		throw fehler;
 
 	}
-
+	/**
+	 * @see Roboter#getRobotType(robotType)
+	 */
 	@Override
 	public RobotType getRobotType() {
 

Roboterfabrik/src/Domäne/R2D2.java

@@ -3,7 +3,13 @@ package Domäne;
 import tpe.exceptions.roboter.exceptions.RobotException;
 import tpe.exceptions.roboter.exceptions.RobotIllegalStateException;
 import tpe.exceptions.roboter.exceptions.RobotMagicValueException;
-
+/**
+ * 
+ * Die Klasse R2D2 erbt von Roboter.
+ * @param name wie der Roboter heißen soll.
+ * @Param id eine zufällig vergebene Zahl zwischen 0-9999.
+ *
+ */
 public class R2D2 extends Roboter {
 	private int id;
 	private RobotType robotType;
@@ -13,9 +19,15 @@ public class R2D2 extends Roboter {
 		this.robotType = RobotType.R2D2;
 		this.id = id;
 	}
-
+	/**
+	 * @see RobotInstructions#think(int[])
+	 * @throws RobotIllegalStateException wenn der Roboter ausgeschaltet ist.
+	 */
 	@Override
 	public int[] think(int[] zahlen) throws RobotException {
+		/**
+		 * Falls zahlen die Zahl 42 enthält, wird eine RobotMagicValueException geworfen.
+		 */
 		if (isPowerOn() == true) {
 			for (int zahl : zahlen) {
 				if (zahl == 42) {
@@ -23,7 +35,12 @@ public class R2D2 extends Roboter {
 					throw fehler;
 				}
 			}
-
+			/**
+			 * Hier werden die Zahlen aufsteigend mit dem SelectionSort sortiert.
+			 * Hier wird immer die nächst kleinere Zahl gesucht.
+			 * ist i(die Zahl links) größer als k(die Zahl rechts), 
+			 * so werden beide Zahlen getauscht.
+			 */
 			for (int i = 0; i < zahlen.length - 1; i++) {
 				for (int k = i + 1; k < zahlen.length; k++) {
 					if (zahlen[i] > zahlen[k]) {
@@ -39,12 +56,16 @@ public class R2D2 extends Roboter {
 			fehler = new RobotIllegalStateException("Roboter ausgeschaltet! Bitte einschalten.", this.name);
 		throw fehler;
 	}
-
+	/**
+	 * @see RobotControl#getId(int)
+	 */
 	@Override
 	public int getId() {
 		return id;
 	}
-
+	/**
+	 * @see Roboter#getRobotType(robotType)
+	 */
 	public RobotType getRobotType() {
 		return this.robotType;
 	}

Roboterfabrik/src/Domäne/RobotFactory.java

@@ -3,7 +3,13 @@ package Domäne;
 import java.util.HashMap;
 
 import tpe.exceptions.roboter.exceptions.RobotException;
-
+/**
+ * 
+ * Schnittstelle zwischen Roboter und FactorySystem.
+ * hier wird auch das Objekt Pris erzeugt.
+ * RobotFactory hat eine HashMap wo die Roboter gelagert werden.
+ *
+ */
 public class RobotFactory {
 	private String name;
 	private Roboter pris = Nexus6.getInstance();
@@ -13,7 +19,13 @@ public class RobotFactory {
 		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.
+	 */
 	public int addRobot(RobotType robotType, String name) {
 		Roboter roboter;
 
@@ -29,15 +41,30 @@ public class RobotFactory {
 		} else
 			return -1;
 	}
-
+	/**
+	 * 
+	 * @return name um eventuell den Namen der RobotFactory zurückzugeben.
+	 */
 	public String getName() {
 		return name;
 	}
-
+	/**
+	 * gibt den gesuchten Roboter mit der passenden ID zurück.
+	 * @param id
+	 * @return Roboter objekt 
+	 */
 	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
+	 */
 	private int idVergeben(int min, int max) {
 
 		int randomValue = (int) (Math.random() * (max - min)) + min;
@@ -47,20 +74,36 @@ public class RobotFactory {
 
 		return randomValue;
 	}
-
+	/**
+	 * gibt anhand der ID den Zustand des Roboters zurück.
+	 * @param id
+	 * @return zustand vom Roboter
+	 */
 	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
+	 */
 	public boolean schalterAnAus(int id) {
 		Roboter r = findeRoboter(id);
 		r.triggerPowerSwitch();
 		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.
+	 */
 	public String aufrufSpeakAndThink(int id, int[] zahlen) throws RobotException {
 		Roboter r = findeRoboter(id);
 		int[] sotiert = r.think(zahlen);
@@ -68,12 +111,20 @@ 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
+	 */
 	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
+	 */
 	public String datenDesRoboters(int id) {
 		Roboter r = findeRoboter(id);
 		String robotType = r.getRobotType().toString();
@@ -83,11 +134,19 @@ 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
+	 */
 	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
+	 */
 	public boolean istDieserRoboterDa(int id) {
 		return roboterLager.containsKey(id);
 	}

Roboterfabrik/src/Domäne/RobotType.java

@@ -1,5 +1,9 @@
 package Domäne;
-
+/**
+ * 
+ * Hier sind die Typen die man bauen kann.
+ *
+ */
 public enum RobotType {
 	R2D2, C3PO, NEXUS6
 }

Roboterfabrik/src/Domäne/Roboter.java

@@ -7,14 +7,20 @@ import tpe.exceptions.roboter.exceptions.RobotException;
 import tpe.exceptions.roboter.exceptions.RobotIllegalStateException;
 import tpe.exceptions.roboter.exceptions.RobotMagicValueException;
 
+/**
+ * 
+ * Die Klasse Roboter implementiert Robot
+ *
+ */
 public abstract class Roboter implements Robot {
 
 	protected final String name;
 	protected boolean power;
 	protected RobotException fehler;
 
-	// Roboter wird in einem ausgeschalteten Zustand instanziiert!
+	/**
-
+	 * Roboter wird in einem ausgeschalteten Zustand instanziiert!
+	 */
 	Roboter(String name) {
 
 		this.name = name;
@@ -22,18 +28,24 @@ public abstract class Roboter implements Robot {
 
 	}
 
-	// gibt die ID des Roboters zurück
+	/**
+	 * @see RobotControl#getid(int)
+	 */
 	@Override
 	public abstract int getId();
 
-	// gibt den Namen des Roboters zurück
+	/**
+	 * @see RobotControl#getName(String)
+	 */
 	@Override
 	public String getName() {
 		return name;
 	}
 
-	// TrigerPowerSwitch dreht den Power zustand um, wenn er false ist wird er
+	/**
-	// eingeschaltet also true und umgekehrt
+	 * @see RobotControl#triggerPowerSwitch
+	 * der Zustand wird beim aufrufen zwischen true und false getauscht.
+	 */
 	@Override
 	public void triggerPowerSwitch() {
 		if (power == false)
@@ -44,7 +56,9 @@ public abstract class Roboter implements Robot {
 
 	}
 
-	// Zustand wird geprüft, ob der Roboter an ist.
+	/**
+	 * @see RobotControl#isPowerOn(boolean)
+	 */
 	@Override
 	public boolean isPowerOn() {
 		if (power == true)
@@ -53,13 +67,19 @@ public abstract class Roboter implements Robot {
 		else
 			return false;
 	}
-
+	/**
+	 * @see RobotControl#getLastException(RobotException)
+	 */
 	@Override
 	public RobotException getLastException() {
 
 		return fehler;
 	}
-
+	/**
+	 * @see RobotInstructions#speak(int)
+	 * @throws zahlen[] die Zahl 42 enthält, wird die RobotMagicValueException geworfen
+	 * 
+	 */
 	public String speak(int[] zahlen) throws RobotException {
 		if (isPowerOn() == true) {
 			for (int zahl : zahlen) {
@@ -73,7 +93,15 @@ public abstract class Roboter implements Robot {
 			fehler = new RobotIllegalStateException("Roboter ausgeschaltet! Bitte einschalten.", this.name);
 		throw fehler;
 	}
-
+	/**
+	 * Gibt die Zahlen als String zurück. Zwischen den Zahlen wird das richtige Trennzeichen verwendet
+	 * Die Methode erkennt das richtige Trennzeichen, indem es die erste Zahl mit der letzen Zahl vergleicht.
+	 * R2D2 sortiert die Zahlen aufsteigend, daher muss die erste Zahl kleiner als die letzte Zahl sein.
+	 * Bei C3PO ist es anders herum.
+	 * @param zahlen
+	 * @return String der die Zahlen mit Trennzeichen zurück gibt.
+	 * 
+	 */
 	private String prepare(int[] zahlen) {
 		StringBuilder sb = new StringBuilder();
 		if (zahlen[0] < zahlen[zahlen.length - 1]) {
@@ -87,9 +115,13 @@ public abstract class Roboter implements Robot {
 		return null;
 
 	}
-
+	/**
+	 * @see RobotInstructions#think(int[])
+	 */
 	@Override
 	public abstract int[] think(int[] zahlen) throws RobotException;
-
+	/**
+	 * gibt den Typ des Roboters zurück 
+	 */
 	public abstract RobotType getRobotType();
 }

Roboterfabrik/src/facade/Factorysystem.java

@@ -3,14 +3,25 @@ package facade;
 import Domäne.RobotFactory;
 import Domäne.RobotType;
 import tpe.exceptions.roboter.exceptions.RobotException;
-
+/**
+ * 
+ * Ist die Schnittstelle zwischen RobotFactory und Factory.
+ * Hier wird eine neue RobotFactory erzeugt
+ *
+ */
 public class Factorysystem {
 	private RobotFactory 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
+	 */
 	public int roboterAnlegen(String name, int auswahl) {
 		RobotType robottype;
 		if (auswahl == 1) {
@@ -25,29 +36,55 @@ public class Factorysystem {
 		return -1;
 
 	}
-
+	/**
+	 * Um den Zustand des Roboter zurückzugeben.
+	 * @param id vom Roboter
+	 * @return gibt den Zustand 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;

Roboterfabrik/src/ui/Factory.java

@@ -7,7 +7,12 @@ import javax.management.loading.PrivateClassLoader;
 
 import facade.Factorysystem;
 import tpe.exceptions.roboter.exceptions.RobotException;
-
+/**
+ * Hier ist die Ui für den User.
+ * Um Roboter zu Bauen und sie zu steuern.
+ * 
+ *
+ */
 public class Factory {
 	Scanner sc = new Scanner(System.in);
 	private Factorysystem factorysystem;
@@ -16,7 +21,11 @@ public class Factory {
 		this.factorysystem = factorysystem;
 		hauptmenü();
 	}
-
+	/**
+	 * Das Hauptmenü wo sich der User entscheiden kann
+	 * einen Roboter zu bauen oder einen auszuwählen um hin zu Steuern.
+	 * @throws RobotException
+	 */
 	private void hauptmenü() throws RobotException {
 		int input = 0;
 		mainloop: while (true) {
@@ -27,7 +36,11 @@ public class Factory {
 			System.out.println("2 -> Roboter auswählen");
 			System.out.println("9 -> Beenden");
 			System.out.println();
-
+			/**
+			 * Die While-Schleife mit dem try und catch Block dient dazu, 
+			 * um zu verhindern dass das Programm durch eine Fehleingabe aufhört.
+			 * 
+			 */
 			while (true) {
 				System.out.println("> ");
 				try {
@@ -56,7 +69,10 @@ public class Factory {
 
 		System.out.println("Programm beendet!");
 	}
-
+	/**
+	 * Hier wird der User gefragt welchen RoboterTyp und welchen Namen der 
+	 * Roboter haben soll. Fehleingaben oder Blank-Eingaben werden verhindert.
+	 */
 	private void roboterBauen() {
 		int auswahl;
 		String name;
@@ -70,7 +86,11 @@ public class Factory {
 				System.out.println("Bitte 1 oder 2 eingeben");
 			}
 		}
-
+		/**
+		 * hier wird verhinder, dass der User seinen Roboter nicht benennt.
+		 * Wenn die Eingabe nicht aus Blanks besteht, bricht die While-Schleife ab
+		 * und das Programm läuft weiter.
+		 */
 		while (true) {
 			System.out.println("Wie wollen Sie ihren Roboter nennen?");
 			name = sc.nextLine();
@@ -82,7 +102,13 @@ public class Factory {
 		System.out.println(name + " mit der Seriennummer: " + seriennummer + " wurde erstellt.");
 
 	}
-
+	/**
+	 * Führt zum nächsten Menü um den User den Roboter steuern zu lassen.
+	 * istDieserRoboterDa() überprüft ob die eingegebene Seriennummer einem Roboter gehört.
+	 * Ist das der Fall, wird die While-Schleife abgebrochen und das Programm läuft weiter.
+	 * ISt das nicht der Fall, wird der User zurück ins Hauptmenü geschickt.
+	 * @throws RobotException
+	 */
 	private void roboterAuswählen() throws RobotException {
 		int id;
 		while (true) {
@@ -135,12 +161,19 @@ public class Factory {
 			}
 		}
 	}
-
+	/**
+	 * Schaut ob der Roboter schon im Roboter Lager existiert.
+	 * @param id vom Roboter
+	 * @return istDa ob der Roboter da ist oder nicht.
+	 */
 	private boolean istDieserRoboterDa(int id) {
 		boolean istDa = factorysystem.istDieserRoboterDa(id);
 		return istDa;
 	}
-
+	/**
+	 * Um zu prüfen ob der Roboter An oder Aus ist.
+	 * @param id vom Roboter
+	 */
 	private void zustandAbfragen(int id) {
 		boolean zustand = factorysystem.zustandRoboter(id);
 		if (zustand == true) {
@@ -149,7 +182,11 @@ public class Factory {
 			System.out.println("Der Roboter ist aus!");
 		}
 	}
-
+	/**
+	 * Um den Roboter An oder Aus zuschalten.
+	 * Pris bleibt ausgeschaltet.
+	 * @param id vom Roboter
+	 */
 	private void schalterBetätigen(int id) {
 		boolean zustand = factorysystem.schalterBetätigen(id);
 		if (zustand == true) {
@@ -158,7 +195,13 @@ public class Factory {
 			System.out.println("Der Roboter wurde abgeschaltet!");
 		}
 	}
-
+	/**
+	 * Um den Roboter sprechen zu lassen.
+	 * User wird aufgefordert Zahlen einzugeben.
+	 * User wird gefragt ob er noch mehr Zahlen hinzufügen möchte.
+	 * Danach werden die Zahlen sortiert und mit dem richtigen Trennzeichen ausgegeben.
+	 * @param id vom Roboter
+	 */
 	private void sprechen(int id) {
 		ArrayList<Integer> zahlenHinzufügen = new ArrayList<>();
 		System.out.println("Geben Sie ein Array an!");
@@ -169,7 +212,10 @@ public class Factory {
 		boolean weiter = true;
 		int i = 2;
 		while (weiter) {
-
+			/**
+			 * Gibt der User etwas anderes außer j oder J ein,
+			 * werden die Zahlen per Stream dem Array hinzugefügt.
+			 */
 			System.out.println("Geben Sie die " + i + ". Zahl an");
 			zahl = Integer.parseInt(sc.nextLine());
 			zahlenHinzufügen.add(zahl);
@@ -188,7 +234,6 @@ public class Factory {
 					System.out.println("Ausgabe: " + ausgabe);
 				} catch (RobotException e) {
 					System.out.println("Fehler! Bitte den letzten Fehler auslesen!");
-					// e.printStackTrace();
 				}
 
 			}
@@ -196,12 +241,19 @@ public class Factory {
 		}
 
 	}
-
+	/**
+	 * Gibt die letzte Fehlermeldung vom Roboter aus.
+	 * @param id vom Roboter
+	 */
 	private void letzteFehlermeldung(int id) {
 		System.out.println(factorysystem.fehlerAuslesen(id));
 
 	}
-
+	/**
+	 * Gibt die Daten vom Roboter aus. 
+	 * RoboterTyp, Name und Seriennummer.
+	 * @param id vom Roboter
+	 */
 	private void datenAbruf(int id) {
 		System.out.println(factorysystem.roboterDaten(id));
 	}