pom.xml

 <project xmlns="http://maven.apache.org/POM/4.0.0" xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"
   xsi:schemaLocation="http://maven.apache.org/POM/4.0.0 http://maven.apache.org/maven-v4_0_0.xsd">
     <modelVersion>4.0.0</modelVersion>
-    <groupId>Projektarbeit</groupId>
-    <artifactId>Enigma</artifactId>
+    <groupId>projekt</groupId>
+    <artifactId>enigma</artifactId>
     <version>0.0.1</version>
     <properties>
         <project.build.sourceEncoding>UTF-8</project.build.sourceEncoding>
-        <maven.compiler.source>11</maven.compiler.source>
-        <maven.compiler.target>11</maven.compiler.target>
+        <!--region[useage]-->
+        <use.java.version>11</use.java.version>
+        <use.javafx.version>11.0.2</use.javafx.version>
+        <use.app.main.class>${project.groupId}.${project.artifactId}.Main</use.app.main.class>
+        <!--endregion[useage]-->
+        <maven.compiler.source>${use.java.version}</maven.compiler.source>
+        <maven.compiler.target>${use.java.version}</maven.compiler.target>
     </properties>
     <dependencies>
         <dependency>
             <groupId>org.openjfx</groupId>
             <artifactId>javafx-controls</artifactId>
-            <version>11.0.2</version>
+            <version>${use.javafx.version}</version>
         </dependency>
         <dependency>
             <groupId>org.openjfx</groupId>
             <artifactId>javafx-fxml</artifactId>
-            <version>11.0.2</version>
+            <version>${use.javafx.version}</version>
+        </dependency>
+        <!-- https://mvnrepository.com/artifact/net.sourceforge.plantuml/plantuml -->
+        <dependency>
+            <groupId>net.sourceforge.plantuml</groupId>
+            <artifactId>plantuml</artifactId>
+            <version>8059</version>
+        </dependency>
+        <!-- https://mvnrepository.com/artifact/org.xerial/sqlite-jdbc -->
+        <dependency>
+            <groupId>org.xerial</groupId>
+            <artifactId>sqlite-jdbc</artifactId>
+            <version>3.28.0</version>
+        </dependency>
+        <!-- https://mvnrepository.com/artifact/org.apache.httpcomponents/httpclient -->
+        <dependency>
+            <groupId>org.apache.httpcomponents</groupId>
+            <artifactId>httpclient</artifactId>
+            <version>4.5.10</version>
+        </dependency>
+        <!-- https://mvnrepository.com/artifact/org.json/json -->
+        <dependency>
+            <groupId>org.json</groupId>
+            <artifactId>json</artifactId>
+            <version>20190722</version>
+        </dependency>
+        <!-- https://mvnrepository.com/artifact/junit/junit -->
+        <dependency>
+            <groupId>junit</groupId>
+            <artifactId>junit</artifactId>
+            <version>4.12</version>
+            <scope>test</scope>
+        </dependency>
+        <!-- https://mvnrepository.com/artifact/org.controlsfx/controlsfx -->
+        <dependency>
+            <groupId>org.controlsfx</groupId>
+            <artifactId>controlsfx</artifactId>
+            <version>11.0.0</version>
         </dependency>
     </dependencies>
     <build>
@@ -28,15 +70,39 @@
                 <artifactId>maven-compiler-plugin</artifactId>
                 <version>3.8.0</version>
                 <configuration>
-                    <release>11</release>
+                    <release>${use.java.version}</release>
+                </configuration>
+            </plugin>
+
+            <plugin>
+                <artifactId>maven-assembly-plugin</artifactId>
+                <configuration>
+                    <appendAssemblyId>false</appendAssemblyId>
+                    <descriptorRefs>
+                        <descriptorRef>jar-with-dependencies</descriptorRef>
+                    </descriptorRefs>
+                    <archive>
+                        <manifest>
+                            <mainClass>${use.app.main.class}</mainClass>
+                        </manifest>
+                    </archive>
                 </configuration>
+                <executions>
+                    <execution>
+                        <phase>package</phase>
+                        <goals>
+                            <goal>attached</goal>
+                        </goals>
+                    </execution>
+                </executions>
             </plugin>
+
             <plugin>
                 <groupId>org.openjfx</groupId>
                 <artifactId>javafx-maven-plugin</artifactId>
                 <version>0.0.1</version>
                 <configuration>
-                    <mainClass>Enigma.App</mainClass>
+                    <mainClass>${use.app.main.class}</mainClass>
                 </configuration>
             </plugin>
         </plugins>

src/main/java/Enigma/App.java

-package Enigma;
-
-import javafx.application.Application;
-import javafx.fxml.FXMLLoader;
-import javafx.scene.Parent;
-import javafx.scene.Scene;
-import javafx.stage.Stage;
-
-import java.io.IOException;
-
-/**
- * JavaFX App
- */
-public class App extends Application {
-
-    private static Scene scene;
-
-    @Override
-    public void start(Stage stage) throws IOException {
-        scene = new Scene(loadFXML("primary"));
-        stage.setScene(scene);
-        stage.show();
-    }
-
-    static void setRoot(String fxml) throws IOException {
-        scene.setRoot(loadFXML(fxml));
-    }
-
-    private static Parent loadFXML(String fxml) throws IOException {
-        FXMLLoader fxmlLoader = new FXMLLoader(App.class.getResource(fxml + ".fxml"));
-        return fxmlLoader.load();
-    }
-
-    public static void main(String[] args) {
-        launch();
-    }
-
-}
\ No newline at end of file

src/main/java/Enigma/PrimaryController.java

-package Enigma;
-
-import java.io.IOException;
-import javafx.fxml.FXML;
-
-public class PrimaryController {
-
-    @FXML
-    private void switchToSecondary() throws IOException {
-        App.setRoot("secondary");
-    }
-}

src/main/java/Enigma/SecondaryController.java

-package Enigma;
-
-import java.io.IOException;
-import javafx.fxml.FXML;
-
-public class SecondaryController {
-
-    @FXML
-    private void switchToPrimary() throws IOException {
-        App.setRoot("primary");
-    }
-}
\ No newline at end of file

src/main/java/Enigma/model/DataFunk.java

-package Enigma.model;
-
-import java.io.IOException;
-import java.net.DatagramPacket;
-import java.net.DatagramSocket;
-import java.net.InetAddress;
-import java.net.MulticastSocket;
-
-public class DataFunk {
-	public int port = 12345;
-	public String mcIPStr = "224.0.0.1";
-
-	public void receive() throws IOException {
-		MulticastSocket mcSocket = null;
-		InetAddress mcIPAddress = null;
-		mcIPAddress = InetAddress.getByName(mcIPStr);
-		mcSocket = new MulticastSocket(port);
-		System.out.println("Multicast Receiver running at:" + mcSocket.getLocalSocketAddress());
-		mcSocket.joinGroup(mcIPAddress);
-
-		DatagramPacket packet = new DatagramPacket(new byte[1024], 1024);
-
-		System.out.println("Waiting for a  multicast message...");
-		mcSocket.receive(packet);
-		String msg = new String(packet.getData(), packet.getOffset(),
-				packet.getLength());
-		System.out.println("[Multicast  Receiver] Received:" + msg);
-
-		mcSocket.leaveGroup(mcIPAddress);
-		mcSocket.close();
-	}
-
-	public void send(String strSend) throws IOException {
-		DatagramSocket udpSocket = new DatagramSocket();
-
-		InetAddress mcIPAddress = InetAddress.getByName(mcIPStr);
-		byte[] msg = strSend.getBytes();
-		DatagramPacket packet = new DatagramPacket(msg, msg.length);
-		packet.setAddress(mcIPAddress);
-		packet.setPort(port);
-		udpSocket.send(packet);
-
-		System.out.println("Sent a  multicast message.");
-		System.out.println("Exiting application");
-		udpSocket.close();
-	}
-}

src/main/java/Enigma/model/Morsecode.java

-package Enigma.model;
-
-import java.util.TreeMap;
-
-public class Morsecode {
-	TreeMap<String, String> codeMap = new TreeMap<>();
-
-	/**
-	 * Im Konstruktor werden alle Notwendigen Zeichen und deren zugehöriger Codes, der Treemap hinzugefügt.
-	 */
-	public Morsecode() {
-		codeMap.put("A", "10110");
-		codeMap.put("B", "110101010");
-		codeMap.put("C", "1101011010");
-		codeMap.put("D", "1101010");
-		codeMap.put("E", "10");
-		codeMap.put("F", "101011010");
-		codeMap.put("G", "11011010");
-		codeMap.put("H", "10101010");
-		codeMap.put("I", "1010");
-		codeMap.put("J", "10110110110");
-		codeMap.put("K", "11010110");
-		codeMap.put("L", "101101010");
-		codeMap.put("M", "110110");
-		codeMap.put("N", "11010");
-		codeMap.put("O", "110110110");
-		codeMap.put("P", "1011011010");
-		codeMap.put("Q", "11011010110");
-		codeMap.put("R", "1011010");
-		codeMap.put("S", "101010");
-		codeMap.put("T", "110");
-		codeMap.put("U", "1010110");
-		codeMap.put("V", "101010110");
-		codeMap.put("W", "10110110");
-		codeMap.put("X", "1101010110");
-		codeMap.put("Y", "11010110110");
-		codeMap.put("Z", "1101101010");
-		codeMap.put("1", "10110110110110");
-		codeMap.put("2", "1010110110110");
-		codeMap.put("3", "101010110110");
-		codeMap.put("4", "10101010110");
-		codeMap.put("5", "1010101010");
-		codeMap.put("6", "11010101010");
-		codeMap.put("7", "110110101010");
-		codeMap.put("8", "1101101101010");
-		codeMap.put("9", "11011011011010");
-		codeMap.put("0", "110110110110110");
-		codeMap.put("KA", "1101011010110");
-		codeMap.put("AR", "101101011010");
-		codeMap.put("VE", "10101011010");
-		codeMap.put("SK", "10101011010110");
-	}
-
-	public void getCode(char sign) {
-
-	}
-}

src/main/java/module-info.java

-module Projektarbeit {
-    requires javafx.controls;
-    requires javafx.fxml;
-
-    opens Enigma to javafx.fxml;
-    exports Enigma;
-}
\ No newline at end of file

src/main/java/projekt/enigma/App.java

+package projekt.enigma;
+
+import javafx.application.Application;
+import javafx.fxml.FXMLLoader;
+import javafx.geometry.Insets;
+import javafx.scene.Scene;
+import javafx.scene.control.Button;
+import javafx.scene.control.Label;
+import javafx.scene.control.TextField;
+import javafx.scene.input.KeyCode;
+import javafx.scene.layout.VBox;
+import javafx.stage.Stage;
+import projekt.enigma.model.Fehler;
+
+import java.io.IOException;
+
+/**
+ * JavaFX App
+ * Startklasse fuer JavaFX Application, durch die Erweiterung um die Klasse Application.
+ * Baut die Benutzeroberflaeche in ihren Grundstrukturen auf.
+ */
+public class App extends Application {
+
+    /**
+     * Deklariert den GuiController.
+     */
+    private static GuiController gc;
+
+    /**
+     * debug : int : fuer die Funktion debug der Klasse Fehler notwendig.
+     */
+    private static int debug;
+
+    /**
+     * Startet die Klasse App und setzt den debug-Wert 1.
+     *
+     * @param args : String[] : Standard-Kommandozeilen-Argument.
+     */
+    public static void main(String[] args) {
+        debug = 0;
+        launch(args);
+    }
+
+    /**
+     * Gibt der Getter einen int > 0 zurueck, wird eine Meldung auf der Konsole ausgegeben.
+     *
+     * @return debug : int : bestimmt die Eingabe der debung-Methode in der Klasse Fehler.
+     */
+    public static int getDebug() {
+        return debug;
+    }
+
+    /**
+     * Initialisierung der Variablen fuer die JavaFX Scene Kenngruppe.
+     * Abfrage der Kenngruppe und Reaktion auf die Eingabe.
+     *
+     * @param primaryStage : Stage : Fenster zur Eingabe der Kenngruppe.
+     * @throws IOException : wird bei fehlerhafter Eingabe geworfen.
+     */
+    @Override
+    public void start(Stage primaryStage) throws IOException {
+        primaryStage.setTitle("Enigma");
+        primaryStage.setResizable(false);
+
+        Label lblEingbae = new Label("Bitte Kenngruppe eingeben!");
+        TextField tfEingabe = new TextField();
+        Button btnKenngruppe = new Button("Kenngruppe setzen!");
+        VBox layout = new VBox();
+        layout.setSpacing(10);
+        layout.setPadding(new Insets(20, 30, 10, 30));
+        btnKenngruppe.setMaxWidth(Double.MAX_VALUE);
+
+        // baut die Scene fuer die Kenngruppenabfrage auf
+        layout.getChildren().addAll(lblEingbae, tfEingabe, btnKenngruppe);
+        Scene sceKenngruppe = new Scene(layout);
+
+        // laden der FXML und der Enigma-Ansicht, um Ladezeiten zu verringern
+        FXMLLoader guiLoader = new FXMLLoader(App.class.getResource("gui.fxml"));
+        Scene sceApp = new Scene(guiLoader.load(), 962, 677);
+
+        /*Bestaetigen der Kenngruppe, Ausgabe einer Fehlermeldung im Fall einer falschen Eingabe und starten
+         des Enigma-Fensters */
+        tfEingabe.setOnKeyPressed(e -> {
+            if (e.getCode() == KeyCode.ENTER) {
+                if (enter(tfEingabe.getText())) {
+                    gc = guiLoader.getController();
+                    gc.setKenngruppe(tfEingabe.getText());
+                    primaryStage.setScene(sceApp);
+                } else {
+                    tfEingabe.setText("");
+                    new Fehler().showErrorDialog("error", "Kenngruppe falsch",
+                            "Regeln für die Kenngruppe: 4-8 Zeichen sowie nur Buchstaben von A-Z.");
+                }
+            }
+        });
+        btnKenngruppe.setOnAction(e -> {
+            if (enter(tfEingabe.getText())) {
+                gc = guiLoader.getController();
+                gc.setKenngruppe(tfEingabe.getText());
+                primaryStage.setScene(sceApp);
+            } else {
+                tfEingabe.setText("");
+                new Fehler().showErrorDialog("error", "Kenngruppe falsch",
+                        "Regeln für die Kenngruppe: 4-8 Zeichen sowie Buchstaben von A-Z.");
+            }
+        });
+        primaryStage.setScene(sceKenngruppe);
+        primaryStage.show();
+    }
+
+    /**
+     * Ueberprueft die Gueltigkeit der Kenngruppeneingabe.
+     * Nur Zeichen von A-Z sind zugelassen und die Kenngruppe muss aus mind. 4 und max. 8 Zeichen bestehen.
+     *
+     * @param kenngruppe : String : Eingabewert aus dem Fenster.
+     * @return result : boolean : ist die Kenngruppe ungueltig wird false zurueckgegeben, sonst true.
+     */
+    private boolean enter(String kenngruppe) {
+        String alphabet = "ABCDEFGHIJKLMNOPQRSTUVWXYZ";
+        boolean result = true;
+
+        for (char c : kenngruppe.toUpperCase().toCharArray()) {
+            if (!alphabet.contains(String.valueOf(c))) {
+                result = false;
+                break;
+            }
+        }
+        if ((kenngruppe.length() > 8) || (kenngruppe.length() < 4)) {
+            result = false;
+        }
+
+        return result;
+    }
+}

src/main/java/projekt/enigma/Main.java

+package projekt.enigma;
+
+/**
+ * Startpunkt des Programms. Startet die Klasse App und damit die GUI.
+ */
+public class Main {
+
+    /**
+     * Startet die App
+     *
+     * @param args : String[] : Standard-Kommandozeilen-Parameter.
+     */
+    public static void main(String[] args) {
+        App.main(args);
+    }
+}

src/main/java/projekt/enigma/database/DatenbankSqlite.java

+package projekt.enigma.database;
+
+import java.sql.*;
+
+/**
+ * Dies ist die SQLite Datenbank Klasse.
+ * In der SQLite Datei im Resources Ordner liegt das Codebuch welches benoetigt wird um die
+ * Nachrichten mit der Enigma zu ver/entschluesseln.
+ * Die Datenbank ist statisch und deshalb konnte sie im Resources Ordner hinterlegt werden.
+ * Für jeden Tag des Monats (1-31) ist ein eigener Eintrag enthalten welcher ueber die Funktion
+ * getCodebuch abgerufen werden kann.
+ * Zurueckgegeben wird ein Array welcher in der getCodebuch Funktion genauer dokumentiert ist.
+ */
+public class DatenbankSqlite {
+
+	/**
+	 * Verbindung zur SQLite Datenbank aufbauen.
+	 * Die Datei liegt in den Resources und aendert sich nicht,
+	 * weshalb der Pfad zu derselben fest hinterlegt ist.
+	 *
+	 * @return conn : Connection: statische Datenbankverbindung.
+	 */
+	private Connection connect() {
+		String url = "jdbc:sqlite::resource:projekt/enigma/codebuch.sqlite";
+		Connection conn = null;
+
+		try {
+			conn = DriverManager.getConnection(url);
+		} catch (SQLException e) {
+			e.printStackTrace();
+		}
+
+		return conn;
+	}
+
+	/**
+	 * Liest das Codebuch aus der SQLite Datenbank aus.
+	 * Dieser Funktion muss ein tag als int Wert uebergeben werden.
+	 * Anschließend wird eine Verbindung zur SQLite Datenbank aufgebaut und das Codebuch angefragt.
+	 * Dieses wird in ein Objekt vom Typ Codebuch gepackt und zurueckgegeben.
+	 *
+	 * Holt den heutigen Eintrag aus der SQLite Datenbank und erstellt daraus ein Codebuch Objekt.
+	 *
+	 * @param tag : int : Tag fuer welchen ein Codebuch benoetigt wird.
+	 * @return String : Die Einstellungen des angefragten Tages.
+	 * <p>
+	 *     String[0] : Tag
+	 *     String[1] : Walzenlage
+	 *     String[2] : Ringstellung
+	 *     String[3] : Steckverbindung
+	 * </p>
+	 */
+	public String[] getCodebuch(int tag) {
+		String[] codebuch = new String[4];
+
+		try {
+			Connection conn = this.connect();
+			PreparedStatement pstm = conn.prepareStatement("SELECT * FROM table_codebuch WHERE Tag = ? LIMIT 1");
+			pstm.setInt(1, tag);
+			ResultSet rs = pstm.executeQuery();
+
+			while (rs.next()) {
+				codebuch[0] = rs.getString("Tag");
+				codebuch[1] = rs.getString("Walzenlage");
+				codebuch[2] = rs.getString("Ringstellung");
+				codebuch[3] = rs.getString("Steckverbindung");
+			}
+		} catch (SQLException ignored) {}
+
+		return codebuch;
+	}
+}

src/main/java/projekt/enigma/model/Codebuch.java

+package projekt.enigma.model;
+
+import projekt.enigma.database.DatenbankSqlite;
+
+import java.time.LocalDate;
+import java.time.ZoneId;
+
+/**
+ * Das Codebuch war eines der essentiell wichtigen Sachen bei der Enigma.
+ * Jeder Enigma gehoerte auch ein Codebuch bei, welches notwendig war um die Nachrichten zu ver/entschluesseln.
+ * Im Codebuch standen für jeden Tag des Monats die notwendigen Einstellungen welche vorgenommen werden
+ * mussten, um die Texte zu ver/entschluesseln.
+ * Hiernach wurden die Walzen eingesetzt, die Ringe für den Ruecksprung der Walze gesetzt und deren Grundeinstellung
+ * vorgenommen.
+ * Bei der Enigma I, um welche es hier geht, gab es zusaetzlich ein Steckbrett, welches ebenfalls im Codebuch
+ * festgelegt war.
+ * <p>
+ * Dieses Codebuch enthaelt die Einstellungen eines Tages, welche mittels Getter und Setter
+ * verarbeitet werden koennen.
+ * <p>
+ * Zusaetzlich gibt es zu Debug-Zwecken eine ueberschriebene toString Funktion, welche das Objekt als String
+ * zurueckgeben kann.
+ */
+public class Codebuch {
+
+	//region Variablen
+	/**
+	 * tag : int : gibt den Tag eines Monats an.
+	 */
+	private int tag;
+
+	/**
+	 * walzenlage : int[] : legt die Positionen der drei Walzen fest.
+	 */
+	private int[] walzenlage;
+
+	/**
+	 * ringstellung : int[] : legt die Ringstellungen der drei Walzen fest.
+	 */
+	private int[] ringstellung;
+
+	/**
+	 * steckverbindung : char[][] : legt die Steckverbindungen im Steckbrett fest.
+	 */
+	private char[][] steckverbindung;
+
+	//endregion
+
+	//region Konstruktor
+	/**
+	 * Im Konstruktor werden die Standardwerte gesetzt.
+	 * <p>
+	 * walzenlage : int[3] :            Hier wird die Position der drei Walzen festgelegt.
+	 * ringstellung : char[3] :         Jede Walze hat einen Ring. Der Index steht fuer die Walze und der Value fuer
+	 * 									die Position des Ringes.
+	 * steckverbindung : char[10][] :   Zehn Kabel koennen in das Steckbrett gesteckt werden. In diesem Array werden
+	 * 									die Kabel mit ihren jeweiligen Buchsen hinterlegt.
+	 */
+	public Codebuch() {
+		this.walzenlage = new int[3];
+		this.ringstellung = new int[3];
+		this.steckverbindung = new char[10][];
+
+		for (int i = 0; i < 10; i++) {
+			this.steckverbindung[i] = new char[2];
+			this.steckverbindung[i][0] = 'A';
+			this.steckverbindung[i][1] = 'A';
+		}
+	}
+
+	//endregion
+
+	//region Funktionen & Methoden
+	/**
+	 * Holt den Tagesschluessel aus dem Codebuch ab. Ist kein Tag angegeben, wird der aktuelle Tag genutzt.
+	 * Aus dem Tagesschluessel werden die Werte fuer die Walzenlage, Ringstellung und Steckverbindung
+	 * gesetzt.
+	 *
+	 * @param tag : int[] : gibt keinen, einen Tag oder mehrere Tage mit.
+	 */
+	public void fetchTagesschluessel(int... tag) {
+		String[] walzenlage, ringstellung, db;
+
+		if (tag.length > 0) {
+			db = new DatenbankSqlite().getCodebuch(tag[0]);
+		} else {
+			db = new DatenbankSqlite().getCodebuch(LocalDate.now(ZoneId.of("Europe/Berlin")).getDayOfMonth());
+		}
+
+		this.setTag(Integer.parseInt(db[0]));
+
+		// setzen der Walzenlage, Ringstellung, Steckverbindung
+		walzenlage = db[1].split(",");
+		for (int i = 0; i < 3; i++) {
+			this.setWalzenlage(i, Integer.parseInt(walzenlage[i]));
+		}
+
+		ringstellung = db[2].split(",");
+		for (int i = 0; i < 3; i++) {
+			this.setRingstellung(i, Integer.parseInt(ringstellung[i]));
+		}
+
+		this.setSteckverbindung(db[3].split(","));
+	}
+
+	/**
+	 * Gibt die aktuelle Instanz des Codebuches als String zurueck.
+	 * Hierbei werden der Tag die Walzenlagen, Ring-/Grundstellung sowie die Steckverbindungen zurueckgegeben.
+	 *
+	 * @return String : String des gesamten Objektes.
+	 */
+	@Override
+	public String toString() {
+		StringBuilder sb = new StringBuilder();
+
+		// Tag des aktuellen Codebuch Eintrags
+		sb.append("Tag: ").append(this.getTag()).append("\n");
+
+		// In welchem Slot steckt die Walze?
+		sb.append("Walzenlage: ");
+		for (int wl : this.getWalzenlage()) {
+			sb.append(wl).append(",");
+		}
+		if (this.getWalzenlage().length > 0) {
+			sb.setLength(sb.length() - 1);
+		}
+		sb.append("\n");
+
+		// Die Ringstellung an den Walzen
+		sb.append("Ringstellung: ");
+		for (int rs : this.getRingstellung()) {
+			sb.append(rs).append(",");
+		}
+		if (this.getRingstellung().length > 0) {
+			sb.setLength(sb.length() - 1);
+		}
+		sb.append("\n");
+
+		// Das Steckbrett und wie die Kabel angeschlossen sind
+		sb.append("Steckverbindung: ");
+		for (char[] verbindung : this.getSteckverbindung()) {
+			sb.append(verbindung[0]).append(":").append(verbindung[1]).append(",");
+		}
+		if (this.getSteckverbindung().length > 0) {
+			sb.setLength(sb.length() - 1);
+		}
+		sb.append("\n");
+
+		return sb.toString();
+	}
+
+	//endregion
+
+	//region Setter
+	/**
+	 * Setzt die Steckverbindung dieser Instanz.
+	 *
+	 * @param kabel : String[] :  Die Steckverbindungen die gesteckt werden sollen.
+	 *              Jeder Eintrag im Array ist ein String mit zwei Zeichen.
+	 *              Diese werden in zwei chars zerlegt und anschließend im globalen Array gespeichert.
+	 */
+	private void setSteckverbindung(String[] kabel) {
+		int counter = 0;
+
+		for (String stecker : kabel) {
+			char[] verbindung = new char[2];
+			verbindung[0] = stecker.charAt(0);
+			verbindung[1] = stecker.charAt(1);
+			this.steckverbindung[counter++] = verbindung;
+		}
+	}
+
+	/**
+	 * Setzt die Walzenlage dieser Instanz.
+	 *
+	 * @param position   : int : Position der Walze.
+	 * @param walzenlage : int : Welche Walze wurde eingesetzt.
+	 */
+	private void setWalzenlage(int position, int walzenlage) {
+		this.walzenlage[position] = walzenlage;
+	}
+
+	/**
+	 * Setzt die Ringstellung dieser Instanz.
+	 *
+	 * @param position     : int : Auf welche Walze wird der Ring aufgesetzt?
+	 * @param ringstellung : int : An dieser Position soll die nächste Walze weiter gedreht werden.
+	 */
+	private void setRingstellung(int position, int ringstellung) {
+		this.ringstellung[position] = ringstellung;
+	}
+
+	/**
+	 * Setzt den Tag dieser Instanz.
+	 *
+	 * @param tag : int : Tag.
+	 */
+	void setTag(int tag) {
+		this.tag = tag;
+	}
+
+	//endregion
+
+	//region Getter
+	/**
+	 * Gibt den Tag dieser Instanz zurueck.
+	 *
+	 * @return int : Tag.
+	 */
+	public int getTag() {
+		return tag;
+	}
+
+	/**
+	 * Gibt die Walzenlage dieser Instanz zurueck.
+	 *
+	 * @return walzenlage : int[] : Walzenlage.
+	 */
+	public int[] getWalzenlage() {
+		return walzenlage;
+	}
+
+	/**
+	 * Gibt die Ringstellung dieser Instanz zurueck.
+	 *
+	 * @return ringstellung : int : Ringstellung.
+	 */
+	public int[] getRingstellung() {
+		return ringstellung;
+	}
+
+	/**
+	 * Gibt die Steckverbindungen dieser Instanz zurueck.
+	 *
+	 * @return steckerverbindung : char[][] : Steckverbindung.
+	 */
+	public char[][] getSteckverbindung() {
+		return this.steckverbindung;
+	}
+	//endregion
+}

src/main/java/projekt/enigma/model/Codierer.java

+package projekt.enigma.model;
+
+import java.io.IOException;
+import java.util.Calendar;
+import java.util.Random;
+
+/**
+ * Die Codierer-Klasse beschreibt den Benutzer, welcher die Enigma benutzt.
+ * Alle Vorgaenge, wie z.B. das zusammenbauen der Hardware, auslesen des Codebuches und das anschließende codieren,
+ * finden hier statt. Dieser ist quasi die Schnittstelle zwischen der GUI (Hauptmann, welcher ihm sagt was er zu
+ * verschluesseln hat), der Enigma und dem Funker im Funkraum, welcher die Nachricht im Anschluss versendet.
+ */
+public class Codierer {
+
+    //region Variablen
+    /**
+     * Der Spruchschluessel als Klartext zur Codierung der Nachricht.
+     */
+    private String spruchschluessel;
+
+    /**
+     * Der Spruchschluessel, mit den Tageswerten aus dem Codebuch, codiert.
+     */
+    private String spruchschluesselCodiert;
+
+    /**
+     * Die Kenngruppe fuer die die versendeten Nachrichten gedacht sind.
+     * Diese ist relevant fuer den Webservice (Funkraum).
+     */
+    private String kenngruppe;
+
+    /**
+     * Die Nachricht, welche der Benutzer eingibt, wird als String "nachricht" gespeichert
+     * und im Laufe der Benutzung ergaenzt.
+     */
+    private String nachricht;
+
+    /**
+     * Das Hardware-Objekt. Hier werden alle hardwarerelevanten Baugruppen gespeichert und verarbeitet.
+     */
+    private Hardware hardware;
+
+    /**
+     * Im Codebuch sind die Tageswerte zu finden. Ueber dieses Objekt kann darauf zugegriffen werden.
+     */
+    private Codebuch codebuch;
+    //endregion
+
+    //region Konstruktor
+
+    /**
+     * Der Konstruktor des Codierers.
+     * Hier werden die globalen Variablen auf ihre Standardwerte gesetzt sowie die Objekte initialisiert.
+     */
+    public Codierer(String kenngruppe) {
+        this.nachricht = "";
+        this.spruchschluessel = "";
+        this.spruchschluesselCodiert = "";
+        this.kenngruppe = kenngruppe;
+        this.codebuch = new Codebuch();
+
+        this.codebuch.fetchTagesschluessel();
+    }
+    //endregion
+
+    //region Funktionen & Methoden
+    //region Reset & Initialisieren
+
+    /**
+     * Hier lesen wir den heutigen Eintrag aus dem Codebuch aus und erstellen ein Codebuch-Objekt.
+     * Nach dem Codebuch werden dann die Ringe auf die Walzen gesteckt und die Walzen anschließend
+     * in die Hardware gebaut.
+     * <br>
+     * Ein Reflektor wird definiert, jedoch keine Werte zugewiesen, da wir nur einen besitzen und
+     * deshalb alle Einstellungen hierfuer statisch im Reflektor definiert haben.
+     * <br>
+     * Das Steckbrett wird ebenfalls definiert und die notwendigen Kabel eingesteckt nach dem heutigen
+     * Codebucheintrag.
+     */
+    private void initialisiereHardware() {
+        this.nachricht = "";
+
+        // Das Steckbrett initialisieren
+        Steckbrett sb = new Steckbrett();
+        char[][] verbinder = this.codebuch.getSteckverbindung();
+
+        // Für jedes Kabel eine Verbindung auf dem Steckbrett setzen
+        for (char[] kabel : verbinder) {
+            sb.setzeVertauschung(kabel[0], kabel[1]);
+        }
+
+        // Die Hardware aus dem Koffer holen (initialisieren)
+        this.hardware = new Hardware();
+
+        // Den Ring an der Walze anbringen und die Walze dann in die Hardware einsetzen
+        this.hardware.setWalzen(0, this.codebuch.getWalzenlage()[0], this.codebuch.getRingstellung()[0]);
+        this.hardware.setWalzen(1, this.codebuch.getWalzenlage()[1], this.codebuch.getRingstellung()[1]);
+        this.hardware.setWalzen(2, this.codebuch.getWalzenlage()[2], this.codebuch.getRingstellung()[2]);
+
+        // Der Hardware das gesetzte Steckbrett zuweisen
+        this.hardware.setSteckbrett(sb);
+
+        // Ein Reflektor-Objekt erstellen und der Hardware bekanntgeben
+        this.hardware.setReflektor(new Reflektor());
+    }
+
+    /**
+     * Setzt die Enigma auf die Einstellungen des aktuellen Tages, aus dem Codebuch zurueck.
+     */
+    public void resetHardware() {
+        this.initialisiereHardware();
+    }
+
+    /**
+     * Leert das Nachrichten-Objekt um eine neue Nachricht aufnehmen zu koennen.
+     */
+    private void resetNachricht() {
+        this.nachricht = "";
+    }
+    //endregion
+
+    //region Nachrichten handler
+
+    /**
+     * Befehl, die Nachricht an den Funker zu uebergeben.
+     *
+     * @throws IOException : Die Antwort konnte nicht gelesen werden.
+     */
+    public void sendeNachricht() throws IOException {
+        String kopf = this.generateKopf();
+        new Funkraum().sendeFunkspruch(new Morsecode().convertBuchstabeToMorsecode(kopf + this.nachricht),
+                this.kenngruppe);
+        this.nachricht = "";
+        this.resetHardware();
+    }
+
+    /**
+     * Gibt die letzte empfangene Nachricht zurueck.
+     * <br>
+     * nachricht[0]: String[]: Tag, an dem die Nachricht gesendet wurde.
+     * nachricht[1]: String[]: Die verschluesselte Nachricht von Morsecode in Buchstaben konvertiert.
+     * nachricht[2]: String[]: Nachricht im Klartext. Die Enigma Nachricht (nachricht[1]) mittels der
+     * Tageseinstellungen (nachricht[0]) decodiert.
+     */
+    public String[] empfangeNachricht() {
+        StringBuilder sb = new StringBuilder();
+        Morsecode mc = new Morsecode();
+        String[] nachricht = new String[3];
+
+        // Alte Nachrichten-Variable erstmal leeren
+        this.nachricht = "";
+
+        // Abrufen der letzten Nachricht, für unsere Kenngruppe, aus dem Funkraum
+        String[] codierteNachricht = new Funkraum().empfangeFunkspruch(this.kenngruppe);
+
+        // Prüfen ob Nachrichtenlänge > 1 und die codierte Nachricht mehr als drei Felder (" ") hat
+        if ((codierteNachricht[1] != null) && (codierteNachricht[1].split(" ").length > 3)) {
+            nachricht[0] = codierteNachricht[0];
+            nachricht[1] = mc.convertMorsecodeToBuchstabe(codierteNachricht[1]);
+            nachricht[2] = this.decodiere(nachricht[1], Integer.parseInt(nachricht[0]));
+
+            sb.append(nachricht[1], 0, 16);
+
+            for (int i = 17; i <= nachricht[1].length(); ) {
+                if ((i + 5) < nachricht[1].length()) {
+                    sb.append(nachricht[1], i, i + 5).append(" ");
+                    i += 5;
+                } else {
+                    sb.append(nachricht[1].substring(i));
+                    break;
+                }
+            }
+            nachricht[1] = sb.toString();
+        }
+
+        return nachricht;
+    }
+    //endregion
+
+    //region Generatoren
+
+    /**
+     * Hier wird ein neuer Spruchschluessel generiert.
+     * <p>
+     * Mit diesem werden die Walzen auf eine neue Startposition gestellt und dem Kopf, mit dem
+     * Tagesschluessel codiert, hinzugefuegt.
+     * <br>
+     * Hierfuer wird mittels der Funktion "randomBuchstabe" ein zufaelliger Buchstabe generiert,
+     * und ueberprueft, ob dieser bereits in der globalen Variable (this.spruchschluessel) vorhanden ist.
+     * Wenn nicht, wird der Buchstabe dem Spruchschluessel hinzugefügt.
+     * <br>
+     * Dies wir nun so lange gemacht bis der Spruchschluessel eine Laenge von drei Zeichen hat.
+     * Die Walzen werden anhand des Spruchschluessels automatisch gestellt.
+     */
+    public void generateSpruchschluessel() {
+        String klartext = "";
+
+        while (klartext.length() < 3) {
+            String temp = this.randomBuchstabe();
+            if (!klartext.contains(temp)) {
+                klartext += temp;
+            }
+        }
+
+        this.spruchschluessel = klartext;
+        this.spruchschluesselCodiert = this.codiere(klartext + klartext, false);
+
+        // Walzen auf den Spruchschlüssel stellen
+        this.hardware.setzePosition(0, this.spruchschluessel.charAt(0));
+        this.hardware.setzePosition(1, this.spruchschluessel.charAt(1));
+        this.hardware.setzePosition(2, this.spruchschluessel.charAt(2));
+
+        // Die Kenngruppe codieren und in der Nachricht speichern
+        this.codiere(this.kenngruppe, true);
+    }
+
+    /**
+     * Erstellen des Nachrichten-Kopfes.
+     * Hierfuer wird die aktuelle Uhrzeit ausgelesen, die Laenge der Nachricht, sowie der, mit dem
+     * Tagescode codierte, Spruchschluessel.
+     *
+     * @return String: Enthaelt die Uhrzeit, die Anzahl der Buchstaben der Nachricht und den Spruchschluessel.
+     */
+    private String generateKopf() {
+        Calendar cal = Calendar.getInstance();
+
+        return String.format("%02d%02d", cal.get(Calendar.HOUR_OF_DAY), cal.get(Calendar.MINUTE)) + " "
+                + this.nachricht.length() + " " + this.spruchschluesselCodiert.substring(0, 3) + " "
+                + this.spruchschluesselCodiert.substring(3, 6) + " ";
+    }
+
+    /**
+     * Generiert einen zufaelligen Buchstaben aus dem Alphabet.
+     * In der Funktion gibt es den String "Alphabet", in welchem alle zulaessigen Zeichen eingetragen sind.
+     * Aus diesem String wird nun zufaellig ein Zeichen ausgewaehlt und zurueckgegeben.
+     *
+     * @return String : ein zufaellig generierter Buchstabe.
+     */
+    private String randomBuchstabe() {
+        return String.valueOf((char) ('A' + new Random().nextInt(26)));
+    }
+    //endregion
+
+    //region setze Funktionen
+
+    /**
+     * Setzt den Ring auf der Walze auf einen neuen Umsprungwert.
+     *
+     * @param walzenPosition : int : Walze auf die der Ring gesteckt wird.
+     * @param umsprungPunkt  : int : Umspringpunkt (Signal an linke Walze zum Drehen).
+     */
+    public void setzeRing(int walzenPosition, int umsprungPunkt) {
+        this.hardware.setzeRing(walzenPosition, umsprungPunkt);
+    }
+
+    /**
+     * Setzt die Walze (walzeNr) in die Position (walzenPosition) der Enigma ein.
+     * Mit Ringstellung(ringstellung) gibt man die Position des Umsprungpunktes an.
+     *
+     * @param walzenPosition : int : Position der Walze in der Enigma (1-2-3).
+     * @param walzeNr        : int : Nummer der Walze die eingesetzt wird.
+     * @param ringstellung   : int : Stellung des Ringes.
+     */
+    public void setzeWalzeNr(int walzenPosition, int walzeNr, int ringstellung) {
+        this.hardware.setzeWalzenNr(walzenPosition, walzeNr, ringstellung);
+    }
+
+    /**
+     * Setzt den anzuzeigenden Buchstaben (buchstabe) auf der Walze (walzenPosition) und resetet das
+     * Nachrichten Objekt
+     *
+     * @param walze     : int : Nummer der Walze
+     * @param buchstabe : char : Buchstabe der zugewiesen soll
+     */
+    public void setzeWalzenPosition(int walze, char buchstabe) {
+        this.resetNachricht();
+        this.hardware.setzePosition(walze, buchstabe);
+    }
+
+
+    /**
+     * Setzt das Kabel in beide Ports ein und fuegt es dem Steckbrett-Array hinzu.
+     *
+     * @param port       : int : Kabel Nummer, welches am Steckbrett eingesteckt wird.
+     * @param verbindung : String : Verbindung, welche die vertauschten Buchstaben angibt.
+     */
+    public void setzeSteckbrett(int port, String verbindung) {
+        if (verbindung.equals("")) {
+            verbindung = "  ";
+        }
+
+        this.hardware.getSteckbrett().setzeVertauschung(port, verbindung.charAt(0), verbindung.charAt(1));
+    }
+    //endregion
+
+    //region fetch Funktionen
+
+    /**
+     * Gibt die Ringstellungen aus dem Codebuch zurueck.
+     *
+     * @return int[] : Array mit den Ringstellungen der drei eingesetzten Walzen.
+     */
+    public int[] fetchRingstellung() {
+        return this.codebuch.getRingstellung();
+    }
+
+    /**
+     * Gibt die Walzennummer aus dem Codebuch zurueck.
+     *
+     * @return int[] : Array mit den Nummern der drei eingesetzten Walzen.
+     */
+    public int[] fetchWalzenNr() {
+        return this.codebuch.getWalzenlage();
+    }
+
+    /**
+     * Gibt die Steckverbindungen aus dem Codebuch zurueck.
+     *
+     * @return char[][] : Array mit den gesteckten Verbindungen im Steckbrett.
+     */
+    public char[][] fetchSteckverbindungen() {
+        return this.codebuch.getSteckverbindung();
+    }
+
+    /**
+     * Gibt die aktuellen Buchstaben auf den Walzen zurueck.
+     *
+     * @return char[] : Walzen Array mit der aktuellen Positionen.
+     */
+    public char[] fetchWalzen() {
+        char[] walzen = new char[3];
+        walzen[0] = this.hardware.getWalzen()[0].getPosition();
+        walzen[1] = this.hardware.getWalzen()[1].getPosition();
+        walzen[2] = this.hardware.getWalzen()[2].getPosition();
+
+        return walzen;
+    }
+
+    /**
+     * Ueberprueft welche Buchstaben noch zur Vertauschung verfuegbar sind.
+     *
+     * @param port: Zahl zwischen 0-9: entspricht der Kabelnummer.
+     * @return String: liefert einen String mit den verfuegbaren Buchstaben zurueck.
+     */
+    public String fetchVerfuegbareBuchstaben(int port) {
+        return this.hardware.getSteckbrett().fetchVerfuegbareBuchstaben(port);
+    }
+
+    /**
+     * Gibt die Walzennummer einer Walze auf Position (walzePos) zurück
+     *
+     * @param walzePos : int : Position der Walze
+     * @return int : Nummer der eingesetzten Walze
+     */
+    public int fetchWalzenNr(int walzePos) {
+        return this.hardware.getWalzen()[walzePos].getWalzenNr();
+    }
+    //endregion
+
+    //region codierer
+
+    /**
+     * Hier wird ein einzelner Buchstabe verschluesselt.
+     * Man muss hier ebenfalls mitgeben, ob der codierte String in "nachricht" gespeichert werden soll oder nicht.
+     * In der Regel ist dies der Fall.
+     *
+     * @param buchstabe : char : Der zu codierende Buchstabe.
+     * @param save      : boolean : Nachricht speichern oder nicht.
+     * @return char     : Der codierte Buchstabe.
+     */
+    public char codiere(char buchstabe, boolean save) {
+        char codiert = this.hardware.codiere(buchstabe);
+
+        if (save) {
+            this.nachricht += codiert;
+        }
+
+        return codiert;
+    }
+
+    /**
+     * Codiert den uebergebenen String.
+     * Man muss hier ebenfalls mitgeben, ob der codierte String in "nachricht" gespeichert werden soll oder nicht.
+     * In der Regel ist dies der Fall.
+     *
+     * @param klartext : String : Der zu codierende Text.
+     * @param save     : boolean : Nachricht speichern oder nicht.
+     * @return String : Der codierte Text zusaetzlich als Rueckgabe.
+     */
+    public String codiere(String klartext, boolean save) {
+        StringBuilder sb = new StringBuilder();
+
+        for (char buchstabe : klartext.toCharArray()) {
+            sb.append(this.codiere(buchstabe, save));
+        }
+
+        return sb.toString();
+    }
+
+    /**
+     * Diese Funktion erwartet als (codierteNachricht) eine korrekte Enigma-Nachricht.
+     * Ihr muss auch der Tag der Codierung mitgegeben werden. Dieser weiss dein Funker im Funkraum.
+     * In der Regel ist dies der Tag des Nachrichtenempfangs.
+     *
+     * @param codierteNachricht : String : Enigma-codierte Nachricht.
+     * @param tag               : int : Tag der Nachricht.
+     * @return String : decodierte Nachricht.
+     */
+    private String decodiere(String codierteNachricht, int tag) {
+
+        // Hardware reseten und Tageseinstellungen aus dem Codebuch laden
+        this.codebuch.fetchTagesschluessel(tag);
+        this.initialisiereHardware();
+
+        // Nachricht splitten mit whitespace als delimiter
+        String[] nachricht = codierteNachricht.split(" ");
+        StringBuilder sb = new StringBuilder();
+
+        // Uhrzeit und Zeichenanzahl der Nachricht
+        sb.append(nachricht[0]).append(" ");
+        sb.append(nachricht[1]).append(" ");
+
+        // Spruchschluessel
+        String spruchschluessel = this.decodiereString(nachricht[2]);
+
+        sb.append(spruchschluessel).append(" ");
+        sb.append(this.decodiereString(nachricht[3])).append(" ");
+
+        // Walzen neu einstellen mit dem Spruchschluessel
+        this.hardware.setzePosition(0, spruchschluessel.charAt(0));
+        this.hardware.setzePosition(1, spruchschluessel.charAt(1));
+        this.hardware.setzePosition(2, spruchschluessel.charAt(2));
+
+        // Nachricht decodieren
+        sb.append(this.decodiereString(nachricht[4]));
+
+        return sb.toString();
+    }
+
+    /**
+     * Zerlegt den uebergebenen String in einen char-Array und decodiert jedes Zeichen.
+     * Der String wird dann decodiert zurueckgegeben.
+     *
+     * @param nachricht : String : Der zu decodierende Text.
+     * @return String : Der decodierte Text.
+     */
+    private String decodiereString(String nachricht) {
+        StringBuilder sb = new StringBuilder();
+
+        for (char buchstabe : nachricht.toCharArray()) {
+            if (buchstabe > 0) {
+                sb.append(this.hardware.codiere(buchstabe));
+            }
+        }
+
+        return sb.toString();
+    }
+    //endregion
+
+    //region Sonstige
+
+    /**
+     * Liest aus der empfangenen Nachricht den Spruchschluessel aus und gibt ihn zurueck.
+     *
+     * @param empfangeneNachricht : String : Die empfangene Nachricht als String.
+     * @return String : Der Spruchschluessel, mit welcher die Nachricht codiert wurde.
+     */
+    public String empfangenerSpruchschluessel(String empfangeneNachricht) {
+        String[] nachricht = empfangeneNachricht.split(" ");
+
+        return nachricht[2];
+    }
+
+    /**
+     * Loescht das letzte Zeichen aus der Nachricht und dreht die Walzen eine Position zurueck.
+     */
+    public void letztesZeichenLoeschen() {
+        this.hardware.dreheWalzen(-1);
+        this.nachricht = this.nachricht.substring(0, this.nachricht.length() - 1);
+    }
+    //endregion
+
+    //endregion
+
+    //region Getter
+
+    /**
+     * Liest die Kenngruppe aus, welche die Maschine gerade besitzt. Frueher war dies eine eindeutige Nummer,
+     * die einer Einheit zugewiesen war. Wir hinterlegen hier einen Benutzernamen.
+     *
+     * @return String : Kenngruppe
+     */
+    public String getKenngruppe() {
+        return kenngruppe;
+    }
+
+    /**
+     * Der Spruchschluessel wird, zur internen Verwendung, auch im Klartext gespeichert.
+     * Wir brauchen diesen dann zum Codieren der eigentlichen Nachricht.
+     *
+     * @return String : Der Klartext des Spruchschluessels
+     */
+    public String getSpruchschluessel() {
+        return this.spruchschluessel;
+    }
+    //endregion
+}

src/main/java/projekt/enigma/model/Fehler.java

+package projekt.enigma.model;
+
+import javafx.scene.control.Alert;
+import javafx.scene.control.Alert.AlertType;
+import projekt.enigma.App;
+
+/**
+ * In dieser Klasse werden Fehler behandelt und an den User/Admin/Entwickler ausgegeben.
+ */
+public class Fehler {
+    /**
+     * Konstanten die anzeigen ob es sich um eine Funktion oder um eine Nachricht handelt.
+     */
+    private static final String FUNCTION_PREFIX = "- ";
+    private static final String MESSAGE_PREFIX = "--> ";
+
+    /**
+     * Zeige Fehler Dialog
+     *
+     * @param type    : String : Art der Meldung (warning/information/error)
+     * @param subject : String : Titel des Dialoges
+     * @param message : String : Nachricht der Meldung
+     */
+    public void showErrorDialog(String type, String subject, String message) {
+        Alert alert;
+
+        new Fehler().debug(this.getClass().getName() + "."
+                            + new Throwable().getStackTrace()[0].getMethodName(), true);
+
+        /* Der Titel darf auch als leerer String uebergeben werden, dann wird ein Default gesetzt */
+        if (subject.equals("")) {
+            subject = "Es ist ein Fehler aufgetreten";
+        }
+
+        /* Welcher Fehler Typ wurde uebergeben? */
+        switch (type) {
+            case "warning":
+                alert = new Alert(AlertType.WARNING);
+                break;
+
+            case "info":
+                alert = new Alert(AlertType.INFORMATION);
+                break;
+
+            case "error":
+                alert = new Alert(AlertType.ERROR);
+                break;
+
+            default:
+                alert = new Alert(AlertType.NONE);
+        }
+
+        //Anzeige des Alerts definieren
+        alert.setTitle(subject);
+        alert.setHeaderText(null);
+        alert.setContentText(message);
+        alert.showAndWait();
+    }
+
+    /**
+     * Unter zuhilfenahme dieser Funktion koennen Debug Meldungen auf der Konsole ausgegeben werden,
+     * wenn in der App.java der Getter getDebug einen int > 0 zurueck gibt.
+     * Ueber diesen Getter kann man steuern ob Meldungen in der Konsole angezeigt werden sollen oder nicht.
+     *
+     * @param message    : String : Nachricht
+     * @param isFunction : boolean : Gibt an ob ein Funktionsname uebergeben wird oder eine Debug Meldung
+     */
+    public void debug(String message, boolean isFunction) {
+        if (App.getDebug() != 0) {
+            if (isFunction) {
+                System.out.println(FUNCTION_PREFIX + message);
+            } else {
+                System.out.println(MESSAGE_PREFIX + message);
+            }
+        }
+    }
+
+    /**
+     * Unter Zuhilfenahme dieser Funktion koennen Debug Meldungen auf der Konsole ausgegeben werden,
+     * wenn in der App.java der Getter getDebug einen int > 0 zurueck gibt.
+     * Ueber diesen Getter kann man steuern ob Meldungen in der Konsole angezeigt werden sollen oder nicht.
+     *
+     * @param message    : String : Nachricht
+     * @param isFunction : boolean : Gibt an ob ein Funktionsname uebergeben wird oder eine Debug Meldung.
+     */
+    public void debug(String message, boolean isFunction, int debugLevel) {
+        if (App.getDebug() != 0 && (App.getDebug() >= debugLevel || App.getDebug() == 3)) {
+            if (isFunction) {
+                System.out.println(FUNCTION_PREFIX + message);
+            } else {
+                System.out.println(MESSAGE_PREFIX + message);
+            }
+        }
+    }
+}
\ No newline at end of file

src/main/java/projekt/enigma/model/Funkraum.java

+package projekt.enigma.model;
+
+import org.apache.http.HttpEntity;
+import org.apache.http.HttpResponse;
+import org.apache.http.NameValuePair;
+import org.apache.http.client.HttpClient;
+import org.apache.http.client.entity.UrlEncodedFormEntity;
+import org.apache.http.client.methods.HttpPost;
+import org.apache.http.impl.client.HttpClients;
+import org.apache.http.message.BasicNameValuePair;
+import org.json.JSONObject;
+
+import java.io.BufferedReader;
+import java.io.IOException;
+import java.io.InputStreamReader;
+import java.io.UnsupportedEncodingException;
+import java.util.ArrayList;
+import java.util.List;
+
+/**
+ * Hier sitzt der Funker.
+ * Der Funkraum kann Funksprueche empfangen und senden.
+ * Hierfuer wird eine Verbindung zu einem externen Service aufgebaut.
+ * Dieser Servive erwartet die Nachrichten im JSON Format. Dazu wird ein k als Kenngruppe
+ * (Benutzername) uebergeben und falls eine Nachricht gesendet werden soll, zusaetzlich ein m mit der Nachricht.
+ * Beides wird als String gesendet.
+ */
+public class Funkraum {
+
+    /**
+     * Zum Empfangen liefert der Server, anstatt der Kenngruppe (k), den Empfangstag (t) der Nachricht mit, damit man
+     * die Grundeinstellungen aus dem Codebuch, für diesen Tag, raussuchen kann.
+     * {'m': 'Hello world', 't': '26'}
+     *
+     * @param kenngruppe : String : Kenngruppe dieser Enigma
+     * @return funkspruch : String[] : String Array wobei Index 0 dem Empfangstag entspricht und Index 1
+     *                                 der empfangenen Nachricht.
+     * @throws NullPointerException : Exception : Keine Nachricht vorhanden.
+     */
+    public String[] empfangeFunkspruch(String kenngruppe) {
+        String[] funkspruch = new String[2];
+
+        HttpClient httpclient = HttpClients.createDefault();
+        HttpPost httppost = new HttpPost("https://enigma.itstall.de/");
+
+        try {
+            // Anfrage Parameter und Encoding setzen
+            List<NameValuePair> params = new ArrayList<>(2);
+            params.add(new BasicNameValuePair("k", kenngruppe));
+            httppost.setEntity(new UrlEncodedFormEntity(params, "UTF-8"));
+
+            // POST Request ausfuehren und Rueckgabe verarbeiten
+            HttpResponse response = httpclient.execute(httppost);
+            HttpEntity entity = response.getEntity();
+
+            if (entity != null) {
+                BufferedReader reader = new BufferedReader(new InputStreamReader(entity.getContent()));
+                JSONObject result = new JSONObject(reader.readLine());
+
+                if (!result.getString("m").isEmpty()) {
+                    funkspruch[0] = result.getString("t");
+                    funkspruch[1] = result.getString("m");
+                }
+            }
+        } catch (UnsupportedEncodingException e) {
+            new Fehler().showErrorDialog("error", "Encoding wird nicht unterstützt",
+                    "Kommunikation mit dem Feind wird als Landesverrat bestraft");
+        } catch (IOException e) {
+            new Fehler().showErrorDialog("error", "HTTP Post war nicht erfolgreich",
+                    "Bitte wenden Sie sich an ihren Vorgesetzten.");
+        } catch (NullPointerException e) {
+            new Fehler().showErrorDialog("info", "Keiner schreibt dir...",
+                    "Es liegen keine neuen Nachrichten im Funkraum für Sie vor.");
+        }
+
+        return funkspruch;
+    }
+
+    /**
+     * Dem Service senden wir unsere Nachricht als POST Parameter (m) und unsere Kenngruppe (k).
+     * Dieser nimmt die Daten entgegen und hierlerlegt sie auf seinem Stapel (Datenbank) von dem die Nachrichten
+     * irgendwann, auf Anfrage, wieder abgerufen werden koennen.
+     * <br>
+     * Darauf antwortet der Server mit einem JSON Object in dem das Ergebnis der Anfrage zu sehen ist.
+     * {'result': 200}
+     * <br>
+     * Die 200 heisst hier, dass alles erfolgreich durchgefuehrt werden konnte. Steht hier etwas anderes, ist ein Fehler
+     * aufgetreten und die Anfrage war nicht erfolgreich.
+     * In letzterem Fall sollte eine Meldung an den Benutzer ausgegeben werden und ggf. spaeter erneut versucht werden.
+     *
+     * @param funkspruch : String : Der zu sendende Funkspruch
+     * @param kenngruppe : String : Die Kenngruppe dieser Engima
+     * @throws IOException : Exception : Funkspruch konnte nicht gesendet werden
+     */
+    public void sendeFunkspruch(String funkspruch, String kenngruppe) throws IOException {
+        HttpClient httpclient = HttpClients.createDefault();
+        HttpPost httppost = new HttpPost("https://enigma.itstall.de/");
+
+        // Anfrage Parameter und Encoding setzen
+        List<NameValuePair> params = new ArrayList<>(2);
+        params.add(new BasicNameValuePair("k", kenngruppe));
+        params.add(new BasicNameValuePair("m", funkspruch));
+        httppost.setEntity(new UrlEncodedFormEntity(params, "UTF-8"));
+
+        // POST Request ausfuehren und Rueckgabe verarbeiten
+        HttpResponse response = httpclient.execute(httppost);
+        HttpEntity entity = response.getEntity();
+
+        if (entity != null) {
+            BufferedReader reader = new BufferedReader(new InputStreamReader(entity.getContent()));
+            JSONObject result = new JSONObject(reader.readLine());
+            if (result.getInt("result") != 200) {
+                new Fehler().showErrorDialog("error", "HTTP Exception",
+                        "Der andere Funker mag deine Nachricht nicht. "
+                                + "Rüge ihn wenn du ihn wieder siehst...");
+            }
+        }
+    }
+}

src/main/java/projekt/enigma/model/Hardware.java

+package projekt.enigma.model;
+
+/**
+ * In dieser Klasse wird die Hardware zusammengefasst.
+ * Alle Komponenten der Enigma laufen hier zusammen.
+ *
+ * <p>
+ * walzen : Walze[] :           Ist ein Array der drei eingebauten Walzen Objekte
+ * steckbrett : Steckbrett :    Das Steckbrett mit den Verbindungen aus dem Codebuch
+ * reflektor : Reflektor :      Dies ist das Objekt der Reflektors
+ * nachricht : String :         Die verschluesselte Nachricht wird in diesem String zusammengesetzt und gespeichert
+ * kenngruppe : String :        Frueher definierte die Kennzeichnung die Einheit welche diese Enigma benutzte.
+ * Wir missbrauchen die Kenngruppe für einen Benutzernamen
+ * </p>
+ */
+public class Hardware {
+
+	//region Variablen
+	/**
+	 * walzen: Walze-Array: erzeugt ein privates Array mit der die Anzahl der Walzen festgelegt wird.
+	 */
+	private Walze[] walzen;
+
+	/**
+	 * steckbrett: Steckbrett: erzeugt ein privates Steckbrett-Objekt
+	 */
+	private Steckbrett steckbrett;
+
+	/**
+	 * reflektor: Reflektor: erzeugt ein privates Reflektor-Objekt.
+	 */
+	private Reflektor reflektor;
+	//endregion
+
+	//region Konstruktor
+
+    /**
+     * Im Konstruktor legen wir die Anzahl der Walzen fest, welche die Hardware aufnehmen kann.
+     * Die Enigma I, welche hier nachgebildet werden soll, konnte drei Walzen aufnehmen.
+     */
+    public Hardware() {
+        this.walzen = new Walze[3];
+    }
+    //endregion
+
+	//region Funktionen & Methoden
+
+    /**
+     * Setzt eine Walze ein.
+     *
+     * @param walze    : int : Setzt die Walze mit der angegebenen Nummer ein.
+     * @param walzenNr : int : Die Nummer der einzusetzenden Walze.
+     * @param ringstellung : int : Setzt den Ring der Walze auf die angegebene Nummer.
+     */
+    public void setzeWalzenNr(int walze, int walzenNr, int ringstellung) {
+        this.walzen[walze] = new Walze(walzenNr, ringstellung);
+    }
+
+    /**
+     * Setzt den Notch der Walze.
+     *
+     * @param walze    : int : Position der Walze.
+     * @param position : int : Umspringpunkt auf der Walze.
+     */
+    public void setzeRing(int walze, int position) {
+        this.walzen[walze].setRingstellung(position);
+    }
+
+    /**
+     * Setzt den Startwert (position) der Walze (walze).
+     *
+     * @param walze     : int : Nummer der Walze.
+     * @param buchstabe : char : Buchstabe der zugewiesen werden soll.
+     */
+    public void setzePosition(int walze, char buchstabe) {
+        this.walzen[walze].setPosition(buchstabe);
+    }
+
+    /**
+     * Verschluesselt den uebergebenen Buchstaben und fuegt ihn der Nachricht hinzu.
+     * Debug Ausgabe auf der Konsole wird zusaetzlich ausgegeben.
+     *
+     * @param buchstabe char : Der zu ver/entschluesselnde Buchstabe.
+     * @return char : Der ver/entschluesselte Buchstabe.
+     */
+    public char codiere(char buchstabe) {
+        new Fehler().debug(this.getClass().getName() + "." +
+                new Throwable().getStackTrace()[0].getMethodName(), true);
+
+        buchstabe = Character.toUpperCase(buchstabe);
+        String debug = String.format("Positionen: W1:%s W2:%s W3:%s",
+                this.walzen[0].getPosition(),
+                this.walzen[1].getPosition(),
+                this.walzen[2].getPosition());
+        debug += "\nI\tS\t3\t2\t1\tR\t1\t2\t3\tS\n" + buchstabe;
+
+		this.dreheWalzen(1);
+
+        //Codiere Vorgang wird fuer jede Walze bis zum Reflektor mit der codiere Funktion durchgefuehrt.
+        //Auf dem Rueckweg wird mit der codiere2 Funktion codiert.
+        buchstabe = this.steckbrett.codiere(Character.toUpperCase(buchstabe));
+        debug += "\t" + buchstabe;
+        buchstabe = this.walzen[2].codiere(buchstabe);
+        debug += "\t" + buchstabe;
+        buchstabe = this.walzen[1].codiere(buchstabe);
+        debug += "\t" + buchstabe;
+        buchstabe = this.walzen[0].codiere(buchstabe);
+        debug += "\t" + buchstabe;
+        buchstabe = this.reflektor.codiere(buchstabe);
+        debug += "\t" + buchstabe;
+        buchstabe = this.walzen[0].codiere2(buchstabe);
+        debug += "\t" + buchstabe;
+        buchstabe = this.walzen[1].codiere2(buchstabe);
+        debug += "\t" + buchstabe;
+        buchstabe = this.walzen[2].codiere2(buchstabe);
+        debug += "\t" + buchstabe;
+        buchstabe = this.steckbrett.codiere(buchstabe);
+        debug += "\t" + buchstabe;
+        new Fehler().debug(debug, false);
+
+		return buchstabe;
+	}
+
+    /**
+     * Nach jeder Codierung eines Buchstabens muessen die Walzen gedreht werden.
+     * Hier ueberpruefen wir, welche der Walzen gedreht werden muessen und stossen den Vorgang an.
+     *
+     * @param richtung : int : +1 fuer eine Vorwaertsdrehung und -1 fuer eine Rueckwaertsdrehung.
+     */
+    public void dreheWalzen(int richtung) {
+        if (richtung > 0) {
+            for (int i = 0; i < richtung; i++) {
+                if (this.walzen[2].dreheWalze(1)) {
+                    if (this.walzen[1].dreheWalze(1)) {
+                        this.walzen[0].dreheWalze(1);
+                    }
+                }
+            }
+        } else {
+            for (int i = 0; i > richtung; richtung++) {
+                if (this.walzen[2].dreheWalze(-1)) {
+                    if (this.walzen[1].dreheWalze(-1)) {
+                        this.walzen[0].dreheWalze(-1);
+                    }
+                }
+            }
+        }
+    }
+    //endregion
+
+	//region Setter
+
+    /**
+     * Setzt eine Walze ein und speichert das Objekt im Walzen Array.
+     *
+     * @param position     : int : Position der Walze.
+     * @param walze        : int : Die Nummer der Walze.
+     * @param ringstellung : int : Umsprungpunkt der Walze.
+     */
+    public void setWalzen(int position, int walze, int ringstellung) {
+        this.walzen[position] = new Walze(walze, ringstellung);
+    }
+
+    /**
+     * Gibt das Objekt des Steckbretts zurueck.
+     *
+     * @return steckbrett : Steckbrett-Objekt:  Das eingesetzte Steckbrett mit seinen Kabeln, wenn eingesteckt.
+     */
+    public Steckbrett getSteckbrett() {
+        return steckbrett;
+    }
+
+    /**
+     * Setzt das uebergebene Steckbrett Objekt in die Hardware ein.
+     *
+     * @param steckbrett : Steckbrett : Objekt des Steckbretts mit allen verbundenen Kabeln.
+     */
+    public void setSteckbrett(Steckbrett steckbrett) {
+        this.steckbrett = steckbrett;
+    }
+    //endregion
+
+	//region Getter
+
+    /**
+     * Setzt den Reflektor ein.
+     * In der Enigma I, welche hier nachgebaut wird, gab es nur einen Reflektor.
+     * Spaetere Versionen hatten zwei oder mehr, deshalb haben wir hier auch schon ein Objekt dafuer erstellt,
+     * welches ausgetauscht werden kann.
+     *
+     * @param reflektor : Reflektor : Das Objekt des Reflektors.
+     */
+    public void setReflektor(Reflektor reflektor) {
+        this.reflektor = reflektor;
+    }
+
+    /**
+     * Gibt die verbauten Walzen Objekte zurück.
+     *
+     * @return walzen : Walze[] : Array mit den Walzen Objekten.
+     */
+    public Walze[] getWalzen() {
+        return this.walzen;
+    }
+    //endregion
+
+}

src/main/java/projekt/enigma/model/Morsecode.java

+package projekt.enigma.model;
+
+import java.util.Map.Entry;
+import java.util.TreeMap;
+
+/**
+ * Diese Klasse definiert die Zugehoerigkeit zwischen den Buchstaben A-Z und dem Morsecode.
+ * Die Funktionen sollen Texte von und zu Morsecode konvertieren.
+ */
+public class Morsecode {
+
+    /**
+     * Anlegen der codeMap als TreeMap.
+     */
+    private TreeMap<String, String> codeMap;
+
+    /**
+     * Im Konstruktor werden alle verfuegbaren Buchstaben (A-Z) und deren zugehoerigen
+     * Morsecodes, der codeMap hinzugefuegt.
+     */
+    public Morsecode() {
+        codeMap = new TreeMap<>();
+        this.codeMap.put("A", ".-");
+        this.codeMap.put("B", "-...");
+        this.codeMap.put("C", "-.-.");
+        this.codeMap.put("D", "-..");
+        this.codeMap.put("E", ".");
+        this.codeMap.put("F", "..-.");
+        this.codeMap.put("G", "--.");
+        this.codeMap.put("H", "....");
+        this.codeMap.put("I", "..");
+        this.codeMap.put("J", ".---");
+        this.codeMap.put("K", "-.-");
+        this.codeMap.put("L", ".-..");
+        this.codeMap.put("M", "--");
+        this.codeMap.put("N", "-.");
+        this.codeMap.put("O", "---");
+        this.codeMap.put("P", ".--.");
+        this.codeMap.put("Q", "--.-");
+        this.codeMap.put("R", ".-.");
+        this.codeMap.put("S", "...");
+        this.codeMap.put("T", "-");
+        this.codeMap.put("U", "..-");
+        this.codeMap.put("V", "...-");
+        this.codeMap.put("W", ".--");
+        this.codeMap.put("X", "-..-");
+        this.codeMap.put("Y", "-.--");
+        this.codeMap.put("Z", "--..");
+        this.codeMap.put(" ", "-...-");
+        this.codeMap.put("1", ".----");
+        this.codeMap.put("2", "..---");
+        this.codeMap.put("3", "...--");
+        this.codeMap.put("4", "....-");
+        this.codeMap.put("5", ".....");
+        this.codeMap.put("6", "-....");
+        this.codeMap.put("7", "--...");
+        this.codeMap.put("8", "---..");
+        this.codeMap.put("9", "----.");
+        this.codeMap.put("0", "-----");
+    }
+
+    /**
+     * Diese Funktion ueberprueft ob der uebergebene Buchstabe in der codeMap enthalten ist.
+     * Wenn er enthalten ist, wird der zugehoerige Morsecode zurueck gegeben, ansonsten null.
+     *
+     * @param buchstabe : char : Zu uebersetzender Buchstabe.
+     * @return String : Der zugehoerige Morsecode aus der codeMap.
+     */
+    private String getMorsecode(char buchstabe) {
+        return this.codeMap.getOrDefault(String.valueOf(buchstabe).toUpperCase(), null);
+    }
+
+    /**
+     * Der uebergebene String wird in seine einzelnen Zeichen (char) zerlegt und an die Funktion getMorsecode
+     * uebergeben und der zugehoerige Morsecode rausgesucht.
+     * Mittels eines StringBuilders werden die Ergebnisse zu einem Rueckgabe-String zusammengesetzt.
+     * Wenn kein zugehoeriger Code in der codeMap gefunden wurde, wird das Zeichen ignoriert da es bei der
+     * Enigma nicht vorhanden war.
+     *
+     * @param input : String : Zu konvertierender Text.
+     * @return String : Der in Morsecode konvertierte Text.
+     */
+    public String convertBuchstabeToMorsecode(String input) {
+        StringBuilder sb = new StringBuilder();
+        String morsecode;
+
+        // Durch alle char im uebergebenen String loopen
+        for (int i = 0; i < input.length(); i++) {
+            morsecode = this.getMorsecode(input.charAt(i));
+            if (morsecode != null) {
+                sb.append(morsecode).append(' ');
+            }
+        }
+
+        return sb.toString();
+    }
+
+    /**
+     * Diese Funktion ueberprueft ob der uebergebene Morsecode in der codeMap enthalten ist.
+     * Wenn er enthalten ist, wird der zugehoerige Buchstabe zurueckgegeben, ansonsten null.
+     *
+     * @param morsecode : String : Der zu uebersetzende Morsecode.
+     * @return : String : Der zugehoerige Buchstabe aus der codeMap.
+     */
+    private String getBuchstabe(String morsecode) {
+        String result = null;
+
+        // Loopt duch die codeMap und erstellt daraus ein Set
+        for (Entry<String, String> entry : this.codeMap.entrySet()) {
+            if (entry.getValue().equals(morsecode)) {
+                result = entry.getKey();
+            }
+        }
+
+        return result;
+    }
+
+    /**
+     * Der uebergebene String wird in ein String-Array zerlegt. Als Trennzeichen wird das Leerzeichen genutzt.
+     * Anschließend wird das Array durchlaufen und die Elemente an die Funktion getBuchstabe uebergeben um den
+     * zugehoerigen Buchstaben zu erhalten.
+     * Mittels eines StringBuilders werden die Ergebnisse zu einem Rueckgabe String zusammengesetzt.
+     * Wenn kein zugehoeriger Buchstabe in der codeMap gefunden wurde, wird das Zeichen ignoriert, da es bei der
+     * Enigma nicht vorhanden war.
+     *
+     * @param input : String : Zu konvertierender Morsecode.
+     * @return String : Der in Text konvertierte Morsecode.
+     */
+    public String convertMorsecodeToBuchstabe(String input) {
+        StringBuilder sb = new StringBuilder();
+        String buchstabe;
+
+        String[] morsecodes = input.split(" ");
+
+        // Durch alle char im uebergebenen String loopen
+        for (String morsecode : morsecodes) {
+            buchstabe = this.getBuchstabe(morsecode);
+            if (buchstabe != null) {
+                sb.append(buchstabe);
+            }
+        }
+
+        return sb.toString();
+    }
+}

src/main/java/projekt/enigma/model/Reflektor.java

+package projekt.enigma.model;
+
+/**
+ * Klasse Reflektor
+ * <br>
+ * Der Reflektor nimmt einen Buchstaben der Klasse Walze entgegen und codiert diesen.
+ * Der codierte Buchstabe wird an die Klasse Walze wieder zurueckgegeben.
+ * <br>
+ * Prinzipiell verhaelt sich die Klasse Reflektor wie die Klasse Walze, ausser das sie sich
+ * nach Betaetigung einer Taste nicht dreht (quasi starr montiert ist) und sie gibt keine Signale
+ * an andere Walzen zum Drehen.
+ */
+public class Reflektor {
+
+    /**
+     * Funktion codiere
+     * <br>
+     * Durchsucht den String alphabet nach der Position des mitgegebenen Buchstabens und
+     * gibt den Character an der entsprechenden Position im String reflektor zurueck.
+     *
+     * @param buchstabe : Character : der zu codierende Buchstabe.
+     * @return char : Der codierte Buchstabe aus dem Reflektor.
+     */
+    public char codiere(Character buchstabe) {
+        String alphabet = "ABCDEFGHIJKLMNOPQRSTUVWXYZ";
+        String reflektor = "EJMZALYXVBWFCRQUONTSPIKHGD";
+
+        return reflektor.charAt(alphabet.indexOf(buchstabe));
+    }
+}

src/main/java/projekt/enigma/model/Steckbrett.java

+package projekt.enigma.model;
+
+/**
+ * <p>
+ * Klasse Steckbrett
+ * <br>
+ * Das Steckbrett diente dazu, Buchstaben paarweise zu vertauschen noch bevor diese durch die Walzen codiert werden.
+ * Die Klasse Steckbrett nimmt bis zu 10 paarweise zu vertauschende Buchstabenpaare entgegen, prueft diese auf
+ * Zulaessigkeit und tauscht diese dann paarweise aus.
+ */
+public class Steckbrett {
+
+    /**
+     * orginalBuchstaben: String : der jeweils den ersten zu vertauschenden Buchstaben enthaelt.
+     */
+    private String originalBuchstaben;
+
+    /**
+     * getauschteBuchstaben: String : der jeweils den zweiten zu vertauschenden Buchstaben enthaelt.
+     */
+    private String getauschteBuchstaben;
+
+    /**
+     * Konstruktor Steckbrett
+     * <br>
+     * Erzeugt zwei Strings und initialisiert diese.
+     */
+    public Steckbrett() {
+        originalBuchstaben = "";
+        getauschteBuchstaben = "";
+    }
+
+    /**
+     * Funktion setzeVertauschung
+     * <br>
+     * Der Funktion setzeVertauschung werden 2 Buchstaben (buchstabe1 und buchstabe2) uebergeben.
+     * Zuerst wird ueberprueft ob einer der beiden Buchstaben bereits enthalten ist, was unzulaessig waere.
+     * <br>
+     * Anschliessend wird:
+     * <p>
+     * buchstabe1 dem String orginalBuchstaben angehaengt.
+     * buchstabe2 dem String getauschteBuchstaben angehaengt.
+     * </p>
+     *
+     * @param buchstabe1 : char : Gibt den ersten Buchstaben an, der getauscht werden soll.
+     * @param buchstabe2 : char : gibt den zweiten Buchstaben an, mit dem der erste getauscht werden soll.
+     * @return boolean : Wenn die Vertauschung zulaessig ist, true, ansonsten false.
+     */
+    public boolean setzeVertauschung(char buchstabe1, char buchstabe2) {
+        if ((!ueberpruefeVertauschungen(buchstabe1)) && (!ueberpruefeVertauschungen(buchstabe2))
+                && (originalBuchstaben.length() <= 20)) {
+            originalBuchstaben += buchstabe1;
+            getauschteBuchstaben += buchstabe2;
+            return true;
+        } else {
+            return false;
+        }
+    }
+
+    /**
+     * Funktion setzeVertauschung mit Angabe eines Ports von 1 - 10
+     * <br>
+     * Der Funktion setzeVertauschung werden 2 Buchstaben (buchstabe1 und buchstabe2) sowie der Port uebergeben.
+     * Zuerst wird ueberprueft ob einer der beiden Buchstaben bereits enthalten ist, was unzulaessig waere.
+     * <br>
+     * Anschliessend wird:
+     * <p>
+     * buchstabe1 in den String orginalBuchstaben auf die Position (steckbrettPort) geschrieben.
+     * buchstabe2 in den String getauschteBuchstaben auf die Position (steckbrettPort) geschrieben.
+     * </p>
+     *
+     * @param buchstabe1 : char: Gibt den ersten Buchstaben an, der getauscht werden soll.
+     * @param buchstabe2 : char: gibt den zweiten Buchstaben an, mit dem der erste getauscht werden soll.
+     * @return boolean : Wenn die Vertauschung zulaessig ist, true, ansonsten false.
+     */
+    public boolean setzeVertauschung(int steckbrettPort, char buchstabe1, char buchstabe2) {
+        char[] original;
+        char[] getauscht;
+
+        new Fehler().debug("setzeVertauschung(int " + steckbrettPort + ", char |" + buchstabe1 + "|, char |" + buchstabe2 + "|)", false);
+
+        if ((!ueberpruefeVertauschungen(buchstabe1) && !ueberpruefeVertauschungen(buchstabe2)) ||
+                (buchstabe1 == ' ' && buchstabe2 == ' ')) {
+
+            new Fehler().debug("-> Original:\t" + originalBuchstaben, false);
+            new Fehler().debug("-> Getauscht:\t" + getauschteBuchstaben, false);
+            original = originalBuchstaben.toCharArray();
+            getauscht = getauschteBuchstaben.toCharArray();
+
+            original[steckbrettPort] = buchstabe1;
+            getauscht[steckbrettPort] = buchstabe2;
+
+            originalBuchstaben = String.valueOf(original);
+            getauschteBuchstaben = String.valueOf(getauscht);
+            new Fehler().debug("<- Original:\t" + originalBuchstaben, false);
+            new Fehler().debug("<- Getauscht:\t" + getauschteBuchstaben, false);
+
+            new Fehler().debug("true\tOS: |" + originalBuchstaben + "| GS: |" + getauschteBuchstaben + "|", false);
+            return true;
+        } else {
+            new Fehler().debug("false\tOS: |" + originalBuchstaben + "| GS: |" + getauschteBuchstaben + "|", false);
+            return false;
+        }
+    }
+
+    /**
+     * Funktion ueberpruefeVertauschungen
+     * <br>
+     * Die Funktion ueberpruefeVertauschungen prueft, ob der uebergebene Buchstabe bereits in den beiden Strings
+     * orginalBuchstaben und getauschteBuchstaben vorhanden ist.
+     * Eine Buchstabenvertauschung ist zulaessig, wenn keine Dopplungen der zu vertauschenden Buchstaben auftritt
+     * (ein Buchstabe nicht mehrmals vertauscht wird).
+     *
+     * @param buchstabe : Character: zu pruefender Buchstabe.
+     * @return result : boolean : Wenn false, dann darf der Buchstabe genutzt werden. Wenn er schon vorhanden ist,
+     * wird true zurueckgegeben.
+     */
+    public boolean ueberpruefeVertauschungen(Character buchstabe) {
+        boolean result = false;
+
+        if (originalBuchstaben.contains(String.valueOf(buchstabe)) ||
+                getauschteBuchstaben.contains(String.valueOf(buchstabe))) {
+            result = true;
+        }
+
+        return result;
+    }
+
+    /**
+     * Funktion codiere
+     * <br>
+     * Die Funktion codiere tauscht den uebergebenen Character buchstabe mit dem zu tauschenden Character aus.
+     *
+     * @param buchstabe : Character : Buchstabe der codiert werden soll.
+     * @return buchstabe : Character : Codierter Buchstabe.
+     */
+    public char codiere(Character buchstabe) {
+        if (originalBuchstaben.contains(String.valueOf(buchstabe))) {
+            return getauschteBuchstaben.charAt(originalBuchstaben.indexOf(buchstabe));
+        } else if (getauschteBuchstaben.contains(String.valueOf(buchstabe))) {
+            return originalBuchstaben.charAt(getauschteBuchstaben.indexOf(buchstabe));
+        } else {
+            return buchstabe;
+        }
+    }
+
+    /**
+     * Tauscht die Buchstaben im Alphabet aus und gibt ein modifiziertes Alphabet zurueck.
+     *
+     * @param port : int : Platz der getauschten Buchstaben.
+     * @return alphabet : String : Alphabet mit getauschtem Buchstabenpaar.
+     */
+    public String fetchVerfuegbareBuchstaben(int port) {
+        String alphabet = "ABCDEFGHIJKLMNOPQRSTUVWXYZ";
+
+        for (char c : this.originalBuchstaben.toCharArray()) {
+            alphabet = alphabet.replace(String.valueOf(c), "");
+        }
+
+        for (char c : this.getauschteBuchstaben.toCharArray()) {
+            alphabet = alphabet.replace(String.valueOf(c), "");
+        }
+
+        alphabet += originalBuchstaben.charAt(port);
+        alphabet += getauschteBuchstaben.charAt(port);
+
+        return alphabet;
+    }
+}
\ No newline at end of file