From 40ed734a796f167469ab3aaeb7488c4995c29df7 Mon Sep 17 00:00:00 2001 From: nikow Date: Sat, 7 Jan 2023 23:53:18 +0100 Subject: [PATCH] Javadoc wurde geschrieben. --- Roboterfabrik/src/Domäne/C3PO.java | 36 +++++++-- Roboterfabrik/src/Domäne/Nexus6.java | 38 ++++++++-- Roboterfabrik/src/Domäne/R2D2.java | 31 ++++++-- Roboterfabrik/src/Domäne/RobotFactory.java | 83 ++++++++++++++++++--- Roboterfabrik/src/Domäne/RobotType.java | 6 +- Roboterfabrik/src/Domäne/Roboter.java | 56 +++++++++++--- Roboterfabrik/src/facade/Factorysystem.java | 53 +++++++++++-- Roboterfabrik/src/ui/Factory.java | 80 ++++++++++++++++---- 8 files changed, 318 insertions(+), 65 deletions(-) diff --git a/Roboterfabrik/src/Domäne/C3PO.java b/Roboterfabrik/src/Domäne/C3PO.java index 3688046..1d31ebd 100644 --- a/Roboterfabrik/src/Domäne/C3PO.java +++ b/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; } diff --git a/Roboterfabrik/src/Domäne/Nexus6.java b/Roboterfabrik/src/Domäne/Nexus6.java index 0819956..b447aa6 100644 --- a/Roboterfabrik/src/Domäne/Nexus6.java +++ b/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() { diff --git a/Roboterfabrik/src/Domäne/R2D2.java b/Roboterfabrik/src/Domäne/R2D2.java index 8ea29b1..acb3e95 100644 --- a/Roboterfabrik/src/Domäne/R2D2.java +++ b/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; } diff --git a/Roboterfabrik/src/Domäne/RobotFactory.java b/Roboterfabrik/src/Domäne/RobotFactory.java index e88546b..c6084d4 100644 --- a/Roboterfabrik/src/Domäne/RobotFactory.java +++ b/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); } diff --git a/Roboterfabrik/src/Domäne/RobotType.java b/Roboterfabrik/src/Domäne/RobotType.java index 60af515..749d47b 100644 --- a/Roboterfabrik/src/Domäne/RobotType.java +++ b/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 } diff --git a/Roboterfabrik/src/Domäne/Roboter.java b/Roboterfabrik/src/Domäne/Roboter.java index a53d369..eb5d5a4 100644 --- a/Roboterfabrik/src/Domäne/Roboter.java +++ b/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(); } diff --git a/Roboterfabrik/src/facade/Factorysystem.java b/Roboterfabrik/src/facade/Factorysystem.java index 25ae7bf..afb0875 100644 --- a/Roboterfabrik/src/facade/Factorysystem.java +++ b/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; diff --git a/Roboterfabrik/src/ui/Factory.java b/Roboterfabrik/src/ui/Factory.java index ba11e68..074ca7a 100644 --- a/Roboterfabrik/src/ui/Factory.java +++ b/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 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)); }