Corrected/Optimised/Cleaned up Code, wrote most of the comments

domain/C3PO.java

@@ -9,22 +9,12 @@ public class C3PO extends Robot {
       super(id, name, "C3PO");
 
    }
-
+   //returns the sorted list as String with the delimiter ';'
-/*   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.");
-      }
-   }*/
    @Override
    public String speak(int[] input) throws RobotException {
       if(isPowerOn()){
          try{
-            return ausgabe(input, ";");
+            return output(input, ";");
          }catch(RobotException re){
             return re.toString();
          }
@@ -33,18 +23,8 @@ 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");
-         }
-      }
-
    /**
     * Sorts any given array of integers with the insertion Sort algorithm.
     * @param input int [ ]
@@ -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

@@ -19,6 +19,7 @@ public class Factory implements Serializable {
             return robots.values();
         }
 
+    //return a String arr with robot attributes
     public String[] getRobotList() {
         Collection<Robot> collect = robotListToCollection();
         String[] list = new String[collect.size()];
@@ -28,21 +29,22 @@ public class Factory implements Serializable {
         }
         return list;
     }
-        public boolean buildNewRobot(String name, int type){
+    //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){
+    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,7 +7,6 @@ import utility.robot_exceptions.robotExceptions;
 
 public class R2D2 extends Robot  {
    /**
-    *
     * @param id> int
     * @param name> String
     */
@@ -15,10 +14,9 @@ public class R2D2 extends Robot  {
       super(id, name, "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,9 +10,13 @@ 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 String name;
+   private final String name;
    private boolean power;
 
    private String type;
@@ -46,11 +50,7 @@ public abstract class Robot implements utility.interfaces.Robot, Serializable {
     */
    @Override
    public void triggerPowerSwitch() {
-      if(power){
+      power = !power;
-         power = false;
-      }else{
-         power = true;
-      }
    }
 
    /**
@@ -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;
    }
 
+   // Override the to String method to get a clean looking outcome
    @Override
    public String toString(){
       return "Name: " + name + "; ID: " + id + "; Type: " + type;

facade/FactorySystem.java

@@ -25,11 +25,12 @@ public class FactorySystem {
 
     }
 
+    //provide robot attributes
     public String[] getAllRobots(){
         return factory.getRobotList();
     }
-
+    //Creating a new robot
-    public boolean buildNewRobot(String name, int type){
+    public boolean buildNewRobot(String name, int type) {
         boolean check = factory.buildNewRobot(name, type);
         if(check) {
             try {
@@ -40,7 +41,7 @@ public class FactorySystem {
         }
         return check;
     }
-
+    //provides a specific robot
     public Robot searchForRobot(int id){
         return factory.getRobotOfList(id);
     }

ui/UI.java

@@ -1,12 +1,8 @@
 package ui;
 
-import domain.C3PO;
-import domain.R2D2;
 import domain.Robot;
 import facade.FactorySystem;
 import infrastructure.Persistenz;
-
-import java.sql.SQLOutput;
 import java.util.Scanner;
 
 public class UI {
@@ -25,14 +21,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){
@@ -44,6 +39,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){
@@ -55,15 +51,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){
@@ -74,9 +68,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(" > ");
@@ -84,25 +77,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){
+            switch (type) {
-                case 0:
+                case 0 -> System.out.println("Created new Robot of type R2D2 with the name " + name);
-                    //Created new Robot of type R2D2 with the name
+                case 1 -> System.out.println("Created new Robot of type C3PO with the name " + 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;
             }
         }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");