Steckbrett hinzugefügt

src/main/java/Enigma/model/Reflektor.java

@@ -2,10 +2,10 @@ package Enigma.model;
 
 /**
  * Klasse Reflektor
- *
+ * <p>
  * Der Reflektor nimmt einen Buchstaben der Klasse Walze entgegen und und kodiert diesen.
  * Der kodierte Buchstabe wird an die Klasse Walze wieder zurückgegeben.
- *
+ * <p>
  * Prinzipiell verhält sich die Klasse Refelktor wie die Klasse Walze, außer das sie sich
  * nach Betätigung einer Taste nicht dreht (starr montiert) und sie gibt keine Signale
  * an andere Walzen zum drehen.
@@ -14,70 +14,38 @@ public class Reflektor {
 
     /**
      * Konstanten und Variablen der Klasse Reflektor
-     *
+     * <p>
      * WALZE_ALPHABET : konstanter Char-Array mit den Werten des Alphabeths (26 Werte)
      * WALZE_REFLEKTOR : konstanter Char-Array mit den Werten des Reflektors (26 Werte)
      * reflektorBuchstabeRein : Character mit dem an die Klasse übergebenen Character
      * reflektorBuchstabeRaus : Character nach der Codierung in der Klasse Reflektor
      * iPositionReflektor : Integer mit der Positionsnummer des Characters im Array
      */
-    private final Character[] WALZE_ALPHABET = {'A','B', 'C', 'D', 'E', 'F', 'G', 'H', 'I', 'J', 'K', 'L', 'M', 'N', 'O', 'P', 'Q', 'R', 'S', 'T', 'U', 'V', 'W', 'X', 'Y', 'Z'};
-    private final Character[] WALZE_REFLEKTOR= {'E', 'J', 'M', 'Z', 'A', 'L', 'Y', 'X', 'V', 'B', 'W', 'F', 'C', 'R', 'Q', 'U', 'O', 'N', 'T', 'S', 'P', 'I', 'K', 'H', 'G', 'D'};
-    private Character reflektorBuchstabeRein;
-    private Character reflektorBuchstabeRaus;
-    private int iPositionReflektor;
+    private final Character[] WALZE_ALPHABET = {'A', 'B', 'C', 'D', 'E', 'F', 'G', 'H', 'I', 'J', 'K', 'L', 'M', 'N', 'O', 'P', 'Q', 'R', 'S', 'T', 'U', 'V', 'W', 'X', 'Y', 'Z'};
+    private final Character[] WALZE_REFLEKTOR = {'E', 'J', 'M', 'Z', 'A', 'L', 'Y', 'X', 'V', 'B', 'W', 'F', 'C', 'R', 'Q', 'U', 'O', 'N', 'T', 'S', 'P', 'I', 'K', 'H', 'G', 'D'};
 
 
     /**
      * Funktion Codiere
-     *
+     * <p>
      * Durchsucht das konstante Char-Array WALZE_ALPHABET nach der Position eines bestimmten
      * Buchstabens und gibt den Character an der entsprechenden Position im konstanten
      * Char-Array WALZE_REFLEKTOR zurück.
      *
      * @return reflektorBuchstabeRaus: Character: Der kodierte Buchstabe aus dem Reflektor
      */
-    public char codiere (){
-        int index = 0;
+    public char codiere(Character buchstabe) {
+        int iPositionReflektor = 0;
 
         /*Ermittelt die Position des Buchstaben buchstabe auf der Alphabetswalze*/
-        for(index = 0; index < WALZE_ALPHABET.length; index++) {
-            if(getReflektorBuchstabeRein().equals(WALZE_ALPHABET[index])) {
+        for (int index = 0; index < WALZE_ALPHABET.length; index++) {
+            if (buchstabe.equals(WALZE_ALPHABET[index])) {
                 iPositionReflektor = index;
                 break;
             }
         }
         /*Im Char-Array WALZE_REFLEKTOR wird der Character an der Position iPositionReflektor ausgegeben*/
-        reflektorBuchstabeRaus = WALZE_REFLEKTOR[iPositionReflektor];
-        return reflektorBuchstabeRaus;
-    }
-
-    /**
-     * Getter getReflektorBuchstabeRein
-     *
-     * Gibt den Wert der Variablen reflektorBuchstabeRein zurück
-     *
-     * @return reflektorBuchstabeRein: Character: gibt den Buchstaben zurück
-     */
-    public Character getReflektorBuchstabeRein() {
-        return reflektorBuchstabeRein;
-    }
-
-
-    /**
-     * Setter setReflektorBuchstabeRein
-     *
-     * Setzt den Wert der Variablen reflektorBuchstabeRein
-     *
-     * @param reflektorBuchstabeRein: Character: setzt den Wert des Buchstabens
-     */
-    public void setReflektorBuchstabeRein(Character reflektorBuchstabeRein) {
-        if (Character.isLetter(reflektorBuchstabeRein)){
-            this.reflektorBuchstabeRein = reflektorBuchstabeRein;
-        } else{
-            System.err.println("Kein Buchstabe übergeben im Reflektor");
-        }
-
+        return WALZE_REFLEKTOR[iPositionReflektor];
     }
 
 }

src/main/java/Enigma/model/Steckbrett.java

 package Enigma.model;
 
+/**
+ *
+ */
 public class Steckbrett {
-
-    private final Character[] WALZE_ALPHABET = {'A','B', 'C', 'D', 'E', 'F', 'G', 'H', 'I', 'J', 'K', 'L', 'M', 'N', 'O', 'P', 'Q', 'R', 'S', 'T', 'U', 'V', 'W', 'X', 'Y', 'Z'};
-    private Character buchstabeEins;
-    private Character buchstabeZwei;
-    private int iPositionEins;
-    private int iPositionZwei;
-
-    public Character getBuchstabeEins() {
-        return buchstabeEins;
+    /**
+     *
+     */
+    private int zaehler;
+    private Character[] orginalBuchstaben;
+    private Character[] getauschteBuchstaben;
+
+    /**
+     *
+     */
+    public Steckbrett() {
+
+        orginalBuchstaben = new Character[10];
+        getauschteBuchstaben = new Character[10];
     }
 
-    public void setBuchstabeEins(Character buchstabeEins) {
-        this.buchstabeEins = buchstabeEins;
-    }
-
-    public Character getBuchstabeZwei() {
-        return buchstabeZwei;
-    }
-
-    public void setBuchstabeZwei(Character buchstabeZwei) {
-        this.buchstabeZwei = buchstabeZwei;
-    }
 
+    /**
+     *
+     * @param buchstabe1
+     * @param buchstabe2
+     * @return
+     */
+    public boolean setzeVertauschung(char buchstabe1, char buchstabe2) {
 
+        if (zaehler < orginalBuchstaben.length) {
+            orginalBuchstaben[zaehler] = buchstabe1;
+            getauschteBuchstaben[zaehler++] = buchstabe2;
+        } else {
+            System.err.println("Zu viele Vertauschungen angegeben!");
+        }
 
-    public char vertauscheBuchstaben(){
-        /*Variable um Index zu speichern*/
-        int indexA = 0;
-        int indexB = 0;
+        return ueberpruefeVertauschungen();
+    }
 
-        /*Ermittelt die Position des Buchstaben buchstabeEins auf der Alphabetswalze*/
-        for(indexA = 0; indexA < WALZE_ALPHABET.length; indexA++) {
-            if(getBuchstabeEins().equals(WALZE_ALPHABET[index])) {
-                iPositionEins = index;
-                break;
+    /**
+     *
+     * @return
+     */
+    public boolean ueberpruefeVertauschungen() {
+
+        boolean result = true;
+        for (int n = 0; n < orginalBuchstaben.length; n++) {
+            if (orginalBuchstaben.equals(orginalBuchstaben[n]) || getauschteBuchstaben.equals(orginalBuchstaben[n]) || getauschteBuchstaben.equals(getauschteBuchstaben[n])) {
+                System.err.println("Vertauschungen enthalten unzulässige Dopplungen");
+                result = false;
             }
         }
 
-        /*Ermittelt die Position des Buchstaben buchstabeZwei auf der Alphabetswalze*/
-        for(indexA = 0; index < WALZE_ALPHABET.length; index++) {
-            if(getBuchstabeEins().equals(WALZE_ALPHABET[index])) {
-                iPositionEins = index;
-                break;
+        return result;
+    }
+
+    /**
+     * 
+     * @param buchstabe
+     * @return
+     */
+    public char codiere(Character buchstabe) {
+
+        for (int index = 0; index < getauschteBuchstaben.length; index++) {
+            if (buchstabe.equals(getauschteBuchstaben[index])) {
+                buchstabe = orginalBuchstaben[index];
+            } else if (buchstabe.equals(orginalBuchstaben[index])) {
+                buchstabe = getauschteBuchstaben[index];
             }
         }
 
-
-        /*Im Char-Array WALZE_REFLEKTOR wird der Character an der Position iPositionReflektor ausgegeben*/
-        reflektorBuchstabeRaus = WALZE_REFLEKTOR[iPositionReflektor];
-        return reflektorBuchstabeRaus;
-
-
-
-
-
-        return 0;
+        return buchstabe;
     }
+
 }

src/main/java/Enigma/model/Walze.java

@@ -33,6 +33,8 @@ public class Walze {
     private int iPositionBuchstabeRe;
     private Character[] walze;
 
+
+
     /**
      * Gibt die Parameter der Walze mit
      *
@@ -46,6 +48,7 @@ public class Walze {
         this.ringstellung = ringstellung;
     }
 
+
     /**
      * Sortiert den Walzennummern das passenden Character-Array mittels switch zu.
      *
@@ -159,8 +162,7 @@ public class Walze {
      * Chiffriert den Buchstaben an der Position aus der Methode positionBuchstabe()
      * anhand der gewaehlten Walze.
      *
-     * @param iPositionBuchstabe : int : Position des zu chiffrierenden Buchstabens
-     * @param walze : Character[] : ausgewaehlte Walze
+     * @param
      * @return chiffrierterBuchstabe : Character : chiffrierter Buchstabe
      */
     public Character codiere(Character buchstabe) {
@@ -176,7 +178,7 @@ public class Walze {
      * Chiffriert den Buchstaben an der Position aus der Methode positionBuchstabeReverse()
      * anhand der AlphaWalze.
      *
-     * @param iPositionBuchstabeRe : int : Position des zu chiffrierenden Buchstabens
+     * @param
      * @return codierterBuchstabeRe : Character : chiffrierter Buchstabe
      */
     public Character codiere2(char buchstabe) {
@@ -241,5 +243,4 @@ public class Walze {
         }
     }
 
-
 }