diff --git a/src/main/java/Enigma/model/Codebuch.java b/src/main/java/Enigma/model/Codebuch.java
index c32345ed483066ea6daa01e4d0f9bc88776e49f0..3ef5e25be47442b10fec91bad94bb60d3070cb43 100644
--- a/src/main/java/Enigma/model/Codebuch.java
+++ b/src/main/java/Enigma/model/Codebuch.java
@@ -5,7 +5,7 @@ package Enigma.model;
* Jeder Enigma gehörte auch ein Codebuch bei, welches notwenidg war um die Nachrichten zu ver/entschlüsseln.
* Im Codebuch standen für jeden Tag des Monats die notwendigen Einstellungen welche vorgenommen werden
* mussten um die Texte zu ver/entschlüsseln.
- * Hiernach wurden die Walzen eingesetzt, die Ringe für den Rücksprung der Walzen gesetzt und deren Grundeinstellung
+ * Hiernach wurden die Walzen eingesetzt, die Ringe für den Rücksprung der Walze gesetzt und deren Grundeinstellung
* vorgenommen.
* Bei der Enigma um welche es hier geht (Enigma I) gab es zusätzlich ein Steckbrett, welches ebenfalls im Codebuch
* festgelegt war.
diff --git a/src/main/java/Enigma/model/Walze.java b/src/main/java/Enigma/model/Walze.java
new file mode 100644
index 0000000000000000000000000000000000000000..2d72adc6bf887c4593b4c591b2aaf1c7eba020de
--- /dev/null
+++ b/src/main/java/Enigma/model/Walze.java
@@ -0,0 +1,224 @@
+package Enigma.model;
+
+public class Walze {
+
+ Character buchstabe = null;
+ Character ringstellung = null;
+ int walzennr = 0;
+ int iPositionBuchstabe = 0;
+ int iPositionBuchstabeRe = 0;
+ Character[] walze = new Character[25];
+
+ /**
+ * 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) {
+ this.walzennr = walzennr;
+ this.buchstabe = buchstabe;
+ this.ringstellung = ringstellung;
+ }
+
+ /**
+ * @return buchstabe : Character : gibt den neuen Buchstaben zurueck
+ */
+ public char 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
+ */
+ private void setBuchstabe(Character buchstabe) {
+ this.buchstabe.toUpperCase(buchstabe);
+
+ if(buchstabe.isLetter(buchstabe)) {
+ this.buchstabe = buchstabe;
+ } else {
+ this.buchstabe = 'A';
+ }
+
+ }
+
+ /**
+ * @return ringstellung : Character : gibt die neue Ringstellung zurueck
+ */
+ public char 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
+ */
+ private void setRingstellung(Character ringstellung) {
+
+ if(buchstabe.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
+ */
+ private 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.
+ *
+ * @return walze : Character[] : gibt die gewaehlte Walze zurueck
+ */
+ private Character[] walzenNummer() {
+
+ //Walze nach der Cheffrierung
+ Character[] walzeEins = {'E','K', 'M', 'F', 'L', 'G', 'D', 'Q', 'V', 'Z', 'N', 'T', 'O', 'W', 'Y', 'H', 'X', 'U', 'S', 'P', 'A', 'I', 'B', 'R', 'C', 'J'};
+ Character[] walzeZwei = {'A', 'J', 'D', 'K', 'S', 'I', 'R', 'U', 'X', 'B', 'L', 'H', 'W', 'T', 'M', 'C', 'Q', 'G', 'Z', 'N', 'P', 'Y', 'F', 'V', 'O', 'E'};
+ Character[] walzeDrei = {'B', 'D', 'F', 'H', 'J', 'L', 'C', 'P', 'R', 'T', 'X', 'V', 'Z', 'N', 'Y', 'E', 'I', 'W', 'G', 'A', 'K', 'M', 'U', 'S', 'Q', 'O'};
+ 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()) {
+ case 1:
+ walze = walzeEins;
+ break;
+ case 2:
+ walze = walzeZwei;
+ break;
+ case 3:
+ walze = walzeDrei;
+ break;
+ case 4:
+ walze = walzeVier;
+ break;
+ case 5:
+ walze = walzeFuenf;
+ break;
+ }
+
+ return walze;
+ }
+
+ /**
+ * Ermittelt die Position des Buchstaben auf der Alphabetswalze, um die Position mit
+ * der Cheffrierung auf der gewaehlten Walze abgleichen zu koennen.
+ *
+ * @return iPositionBuchstabe : int : Position des Buchstaben im Array
+ */
+ public int positionBuchstabe() {
+
+ //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'};
+
+ int index = 0;
+
+ //Ermittelt die Position des Buchstaben buchstabe auf der Alphabetswalze
+ for(index = 0; index < walzeAlpha.length; index++) {
+ if(buchstabe.equals(walzeAlpha[index])) {
+ iPositionBuchstabe = index;
+ break;
+ }
+ }
+
+ return iPositionBuchstabe;
+ }
+
+
+ /**
+ * Cheffriert den Buchstaben an der Position aus der Methode positionBuchstabe()
+ * anhand der gewaehlten Walze.
+ *
+ * @param iPositionBuchstabe : int : Position des zu cheffrierenden Buchstabens
+ * @param walze : Character[] : ausgewaehlte Walze
+ * @return cheffrierterBuchstabe : Character : cheffrierter Buchstabe
+ */
+ public Character codierterBuchstabe(int iPositionBuchstabe, Character[] walze) {
+ Character codierterBuchstabe = walze[iPositionBuchstabe];
+ return codierterBuchstabe;
+ }
+
+
+ /**
+ * 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.
+ *
+ * @param iPositionBuchstabe : int : alte Position der Walze
+ * @return iPositionBuchstabe : int : neue Position der Walze
+ */
+ public int vorstellenDerWalze(int iPositionBuchstabe) {
+
+ if(iPositionBuchstabe == 25) {
+ iPositionBuchstabe = 0;
+ } else {
+ iPositionBuchstabe += 1;
+ }
+
+ return iPositionBuchstabe;
+ }
+
+ /**
+ * Ermittelt die Position des Buchstaben auf der gewaehlten Walze, um die Position mit
+ * der Cheffrierung auf der AlphaWalze abgleichen zu koennen.
+ *
+ * @param walzennr : int : gibt die gewaehlte Walze zurueck
+ * @return iPositionBuchstabeRe : int : Position des Buchstaben im Array
+ */
+ public int positionBuchstabeReverse(int walzennr) {
+
+ int index = 0;
+
+ //Ermittelt die Position des Buchstaben buchstabe auf der Alphabetswalze
+ for(index = 0; index < walze.length; index++) {
+ if(buchstabe.equals(walze[index])) {
+ iPositionBuchstabeRe = index;
+ break;
+ }
+ }
+ return iPositionBuchstabeRe;
+ }
+
+ /**
+ * Cheffriert den Buchstaben an der Position aus der Methode positionBuchstabeReverse()
+ * anhand der AlphaWalze.
+ *
+ * @param iPositionBuchstabeRe : int : Position des zu cheffrierenden Buchstabens
+ * @return codierterBuchstabeRe : Character : cheffrierter Buchstabe
+ */
+ 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;
+ }
+
+}