my changes

domain/C3PO.java

@@ -6,25 +6,15 @@ import utility.robot_exceptions.robotExceptions;
 
 public class C3PO extends Robot {
    public C3PO(int id, String name){
-      super(id, name, "C3PO");
+      super(id, name, RobotType.C3PO);
 
    }
-
-/*   public String ausgabe(int[] input) throws RobotException{
-      if(input.length != 0 && !checkArray(input)){
-         return Arrays.stream(input)
-                 .mapToObj(Integer::toString)
-                 .collect(Collectors.joining("; "));
-      }else{
-         throw new RobotException(robotExceptions.MAGICVALUE, getName());
-        // throw new RobotMagicValueException(getName()  + " has an unknown Error. Code 42.");
-      }
-   }*/
+   //returns the sorted list as String with the delimiter ';'
    @Override
    public String speak(int[] input) throws RobotException {
       if(isPowerOn()){
          try{
-            return ausgabe(input, ";");
+            return output(input, ";");
          }catch(RobotException re){
             return re.toString();
          }
@@ -33,16 +23,6 @@ public class C3PO extends Robot {
          this.exceptions = new ExceptionStorage(robotException);
          throw robotException;
       }
-
-   }
-
-   public int[] sorting(int[] input) throws RobotException{
-         if(checkArray(input)){
-            return insertionSort(input);
-         }else{
-            throw new RobotException(robotExceptions.MAGICVALUE, getName());
-            //throw new RobotMagicValueException(getName() + " has an unknown error. Code 42");
-         }
    }
 
    /**
@@ -67,12 +47,11 @@ public class C3PO extends Robot {
       }
 
    }
-
+   //Sorting then returning the input arr with insertion Sort
    @Override
    public int[] think(int[] input) throws RobotException {
-      //Insertionsort
       if(isPowerOn()){
-         return sorting(input);
+         return insertionSort(input);
       }else{
          RobotException robotException = new RobotException(robotExceptions.ILLEGALSTATE, getName());
          this.exceptions = new ExceptionStorage(robotException);

domain/Factory.java

@@ -5,6 +5,7 @@ import java.util.Collection;
 import java.util.HashMap;
 
 public class Factory implements Serializable {
+
     private HashMap<Integer, Robot> robots = new HashMap<>();
     private int c3poID = 0;
     private int r2d2ID = 10000;
@@ -14,24 +15,35 @@ public class Factory implements Serializable {
     }
 
     //Has to return Collection<Robot>
-    public Collection<Robot> getRobotList(){
+    public Collection<Robot> robotListToCollection(){
             return robots.values();
         }
 
+    //return a String arr with robot attributes
+    public String[] getRobotList() {
+        Collection<Robot> collect = robotListToCollection();
+        String[] list = new String[collect.size()];
+        int i = 0;
+        for(Robot r: collect){
+            list[i++] = r.toString();
+        }
+        return list;
+    }
+    //creates a new robot
     public boolean buildNewRobot(String name, int type){
         Robot r ;
-        if(type == 0){
+        if(type == 0) {
             r = new R2D2(r2d2ID++, name);
-        }else if(type == 1){
+        } else if(type == 1) {
             r = new C3PO(c3poID++, name);
-        }else{
+        } else {
             return false;
         }
 
         robots.put(r.getId(), r);
         return true;
     }
-
+    //returns a specific robot via id
     public Robot getRobotOfList(int id){
         return robots.get(id);
         }

domain/Nexus6.java

@@ -16,13 +16,14 @@ public final class Nexus6 extends Robot {
         return INSTANCE;
     }
 
+    //This method always throws an Illegalstate exception
     @Override
     public String speak(int[] numbers) throws RobotException {
         RobotException e = new RobotException(robotExceptions.ILLEGALSTATE, getName());
         this.exceptions = new ExceptionStorage(e);
         throw e;
     }
-
+    //This method always throws an Illegalstate exception
     @Override
     public int[] think(int[] numbers) throws RobotException {
         RobotException e = new RobotException(robotExceptions.ILLEGALSTATE, getName());

domain/R2D2.java

@@ -7,18 +7,16 @@ import utility.robot_exceptions.robotExceptions;
 
 public class R2D2 extends Robot  {
    /**
-    *
     * @param id> int
     * @param name> String
     */
    public R2D2(int id, String name){
-      super(id, name, "R2D2");
+      super(id, name, RobotType.R2D2);
    }
 
-
-
    /**
     * @see utility.interfaces.RobotInstructions
+    * Sorting then returning the input arr with selection sort
     */
    public int[] think(int[] input) throws RobotException {
       if(isPowerOn()){
@@ -44,7 +42,6 @@ public class R2D2 extends Robot  {
             for(int j = i + 1; j < input.length; j++){
                if(input[j] < input[small]){
                   small = j;
-//                  System.out.println(small);
                }
             }
             int temp = input[i];
@@ -57,17 +54,16 @@ public class R2D2 extends Robot  {
          this.exceptions = new ExceptionStorage(robotexception);
          throw robotexception;
       }
-
    }
 
-
    /**
     * @see utility.interfaces.RobotInstructions
+    * returns the sorted list as String with the delimiter ','
     */
    @Override
    public String speak(int[] input) throws RobotException {
       if (isPowerOn()) {
-            return ausgabe(input, ";");
+            return output(input, ",");
       } else {
          RobotException robotexception = new RobotException(robotExceptions.ILLEGALSTATE, getName());
          this.exceptions = new ExceptionStorage(robotexception);

domain/Robot.java

@@ -10,14 +10,18 @@ import java.util.stream.Collectors;
 
 
 public abstract class Robot implements utility.interfaces.Robot, Serializable {
+   // ENUMS für Robot Type
+   static enum RobotType {
+      C3PO, R2D2, Nexus6;
+   }
    protected ExceptionStorage exceptions;
    private int id;
    private final String name;
    private boolean power;
 
-   private String type;
+   private RobotType type;
 
-   public Robot(int id, String name, String type){
+   public Robot(int id, String name, RobotType type){
       this.id = id;
       this.name = name;
       this.power = false;
@@ -46,11 +50,7 @@ public abstract class Robot implements utility.interfaces.Robot, Serializable {
     */
    @Override
    public void triggerPowerSwitch() {
-      if(power){
-         power = false;
-      }else{
-         power = true;
-      }
+      power = !power;
    }
 
    /**
@@ -79,6 +79,8 @@ public abstract class Robot implements utility.interfaces.Robot, Serializable {
     * @return boolean
     * @throws RobotException EMPTYARRAY Exception
     */
+
+   // Check lists for the forbidden Number 42
    public boolean checkArray(int[] input) throws RobotException{
       if(input.length != 0){
          for(int x: input){
@@ -89,11 +91,8 @@ public abstract class Robot implements utility.interfaces.Robot, Serializable {
          RobotException robotexception = new RobotException(robotExceptions.EMPTYARRAY, getName());
          this.exceptions = new ExceptionStorage(robotexception);
          throw robotexception;
-
       }
-
    }
-
    /**
     * This method uses Streams to join any given array to a String.
     * @param input int [ ]
@@ -101,7 +100,9 @@ public abstract class Robot implements utility.interfaces.Robot, Serializable {
     * @return String (array as String)
     * @throws RobotException
     */
-   public String ausgabe(int[] input, String delemiter)throws RobotException{
+
+   // Write an array with a delimiter to the command line
+   public String output(int[] input, String delemiter)throws RobotException{
       if(checkArray(input)) {
          return Arrays.stream(input)
                  .mapToObj(Integer::toString)
@@ -112,14 +113,11 @@ public abstract class Robot implements utility.interfaces.Robot, Serializable {
          throw robotexception;
       }
    }
-
-
-
-
    public String getType(){
-      return this.type;
+      return this.type.toString();
    }
 
+   // Override the to String method to get a clean looking outcome
    @Override
    public String toString(){
       return "Name: " + name + "; ID: " + id + "; Type: " + type;

domain/RobotType.java

@@ -0,0 +1,16 @@
+package domain;
+
+public enum RobotType {
+    R2D2("R2D2"),
+    C3PO("C3PO"),
+    NEXUS6("Nexus-6");
+
+    private final String type;
+    private RobotType(String type){
+        this.type = type;
+}
+   @Override
+   public String toString(){
+        return "Type: " + type;
+   }
+}

facade/FactorySystem.java

@@ -1,7 +1,8 @@
 package facade;
 
-import java.util.Collection;
-import domain.*;
+import domain.Factory;
+import domain.Robot;
+
 import infrastructure.Persistenz;
 
 public class FactorySystem {
@@ -25,17 +26,12 @@ public class FactorySystem {
 
     }
 
+    //provide robot attributes
     public String[] getAllRobots(){
-        Collection<Robot> robots = factory.getRobotList();
-        String[] list = new String[robots.size()];
-        int i = 0;
-        for(Robot r: robots){
-            list[i++] = r.toString();
+        return factory.getRobotList();
     }
-        return list;
-    }
-
-    public boolean buildNewRobot(String name, int type){
+    //Creating a new robot
+    public boolean buildNewRobot(String name, int type) {
         boolean check = factory.buildNewRobot(name, type);
         if(check) {
             try {
@@ -46,7 +42,7 @@ public class FactorySystem {
         }
         return check;
     }
-
+    //provides a specific robot
     public Robot searchForRobot(int id){
         return factory.getRobotOfList(id);
     }

ui/UI.java

@@ -1,13 +1,10 @@
 package ui;
 
-import domain.C3PO;
-import domain.Nexus6;
-import domain.R2D2;
+
+
 import domain.Robot;
 import facade.FactorySystem;
 import infrastructure.Persistenz;
-
-import java.sql.SQLOutput;
 import java.util.Scanner;
 
 public class UI {
@@ -26,14 +23,13 @@ public class UI {
        if(Persistenz.existsSavedData(name)){
            try{
                this.fs = (FactorySystem) Persistenz.loadFactoryData(name);
-           }catch(Exception e){
-
+           }catch(Exception ignored){
            }
        }else{
            this.fs = new FactorySystem(name);
        }
     }
-
+    //starting screen
     private void hauptmenü() {
         mainloop:
         while(true){
@@ -45,6 +41,7 @@ public class UI {
             System.out.println("-3- ------- use robot ------");
             System.out.println("-4- --------- Exit ---------");
             System.out.print(" > ");
+            //User options
             try{
                 int input = Integer.parseInt(sc.nextLine());
                 switch(input){
@@ -56,15 +53,13 @@ public class UI {
                     default:
                         System.out.println("this is an invalid option"); break;
                 }
-
             }catch(NumberFormatException e){
                 System.out.println("invalid input");
             }
         }
-
         System.out.println("Good Bye");
     }
-
+    //display all existing robots
     private void listAllRobots(){
         String[] listOfAll = fs.getAllRobots();
         if(listOfAll.length > 0){
@@ -75,9 +70,8 @@ public class UI {
         }else{
             System.out.println("There are no robots yet.");
         }
-
     }
-
+    //create a new robot
     private void buildNewRobot(){
         System.out.println("What shall the name of the robot be?");
         System.out.print(" > ");
@@ -85,25 +79,24 @@ public class UI {
         System.out.println("Which type of robot do u want?");
         System.out.println(" [0] for R2D2 and [1] for C3PO");
         System.out.print(" > ");
+        //user enters which type of robot he wants
         int type = Integer.parseInt(sc.nextLine());
         if(fs.buildNewRobot(name, type)){
-            switch(type){
-                case 0:
-                    //Created new Robot of type R2D2 with the name
-                    System.out.println("Created new Robot of type R2D2 with the name " + name );break;
-                case 1:
-                    System.out.println("Created new Robot of type C3PO with the name " + name );break;
+            switch (type) {
+                case 0 -> System.out.println("Created new Robot of type R2D2 with the name " + name);
+                case 1 -> System.out.println("Created new Robot of type C3PO with the name " + name);
             }
         }else{
             System.out.println("Anlegen des Roboters fehlgeschlagen");
         }
     }
-
+    //let the robots sort
     private void useRobot(){
         System.out.println("Which robot do you want to use?");
         listAllRobots();
         System.out.print(" ID > ");
         int input = Integer.parseInt(sc.nextLine());
+        // Change the searchForRobot Methode (safety)
         Robot r = fs.searchForRobot(input);
         System.out.println("You choose " + r.getName() + " of type " + r.getType());
         System.out.println("Yout have following options");

utility/robot_exceptions/ExceptionStorage.java

@@ -24,13 +24,4 @@ public class ExceptionStorage implements Serializable {
         return this.message;
     }
 
-    /*public boolean emptyErrorStorage(){
-        if(this.message != ""){
-            this.message = "";
-            this.date = LocalDateTime.now();
-            return true;
-        }else{return false;}
-
-    }*/
-
 }

utility/robot_exceptions/RobotException.java

@@ -15,6 +15,7 @@ public class RobotException extends Exception{
    }
 
    @Override
+   // länge auffüllen für ebene Liste
    public String toString(){
       return getMessage(this.currentType, this.name);
    }