diff --git a/src/main/java/Enigma/model/Steckbrett.java b/src/main/java/Enigma/model/Steckbrett.java
new file mode 100644
index 0000000000000000000000000000000000000000..804c20328c2f1c9740bf7563a0e1133394e027f3
--- /dev/null
+++ b/src/main/java/Enigma/model/Steckbrett.java
@@ -0,0 +1,61 @@
+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;
+ }
+}
diff --git a/src/main/java/Enigma/model/Walze.java b/src/main/java/Enigma/model/Walze.java
index 9ad536e3a3a67ec8f1f75500d4c66799aa893614..886b1cb3158e84b0f5a293c60f07f3aa4ffa96b1 100644
--- a/src/main/java/Enigma/model/Walze.java
+++ b/src/main/java/Enigma/model/Walze.java
@@ -1,7 +1,31 @@
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");
+ }
}
+
}