Walze-Klasse überarbeitet

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;
+    }
+
+    public void setBuchstabeEins(Character buchstabeEins) {
+        this.buchstabeEins = buchstabeEins;
+    }
+
+    public Character getBuchstabeZwei() {
+        return buchstabeZwei;
+    }
+
+    public void setBuchstabeZwei(Character buchstabeZwei) {
+        this.buchstabeZwei = buchstabeZwei;
+    }
+
+
+
+    public char vertauscheBuchstaben(){
+        /*Variable um Index zu speichern*/
+        int indexA = 0;
+        int indexB = 0;
+
+        /*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;
+            }
+        }
+
+        /*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;
+            }
+        }
+
+
+        /*Im Char-Array WALZE_REFLEKTOR wird der Character an der Position iPositionReflektor ausgegeben*/
+        reflektorBuchstabeRaus = WALZE_REFLEKTOR[iPositionReflektor];
+        return reflektorBuchstabeRaus;
+
+
+
+
+
+        return 0;
+    }
+}

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

 package Enigma.model;
 
+/**
+ * Klasse Walze
+ *
+ * Erzeugt ein Objekt des Typs Walze mit den Eigenschaften:
+ *
+ * 1. Walzennummer (Die Walze enthält die 26 Buchstaben des Alphabeths und codiert diese.
+ * 5 verschiedene Walzen stehen zur Auswahl, die jeweils verschieden die Buchstaben des Alphabeths
+ * paarweise vertauschen)
+ *
+ * 2. Ringstellung (Umspringpunkt der Walze wird festgelegt. Der Umspringpunkt bestimmt
+ * den Drehzeitpunkt der linken Nachbarwalze)
+ *
+ */
 public class Walze {
 
+    /**
+     * Konstanten und Variablen der Klasse Walze
+     *
+     * buchstabe : Bestimmt den Buchstaben
+     * ringstellung : Bestimmt den Umspringpunkt der Walze
+     * walzennr : Bestimmt die Walzennr. (also wie der Buchstabe codiert wird)
+     * iPositionBuchstabe : gibt die Position des Buchstabens auf dem Array der Walze wieder.
+     * iPositionBuchstabeRe : gibt die Position des codierten Buchstabens im Alphabet wieder.
+     * private Character[] walze : Character-Array der Walze
+     */
+
     private Character buchstabe;
     private Character ringstellung;
     private int walzennr;
@@ -13,83 +37,15 @@ public class Walze {
      * Gibt die Parameter der Walze mit
      *
      * @param walzennr : int : Nummer der gewaehlten Walze
-     * @param buchstabe : Character : Grundeinstellung der Walze
      * @param ringstellung : Character : Einstellung des Notch
      */
-    public Walze(int walzennr, Character buchstabe, Character ringstellung) {
+    public Walze(int walzennr, Character ringstellung) {
         this.walze = new Character[25];
         this.walzennr = walzennr;
-        this.buchstabe = buchstabe;
+        this.buchstabe = 'A';
         this.ringstellung = ringstellung;
     }
 
-    /**
-     * @return buchstabe : Character : gibt den neuen Buchstaben zurueck
-     */
-    public Character getBuchstabe() {
-        return buchstabe;
-    }
-
-    /**
-     * Gibt die Grundeinstellung der Walze ein. Nur Buchstaben von A - Z sind zugelassen.
-     * Buchstaben werden automatisch in Grossbuchstaben umgewandelt.
-     * Im Fehlerfall wird die Grundeinstellung der Walze standardmaessig auf 'A' gesetzt.
-     *
-     * @param buchstabe : Character : Grundeinstellung der Walze
-     */
-    public void setBuchstabe(Character buchstabe) {
-
-        if(Character.isLetter(buchstabe)) {
-            this.buchstabe = Character.toUpperCase(buchstabe);
-        } else {
-            this.buchstabe = 'A';
-        }
-    }
-
-    /**
-     * @return ringstellung : Character : gibt die neue Ringstellung zurueck
-     */
-    public Character getRingstellung() {
-        return ringstellung;
-    }
-
-
-    /**
-     * Gibt die Initiale Ringstellung der Walze an.
-     * Es sind nur Zahlen von 1 - 26 zugelassen.
-     * Im Fehlerfall wird die Ringstellung standardmaessig auf '1' gesetzt.
-     *
-     * @param ringstellung : Character : Punkt an dem die Walze umspringt
-     */
-    public void setRingstellung(Character ringstellung) {
-
-        if(Character.isDigit(ringstellung) && ringstellung > 0 && ringstellung <= 26) {
-            this.ringstellung = ringstellung;
-        } else {
-            this.ringstellung = '1';
-        }
-    }
-
-    /**
-     * @return walzennr : int : gibt die Walzennummer zurueck
-     */
-    public int getWalzennr() {
-        return walzennr;
-    }
-
-    /**
-     * Definiert die Walze. Es stehen fuenf Walze zur Auswahl.
-     *
-     * @param walzennr : int : setzt die Walzennummer
-     */
-    public void setWalzennr(int walzennr) {
-        if(walzennr > 0 && walzennr < 6) {
-            this.walzennr = walzennr;
-        } else {
-            System.err.println("Keine gültige Walzennummer");
-        }
-    }
-
     /**
      * Sortiert den Walzennummern das passenden Character-Array mittels switch zu.
      *
@@ -104,7 +60,7 @@ public class Walze {
         Character[] walzeVier = {'E', 'S', 'O', 'V', 'P', 'Z', 'J', 'A', 'Y', 'Q', 'U', 'I', 'R', 'H', 'X', 'L', 'N', 'F', 'T', 'G', 'K', 'D', 'C', 'M', 'W', 'B'};
         Character[] walzeFuenf = {'V', 'Z', 'B', 'R', 'G', 'I', 'T', 'Y', 'U', 'P', 'S', 'D', 'N', 'H', 'L', 'X', 'A', 'W', 'M', 'J', 'Q', 'O', 'F', 'E', 'C', 'K'};
 
-        switch (getWalzennr()) {
+        switch (walzennr) {
             case 1:
                 walze = walzeEins;
                 break;
@@ -125,29 +81,80 @@ public class Walze {
         return walze;
     }
 
-    /**
-     * Ermittelt die Position des Buchstaben auf der Alphabetswalze, um die Position mit
-     * der Chiffrierung auf der gewaehlten Walze abgleichen zu koennen.
-     *
-     * @return iPositionBuchstabe : int : Position des Buchstaben im Array
-     */
-    public int positionBuchstabe() {
+
+
+    //walzenPosition() return int => Gibt die aktuelle Position des Buchstabens zurück
+    public int walzenPosition() {
 
         /*Alphabetswalze*/
-        Character[] walzeAlpha = {'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'};
+        Character[] walzeAlphabeth = {'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'};
 
         /*Ermittelt die Position des Buchstaben buchstabe auf der Alphabetswalze*/
-        for(int index = 0; index < walzeAlpha.length; index++) {
-            if(getBuchstabe().equals(walzeAlpha[index])) {
+        for(int index = 0; index < walzeAlphabeth.length; index++) {
+            if(getBuchstabe().equals(walzeAlphabeth[index])) {
                 iPositionBuchstabe = index;
                 break;
             }
         }
-
         return iPositionBuchstabe;
     }
 
 
+    //setzeNotch(int position) => Setze Startpunkt auf int Position des Buchstabens
+    // Setter für Ringstellung
+    /**
+     * Gibt die Initiale Ringstellung der Walze an.
+     * Es sind nur Zahlen von 1 - 26 zugelassen.
+     * Im Fehlerfall wird die Ringstellung standardmaessig auf '1' gesetzt.
+     *
+     * @param ringstellung : Character : Punkt an dem die Walze umspringt
+     */
+    public void setRingstellung(Character ringstellung) {
+
+        if(Character.isDigit(ringstellung) && ringstellung > 0 && ringstellung <= 26) {
+            this.ringstellung = ringstellung;
+        } else {
+            this.ringstellung = '1';
+        }
+    }
+
+    /**
+     * @return ringstellung : Character : gibt die neue Ringstellung zurueck
+     */
+    public Character getRingstellung() {
+        return ringstellung;
+    }
+
+
+
+    //dreheWalze() return boolean => Wenn Notch erreicht, gib true zurück, ansonsten false
+        public boolean dreheWalze(){
+
+        boolean checkRing;
+
+            if(iPositionBuchstabe == 25) {
+
+                iPositionBuchstabe = 0;
+
+            } else {
+
+                iPositionBuchstabe += 1;
+            }
+
+        if (iPositionBuchstabe == getRingstellung()){
+
+            checkRing = true;
+
+        }else{
+
+            checkRing = false;
+        }
+
+        return checkRing;
+    }
+
+
+    //codiere(char buchstabe) return char => Gibt den verschlüsselten Buchstaben zurück
     /**
      * Chiffriert den Buchstaben an der Position aus der Methode positionBuchstabe()
      * anhand der gewaehlten Walze.
@@ -156,64 +163,83 @@ public class Walze {
      * @param walze : Character[] : ausgewaehlte Walze
      * @return chiffrierterBuchstabe : Character : chiffrierter Buchstabe
      */
-    public Character codiereBuchstabe(int iPositionBuchstabe, Character[] walze) {
-        Character codierterBuchstabe = walze[iPositionBuchstabe];
+    public Character codiere(Character buchstabe) {
+        setBuchstabe(buchstabe);
+        walzenPosition();
+        Character codierterBuchstabe = walzenNummer()[iPositionBuchstabe];
         return codierterBuchstabe;
     }
 
 
+    //codiere2(char buchstabe) => Gibt den vertauschten Buchstaben zurück (Reverse)
     /**
-     * Nimmt die Startposition, die aus der Walzeneinstellung geholt wird und
-     * erhoeht sie um eins.
-     * Die Variable wird ueberschrieben und zaehlt von nun an die Position mit.
-     * Ab Position 25 wird wieder bei 0 angefangen.
+     * Chiffriert den Buchstaben an der Position aus der Methode positionBuchstabeReverse()
+     * anhand der AlphaWalze.
      *
-     * @param iPositionBuchstabe : int : alte Position der Walze
-     * @return iPositionBuchstabe : int : neue Position der Walze
+     * @param iPositionBuchstabeRe : int : Position des zu chiffrierenden Buchstabens
+     * @return codierterBuchstabeRe : Character : chiffrierter Buchstabe
      */
-    public int vorstellenDerWalze(int iPositionBuchstabe) {
+    public Character codiere2(char buchstabe) {
 
-        if(iPositionBuchstabe == 25) {
-            iPositionBuchstabe = 0;
-        } else {
-            iPositionBuchstabe += 1;
+        /*Alphawalze*/
+        Character[] walzeAlpha = {'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'};
+
+        setBuchstabe(buchstabe);
+
+        /*Ermittelt die Position des Buchstaben buchstabe auf der Alphabetswalze*/
+        for(int index = 0; index < walzenNummer().length; index++) {
+            if(getBuchstabe().equals(walzenNummer()[index])) {
+                iPositionBuchstabeRe = index;
+                break;
+            }
         }
 
-        return iPositionBuchstabe;
+        Character codierterBuchstabeRe = walzeAlpha[iPositionBuchstabeRe];
+        return codierterBuchstabeRe;
+
+
+    }
+
+//_________________________________________________________________________________________
+
+
+    /**
+     * @return buchstabe : Character : gibt den neuen Buchstaben zurueck
+     */
+    public Character getBuchstabe() {
+        return buchstabe;
     }
 
     /**
-     * Ermittelt die Position des Buchstaben auf der gewaehlten Walze, um die Position mit
-     * der Chiffrierung auf der AlphaWalze abgleichen zu koennen.
+     * Gibt die Grundeinstellung der Walze ein. Nur Buchstaben von A - Z sind zugelassen.
+     * Buchstaben werden automatisch in Grossbuchstaben umgewandelt.
+     * Im Fehlerfall wird die Grundeinstellung der Walze standardmaessig auf 'A' gesetzt.
      *
-     * @param walzennr : int : gibt die gewaehlte Walze zurueck
-     * @return iPositionBuchstabeRe : int : Position des Buchstaben im Array
+     * @param buchstabe : Character : Grundeinstellung der Walze
      */
-    public int positionBuchstabeReverse(int walzennr) {
+    public void setBuchstabe(Character buchstabe) {
 
-        /*Ermittelt die Position des Buchstaben buchstabe auf der Alphabetswalze*/
-        for(int index = 0; index < walze.length; index++) {
-            if(getBuchstabe().equals(walze[index])) {
-                iPositionBuchstabeRe = index;
-                break;
-            }
+        if(Character.isLetter(buchstabe)) {
+            this.buchstabe = Character.toUpperCase(buchstabe);
+        } else {
+            this.buchstabe = 'A';
         }
-        return iPositionBuchstabeRe;
     }
 
+
+    //TODO: ??? Brauchen wir Setter, wo findet Überprüfung der Walzennr. statt.
     /**
-     * Chiffriert den Buchstaben an der Position aus der Methode positionBuchstabeReverse()
-     * anhand der AlphaWalze.
+     * Definiert die Walze. Es stehen fuenf Walze zur Auswahl.
      *
-     * @param iPositionBuchstabeRe : int : Position des zu chiffrierenden Buchstabens
-     * @return codierterBuchstabeRe : Character : chiffrierter Buchstabe
+     * @param walzennr : int : setzt die Walzennummer
      */
-    public Character codierterBuchstabeReverse(int iPositionBuchstabeRe) {
-        /*Alphawalze*/
-        Character[] walzeAlpha = {'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'};
-
-        Character codierterBuchstabeRe = walzeAlpha[iPositionBuchstabeRe];
-        return codierterBuchstabeRe;
+    public void setWalzennr(int walzennr) {
+        if(walzennr > 0 && walzennr < 6) {
+            this.walzennr = walzennr;
+        } else {
+            System.err.println("Keine gültige Walzennummer");
+        }
     }
 
+
 }