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

Javadoc wurde geschrieben.

master
nikow 2023-01-07 23:53:18 +01:00
parent 87815a7318
commit 40ed734a79
8 changed files with 318 additions and 65 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

36
Roboterfabrik/src/Domäne/C3PO.java
View File

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

38
Roboterfabrik/src/Domäne/Nexus6.java
View File

@ -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() {

31
Roboterfabrik/src/Domäne/R2D2.java
View File

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

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

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

6
Roboterfabrik/src/Domäne/RobotType.java
View File

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

56
Roboterfabrik/src/Domäne/Roboter.java
View File

@ -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();
}

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

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

80
Roboterfabrik/src/ui/Factory.java
View File

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