From 1aad276d6f40f7b70cdf6bfc45372ea5fe66a2f2 Mon Sep 17 00:00:00 2001
From: Dennis Eisold <de@itstall.de>
Date: Tue, 26 Nov 2019 22:45:02 +0100
Subject: [PATCH 01/10] Gitlab-CI Test

---
 .gitlab-ci.yml | 27 +++++++++++++++++++--------
 1 file changed, 19 insertions(+), 8 deletions(-)

diff --git a/.gitlab-ci.yml b/.gitlab-ci.yml
index 649bec9..9a8ae4f 100644
--- a/.gitlab-ci.yml
+++ b/.gitlab-ci.yml
@@ -1,11 +1,22 @@
 image: maven:latest
 
-java:
+stages:
+  - build
+  - test
+  - deploy
+
+job build dependencies:
+  stage: build
+  script: make build dependencies
+
+job build artifacts:
+  stage: build
+  script: make build artifacts
+
+job test:
   stage: test
-  script:
-  - mvn verify
-  artifacts:
-    reports:
-      junit:
-        - target/surefire-reports/TEST-*.xml
-        - target/failsafe-reports/TEST-*.xml
\ No newline at end of file
+  script: make test
+
+job deploy:
+  stage: deploy
+  script: make deploy
-- 
GitLab


From 6eb3f856e0f7294bbdce32fa758ee14b2b2edd48 Mon Sep 17 00:00:00 2001
From: Dennis Eisold <de@itstall.de>
Date: Tue, 26 Nov 2019 22:46:29 +0100
Subject: [PATCH 02/10] Gitlab-CI Test

---
 .gitlab-ci.yml | 8 ++++----
 1 file changed, 4 insertions(+), 4 deletions(-)

diff --git a/.gitlab-ci.yml b/.gitlab-ci.yml
index 9a8ae4f..a052fdd 100644
--- a/.gitlab-ci.yml
+++ b/.gitlab-ci.yml
@@ -7,16 +7,16 @@ stages:
 
 job build dependencies:
   stage: build
-  script: make build dependencies
+  script: mvn build dependencies
 
 job build artifacts:
   stage: build
-  script: make build artifacts
+  script: mvn build artifacts
 
 job test:
   stage: test
-  script: make test
+  script: mvn test
 
 job deploy:
   stage: deploy
-  script: make deploy
+  script: mvn deploy
-- 
GitLab


From 7c22a3d8d6e913029989150b22161096d3c2cea9 Mon Sep 17 00:00:00 2001
From: Dennis Eisold <de@itstall.de>
Date: Tue, 26 Nov 2019 22:48:52 +0100
Subject: [PATCH 03/10] Gitlab-CI Test

---
 .gitlab-ci.yml | 11 ++++++-----
 1 file changed, 6 insertions(+), 5 deletions(-)

diff --git a/.gitlab-ci.yml b/.gitlab-ci.yml
index a052fdd..a6884d3 100644
--- a/.gitlab-ci.yml
+++ b/.gitlab-ci.yml
@@ -1,17 +1,18 @@
 image: maven:latest
 
 stages:
+  - clean
   - build
   - test
   - deploy
 
-job build dependencies:
-  stage: build
-  script: mvn build dependencies
+job clean:
+  stage: clean
+  script: mvn clean
 
-job build artifacts:
+job compile:
   stage: build
-  script: mvn build artifacts
+  script: mvn compile
 
 job test:
   stage: test
-- 
GitLab


From 3947f267678c3af508619d4ab0434bc62ac077e5 Mon Sep 17 00:00:00 2001
From: Dennis Eisold <de@itstall.de>
Date: Tue, 26 Nov 2019 22:54:52 +0100
Subject: [PATCH 04/10] Gitlab-CI Test

---
 .gitlab-ci.yml | 2 +-
 1 file changed, 1 insertion(+), 1 deletion(-)

diff --git a/.gitlab-ci.yml b/.gitlab-ci.yml
index a6884d3..6651f57 100644
--- a/.gitlab-ci.yml
+++ b/.gitlab-ci.yml
@@ -20,4 +20,4 @@ job test:
 
 job deploy:
   stage: deploy
-  script: mvn deploy
+  script: mvn assembly:assembly
-- 
GitLab


From 2a774853240319a0d0ca4e072d7e9cbd232bff5c Mon Sep 17 00:00:00 2001
From: Dennis Eisold <de@itstall.de>
Date: Tue, 26 Nov 2019 23:07:19 +0100
Subject: [PATCH 05/10] Gitlab-CI Test

---
 .gitlab-ci.yml | 15 ++++++++++-----
 1 file changed, 10 insertions(+), 5 deletions(-)

diff --git a/.gitlab-ci.yml b/.gitlab-ci.yml
index 6651f57..1b9bfde 100644
--- a/.gitlab-ci.yml
+++ b/.gitlab-ci.yml
@@ -6,18 +6,23 @@ stages:
   - test
   - deploy
 
-job clean:
+Clean Project files:
   stage: clean
   script: mvn clean
 
-job compile:
+Compile new version:
   stage: build
   script: mvn compile
 
-job test:
+Run JUnit tests and verify:
   stage: test
-  script: mvn test
+  script: mvn verify
+  artifacts:
+    reports:
+      junit:
+      - target/surefire-reports/TEST-*.xml
+      - target/failsafe-reports/TEST-*.xml
 
-job deploy:
+Deploy new version as Release:
   stage: deploy
   script: mvn assembly:assembly
-- 
GitLab


From 7732b87f545ce075f66bbc8c2174c4868cc4ff32 Mon Sep 17 00:00:00 2001
From: Dennis Eisold <de@itstall.de>
Date: Tue, 26 Nov 2019 23:38:05 +0100
Subject: [PATCH 06/10] Update README.md

---
 README.md | 2 ++
 1 file changed, 2 insertions(+)

diff --git a/README.md b/README.md
index a0199f8..940811b 100644
--- a/README.md
+++ b/README.md
@@ -1 +1,3 @@
+[![pipeline status](https://www.gitrepo.de/alfatrainingkurse/java/enigma/badges/master/pipeline.svg)](https://www.gitrepo.de/alfatrainingkurse/java/enigma/commits/master)
+
 Link zum [Wiki](https://www.gitrepo.de/alfatrainingkurse/java/enigma/wikis/home)
\ No newline at end of file
-- 
GitLab


From 2ea318ce68db580af2130dfdd2ee3e7105a3200d Mon Sep 17 00:00:00 2001
From: Dennis Eisold <de@itstall.de>
Date: Wed, 27 Nov 2019 00:04:19 +0100
Subject: [PATCH 07/10] Gitlab-CI Test

---
 .gitlab-ci.yml | 4 +++-
 1 file changed, 3 insertions(+), 1 deletion(-)

diff --git a/.gitlab-ci.yml b/.gitlab-ci.yml
index 1b9bfde..a9cdd0d 100644
--- a/.gitlab-ci.yml
+++ b/.gitlab-ci.yml
@@ -25,4 +25,6 @@ Run JUnit tests and verify:
 
 Deploy new version as Release:
   stage: deploy
-  script: mvn assembly:assembly
+  script:
+    - mvn versions:set -DnewVersion=$CI_COMMIT_TAG
+    - mvn assembly:assembly
-- 
GitLab


From 2280ecc567fd1f3f19d9a8aab1fac593d88a3cdd Mon Sep 17 00:00:00 2001
From: Dennis Eisold <de@itstall.de>
Date: Wed, 27 Nov 2019 09:28:06 +0100
Subject: [PATCH 08/10] =?UTF-8?q?Unit=20Tests=20f=C3=BCr=20Reflektor,=20Wl?=
 =?UTF-8?q?aze=20und=20Steckbrett?=
MIME-Version: 1.0
Content-Type: text/plain; charset=UTF-8
Content-Transfer-Encoding: 8bit

---
 src/test/java/Enigma/model/ReflektorTest.java |  4 ----
 .../java/Enigma/model/SteckbrettTest.java     | 12 +++++------
 src/test/java/Enigma/model/WalzeTest.java     | 20 +++++++++----------
 3 files changed, 16 insertions(+), 20 deletions(-)

diff --git a/src/test/java/Enigma/model/ReflektorTest.java b/src/test/java/Enigma/model/ReflektorTest.java
index 74ab4f6..dbaaa52 100644
--- a/src/test/java/Enigma/model/ReflektorTest.java
+++ b/src/test/java/Enigma/model/ReflektorTest.java
@@ -7,7 +7,6 @@ public class ReflektorTest {
 
 	@Test
 	public void codiere() {
-		/*
 		Reflektor r = new Reflektor();
 
 		Assert.assertEquals('E', r.codiere('A'));
@@ -16,18 +15,15 @@ public class ReflektorTest {
 		Assert.assertEquals('O', r.codiere('Q'));
 		Assert.assertEquals('I', r.codiere('V'));
 		//Assert.assertNull(null, r.codiere(null));
-		*/
 	}
 
 	@Test
 	public void codiere2() {
-		/*
 		Reflektor r = new Reflektor();
 		Assert.assertEquals('A', r.codiere('E'));
 		Assert.assertEquals('D', r.codiere('Z'));
 		Assert.assertEquals('H', r.codiere('X'));
 		Assert.assertEquals('Q', r.codiere('O'));
 		Assert.assertEquals('V', r.codiere('I'));
-		*/
 	}
 }
\ No newline at end of file
diff --git a/src/test/java/Enigma/model/SteckbrettTest.java b/src/test/java/Enigma/model/SteckbrettTest.java
index df6051d..114294f 100644
--- a/src/test/java/Enigma/model/SteckbrettTest.java
+++ b/src/test/java/Enigma/model/SteckbrettTest.java
@@ -9,28 +9,28 @@ public class SteckbrettTest {
 
 	@Test
 	public void setzeVertauschung() {
-		/*Steckbrett sb = new Steckbrett();
+		Steckbrett sb = new Steckbrett();
 		sb.setzeVertauschung('A', 'G');
 		sb.setzeVertauschung('C', 'H');
 		Assert.assertEquals('H', sb.codiere('C'));
-		Assert.assertEquals('G', sb.codiere('A'));*/
+		Assert.assertEquals('G', sb.codiere('A'));
 	}
 
 	@Test
 	public void codiere() {
-		/*Steckbrett sb = new Steckbrett();
+		Steckbrett sb = new Steckbrett();
 		sb.setzeVertauschung('A', 'G');
 		sb.setzeVertauschung('C', 'H');
 		Assert.assertEquals('H', sb.codiere('C'));
-		Assert.assertEquals('G', sb.codiere('A'));*/
+		Assert.assertEquals('G', sb.codiere('A'));
 	}
 
 	@Test
 	public void codiere2() {
-		/*Steckbrett sb = new Steckbrett();
+		Steckbrett sb = new Steckbrett();
 		sb.setzeVertauschung('A', 'G');
 		sb.setzeVertauschung('C', 'H');
 		Assert.assertEquals('C', sb.codiere2('H'));
-		Assert.assertEquals('A', sb.codiere2('G'));*/
+		Assert.assertEquals('A', sb.codiere2('G'));
 	}
 }
\ No newline at end of file
diff --git a/src/test/java/Enigma/model/WalzeTest.java b/src/test/java/Enigma/model/WalzeTest.java
index 1c58136..5b526b6 100644
--- a/src/test/java/Enigma/model/WalzeTest.java
+++ b/src/test/java/Enigma/model/WalzeTest.java
@@ -9,37 +9,37 @@ public class WalzeTest {
 
 	@Test
 	public void setzeNotch() {
-		/*Walze w = new Walze(1);
+		Walze w = new Walze(1);
 		w.setzeNotch('G');
-		Assert.assertEquals('G', w.wlazenPosition());*/
+		Assert.assertEquals('G', w.wlazenPosition());
 	}
 
 	@Test
 	public void dreheWalze() {
-		/*Walze w = new Walze(1);
+		Walze w = new Walze(1);
 		w.setzeNotch('G');
 		w.dreheWalze();
-		Assert.assertEquals('H', w.wlazenPosition());*/
+		Assert.assertEquals('H', w.wlazenPosition());
 	}
 
 	@Test
 	public void walzenPoition() {
-		/*Walze w = new Walze(1);
+		Walze w = new Walze(1);
 		w.setzeNotch('G');
-		Assert.assertEquals('G', w.wlazenPosition());*/
+		Assert.assertEquals('G', w.wlazenPosition());
 	}
 
 	@Test
 	public void codiere() {
-		/*Walze w = new Walze(1);
+		Walze w = new Walze(1);
 		w.setzeNotch('A');
-		Assert.assertEquals('E', w.codiere('A'));*/
+		Assert.assertEquals('E', w.codiere('A'));
 	}
 
 	@Test
 	public void codiere2() {
-		/*Walze w = new Walze(1);
+		Walze w = new Walze(1);
 		w.setzeNotch('A');
-		Assert.assertEquals('A', w.codiere('E'));*/
+		Assert.assertEquals('A', w.codiere('E'));
 	}
 }
\ No newline at end of file
-- 
GitLab


From 8abc13fc02c80e5a99f290e6f475f783fb8d0fb8 Mon Sep 17 00:00:00 2001
From: Dennis Eisold <de@itstall.de>
Date: Wed, 27 Nov 2019 14:16:41 +0100
Subject: [PATCH 09/10] Hardware Klasse angelegt.

---
 src/main/java/Enigma/model/Hardware.java | 120 +++++++++++++++++++++++
 1 file changed, 120 insertions(+)
 create mode 100644 src/main/java/Enigma/model/Hardware.java

diff --git a/src/main/java/Enigma/model/Hardware.java b/src/main/java/Enigma/model/Hardware.java
new file mode 100644
index 0000000..12f208e
--- /dev/null
+++ b/src/main/java/Enigma/model/Hardware.java
@@ -0,0 +1,120 @@
+package Enigma.model;
+
+public class Hardware {
+
+	private Walze[] walzen;
+	private Steckbrett steckbrett;
+	private Reflektor reflektor;
+	private String nachricht;
+	private String kenngruppe;
+
+	/**
+	 * Setzt eine Walze ein
+	 *
+	 * @param walze    : int : Setzt die Walze mit der angegebenen Nummer ein
+	 * @param walzenNr : int : Die Nummer der einzusetzenden Walze
+	 */
+	public void setzeWalzenNr(int walze, int walzenNr) {
+	}
+
+	/**
+	 * 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) {
+	}
+
+	/**
+	 * Setzt den Startwert (position) der Walze (walze)
+	 *
+	 * @param walze
+	 * @param buchstabe
+	 */
+	public void setzePosition(int walze, char buchstabe) {
+	}
+
+	// Befehl die Nachricht an den Funker zu übergeben
+	public void sendeNachricht() {
+		new Funkraum().sendeFunkspruch(new Morsecode().convertBuchstabeToMorsecode(this.nachricht), this.kenngruppe);
+	}
+
+	/**
+	 * Gibt die letzte empfangene Nachricht zurück
+	 * <p>
+	 * String[0] = Die verschlüsselte Nachricht
+	 * String[1] = Nachricht im Klartext
+	 */
+	public String[] empfangeNachricht() {
+		String[] result = new String[2];
+
+		return result;
+	}
+
+	/**
+	 * Fügt die gedrückte Taste der Nachricht hinzu
+	 *
+	 * @param buchstabe char : Der zu verschlüsselnde Buchstabe
+	 * @return char : Der verschlüsselte Buchstabe
+	 */
+	public char tippeBuchstabe(char buchstabe) {
+		buchstabe = this.steckbrett.codiere(buchstabe);
+		buchstabe = this.walzen[1].codiere(buchstabe);
+		buchstabe = this.walzen[2].codiere(buchstabe);
+		buchstabe = this.walzen[3].codiere(buchstabe);
+		buchstabe = this.reflektor.codiere(buchstabe);
+		buchstabe = this.walzen[3].codiere2(buchstabe);
+		buchstabe = this.walzen[2].codiere2(buchstabe);
+		buchstabe = this.walzen[1].codiere2(buchstabe);
+		buchstabe = this.steckbrett.codiere2(buchstabe);
+
+		this.nachricht += buchstabe;
+
+		return buchstabe;
+	}
+
+	/**
+	 * Nachricht entschlüsseln
+	 *
+	 * @param nachricht : String : Verschlüsselte Nachricht
+	 * @return String : Die Klartext Nachricht
+	 */
+	private String decodiereNachricht(String nachricht) {
+		String result = "";
+
+		return result;
+	}
+
+	public Walze[] getWalzen() {
+		return this.walzen;
+	}
+
+	public void setWalzen(int walze, int position, char ringstellung) {
+		this.walzen[position] = new Walze(walze, ringstellung);
+	}
+
+	public Steckbrett getSteckbrett() {
+		return steckbrett;
+	}
+
+	public void setSteckbrett(Steckbrett steckbrett) {
+		this.steckbrett = steckbrett;
+	}
+
+	public Reflektor getReflektor() {
+		return reflektor;
+	}
+
+	public void setReflektor(Reflektor reflektor) {
+		this.reflektor = reflektor;
+	}
+
+	public String getKenngruppe() {
+		return kenngruppe;
+	}
+
+	public void setKenngruppe(String kenngruppe) {
+		this.kenngruppe = kenngruppe;
+	}
+}
-- 
GitLab


From 14d6247514ffc859a436e86160a04ce84d7aa656 Mon Sep 17 00:00:00 2001
From: Dennis Eisold <de@itstall.de>
Date: Wed, 27 Nov 2019 16:21:43 +0100
Subject: [PATCH 10/10] =?UTF-8?q?Fixes=20f=C3=BCr=20codier=20Funktionen=20?=
 =?UTF-8?q?und=20Tests=20f=C3=BCr=20Hardware=20Klasse?=
MIME-Version: 1.0
Content-Type: text/plain; charset=UTF-8
Content-Transfer-Encoding: 8bit

---
 src/main/java/Enigma/App.java             |  37 +-
 src/main/java/Enigma/model/Hardware.java  |  14 +-
 src/main/java/Enigma/model/Morsecode.java |   1 -
 src/main/java/Enigma/model/Walze.java     | 416 +++++++++++-----------
 4 files changed, 250 insertions(+), 218 deletions(-)

diff --git a/src/main/java/Enigma/App.java b/src/main/java/Enigma/App.java
index 1e8c809..397e3da 100644
--- a/src/main/java/Enigma/App.java
+++ b/src/main/java/Enigma/App.java
@@ -1,5 +1,8 @@
 package Enigma;
 
+import Enigma.model.Codebuch;
+import Enigma.model.DatenbankSqlite;
+import Enigma.model.Hardware;
 import javafx.application.Application;
 import javafx.fxml.FXMLLoader;
 import javafx.scene.Parent;
@@ -7,6 +10,9 @@ import javafx.scene.Scene;
 import javafx.stage.Stage;
 
 import java.io.IOException;
+import java.sql.SQLException;
+import java.util.Calendar;
+import java.util.TimeZone;
 
 /**
  * JavaFX App
@@ -14,13 +20,15 @@ import java.io.IOException;
 public class App extends Application {
 
     private static Scene scene;
+    private Codebuch cb;
+    private Hardware h;
 
     @Override
     public void start(Stage stage) throws IOException {
         scene = new Scene(loadFXML("gui"));
         stage.setScene(scene);
         stage.show();
-
+        holeCodebuch();
     }
 
     static void setRoot(String fxml) throws IOException {
@@ -36,4 +44,31 @@ public class App extends Application {
         Application.launch();
     }
 
+    public void holeCodebuch() {
+        Calendar calendar = Calendar.getInstance(TimeZone.getDefault());
+
+        try {
+            this.cb = new DatenbankSqlite().getCodebuch(Calendar.DATE);
+        } catch (SQLException ignored) { }
+
+        for(int i = 0; i < 3; i++) {
+            h.setWalzen(i + 1, Integer.parseInt(cb.getWalzenlage()[i]), cb.getRingstellung()[i].charAt(0));
+        }
+
+        /*Walze w1 = new Walze(3);
+		w1.setzeNotch(13);
+		Walze w2 = new Walze(5);
+		w2.setzeNotch(1);
+		Walze w3 = new Walze(1);
+		w3.setzeNotch(20);
+		Reflektor r = new Reflektor();
+		Steckbrett sb = new Steckbrett();
+
+		if(w1.dreheWalze()) {
+			if(w2.dreheWalze()) {
+				w3.dreheWalze();
+			}
+		}*/
+    }
+
 }
\ No newline at end of file
diff --git a/src/main/java/Enigma/model/Hardware.java b/src/main/java/Enigma/model/Hardware.java
index 12f208e..4280ddc 100644
--- a/src/main/java/Enigma/model/Hardware.java
+++ b/src/main/java/Enigma/model/Hardware.java
@@ -1,5 +1,9 @@
 package Enigma.model;
 
+import org.apache.http.HttpException;
+
+import java.io.IOException;
+
 public class Hardware {
 
 	private Walze[] walzen;
@@ -8,6 +12,10 @@ public class Hardware {
 	private String nachricht;
 	private String kenngruppe;
 
+	public Hardware() {
+		this.walzen = new Walze[4];
+	}
+
 	/**
 	 * Setzt eine Walze ein
 	 *
@@ -36,7 +44,7 @@ public class Hardware {
 	}
 
 	// Befehl die Nachricht an den Funker zu übergeben
-	public void sendeNachricht() {
+	public void sendeNachricht() throws IOException, HttpException {
 		new Funkraum().sendeFunkspruch(new Morsecode().convertBuchstabeToMorsecode(this.nachricht), this.kenngruppe);
 	}
 
@@ -67,7 +75,7 @@ public class Hardware {
 		buchstabe = this.walzen[3].codiere2(buchstabe);
 		buchstabe = this.walzen[2].codiere2(buchstabe);
 		buchstabe = this.walzen[1].codiere2(buchstabe);
-		buchstabe = this.steckbrett.codiere2(buchstabe);
+		buchstabe = this.steckbrett.codiere(buchstabe);
 
 		this.nachricht += buchstabe;
 
@@ -90,7 +98,7 @@ public class Hardware {
 		return this.walzen;
 	}
 
-	public void setWalzen(int walze, int position, char ringstellung) {
+	public void setWalzen(int walze, int position, int ringstellung) {
 		this.walzen[position] = new Walze(walze, ringstellung);
 	}
 
diff --git a/src/main/java/Enigma/model/Morsecode.java b/src/main/java/Enigma/model/Morsecode.java
index f8c759c..38e2b1f 100644
--- a/src/main/java/Enigma/model/Morsecode.java
+++ b/src/main/java/Enigma/model/Morsecode.java
@@ -93,7 +93,6 @@ public class Morsecode {
 	 */
 	private String getBuchstabe(String morsecode) {
 		// Initialisieren des Rückgabe Strings
-		// TODO: Darf bei der Initialisierung gleich einen Wert setzten lauf JAVA Konventionen?
 		String result = null;
 
 		// Loopt duch die Codemap und erstellt daraus ein Set
diff --git a/src/main/java/Enigma/model/Walze.java b/src/main/java/Enigma/model/Walze.java
index 86cf8f4..f12de2a 100644
--- a/src/main/java/Enigma/model/Walze.java
+++ b/src/main/java/Enigma/model/Walze.java
@@ -1,246 +1,236 @@
 package Enigma.model;
 
+import java.time.Year;
+
 /**
  * Klasse Walze
- *
+ * <p>
  * Erzeugt ein Objekt des Typs Walze mit den Eigenschaften:
- *
+ * <p>
  * 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)
- *
+ * <p>
  * 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;
-    private int iPositionBuchstabe;
-    private int iPositionBuchstabeRe;
-    private Character[] walze;
-
-
-
-    /**
-     * Gibt die Parameter der Walze mit
-     *
-     * @param walzennr : int : Nummer der gewaehlten Walze
-     * @param ringstellung : Character : Einstellung des Notch
-     */
-    public Walze(int walzennr, Character ringstellung) {
-        this.walze = new Character[25];
-        this.walzennr = walzennr;
-        this.buchstabe = 'A';
-        this.ringstellung = ringstellung;
-    }
-
-
-    /**
-     * Sortiert den Walzennummern das passenden Character-Array mittels switch zu.
-     *
-     * @return walze : Character[] : gibt die gewaehlte Walze zurueck
-     */
-    private Character[] walzenNummer() {
-
-        /*Walze nach der Chiffrierung*/
-        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 (walzennr) {
-            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;
-    }
-
-
-
-    //walzenPosition() return int => Gibt die aktuelle Position des Buchstabens zurück
-    public int walzenPosition() {
+	/**
+	 * Konstanten und Variablen der Klasse Walze
+	 * <p>
+	 * 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
+	 */
+    /*Alphawalze*/
+    private final static 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'};
+	private Character buchstabe;
+	private int ringstellung;
+	private int walzennr;
+	private int iPositionBuchstabe;
+	private int iPositionBuchstabeRe;
+	private Character[] walze;
+
+
+	/**
+	 * Gibt die Parameter der Walze mit
+	 *
+	 * @param walzennr     : int : Nummer der gewaehlten Walze
+	 * @param ringstellung : Character : Einstellung des Notch
+	 */
+	public Walze(int walzennr, int ringstellung) {
+		this.walze = new Character[25];
+		this.walzennr = walzennr;
+		this.buchstabe = 'A';
+		this.iPositionBuchstabe = 0;
+		this.ringstellung = ringstellung;
+	}
+
+
+	/**
+	 * Sortiert den Walzennummern das passenden Character-Array mittels switch zu.
+	 *
+	 * @return walze : Character[] : gibt die gewaehlte Walze zurueck
+	 */
+	private Character[] walzenNummer() {
+
+	    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 (this.walzennr) {
+			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;
+	}
+
+
+	//walzenPosition() return int => Gibt die aktuelle Position des Buchstabens zurück
+	public char walzenPosition() {
 
         /*Alphabetswalze*/
-        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 < walzeAlphabeth.length; index++) {
-            if(getBuchstabe().equals(walzeAlphabeth[index])) {
-                iPositionBuchstabe = index;
+        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'};
+
+        return walzeAlphabeth[iPositionBuchstabe];
+	}
+
+
+	//setzeNotch(int position) => Setze Startpunkt auf int Position des Buchstabens
+	// Setter für Ringstellung
+
+	/**
+	 * @return ringstellung : Character : gibt die neue Ringstellung zurueck
+	 */
+	public int 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(int ringstellung) {
+
+		if (ringstellung > 0 && ringstellung <= 26) {
+			this.ringstellung = ringstellung;
+		} else {
+			this.ringstellung = 1;
+		}
+	}
+
+	//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.
+	 *
+	 * @param
+	 * @return chiffrierterBuchstabe : Character : chiffrierter Buchstabe
+	 */
+	public char codiere(char buchstabe) {
+        for(int i = 0; i < walzeAlpha.length; i++) {
+            if(walzeAlpha[i].equals(buchstabe)) {
+                buchstabe = walzenNummer()[i];
                 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;
-            }
+        return buchstabe;
+	}
 
-        if (iPositionBuchstabe == getRingstellung()){
 
-            checkRing = true;
+	//codiere2(char buchstabe) => Gibt den vertauschten Buchstaben zurück (Reverse)
 
-        }else{
+	/**
+	 * Chiffriert den Buchstaben an der Position aus der Methode positionBuchstabeReverse()
+	 * anhand der AlphaWalze.
+	 *
+	 * @param
+	 * @return codierterBuchstabeRe : Character : chiffrierter Buchstabe
+	 */
+	public char codiere2(char buchstabe) {
 
-            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.
-     *
-     * @param
-     * @return chiffrierterBuchstabe : Character : chiffrierter Buchstabe
-     */
-    public Character codiere(Character buchstabe) {
-        setBuchstabe(buchstabe);
-        walzenPosition();
-        Character codierterBuchstabe = walzenNummer()[iPositionBuchstabe];
-        return codierterBuchstabe;
-    }
-
-
-    //codiere2(char buchstabe) => Gibt den vertauschten Buchstaben zurück (Reverse)
-    /**
-     * Chiffriert den Buchstaben an der Position aus der Methode positionBuchstabeReverse()
-     * anhand der AlphaWalze.
-     *
-     * @param
-     * @return codierterBuchstabeRe : Character : chiffrierter Buchstabe
-     */
-    public Character codiere2(char buchstabe) {
-
-        /*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;
+	    for(int i = 0; i < walzenNummer().length; i++) {
+            if(walzenNummer()[i].equals(buchstabe)) {
+                buchstabe = walzeAlpha[i];
                 break;
             }
         }
 
-        Character codierterBuchstabeRe = walzeAlpha[iPositionBuchstabeRe];
-        return codierterBuchstabeRe;
-
-
-    }
+		return buchstabe;
+	}
 
 //_________________________________________________________________________________________
 
 
-    /**
-     * @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';
-        }
-    }
-
-
-    //TODO: ??? Brauchen wir Setter, wo findet Überprüfung der Walzennr. statt.
-    /**
-     * 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");
-        }
-    }
+	/**
+	 * @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);
+			for(int i = 0; i < 25; i++) {
+			    if(walzeAlpha[i].equals(buchstabe)) {
+                    this.iPositionBuchstabe = i;
+                }
+            }
+		} else {
+			this.buchstabe = 'A';
+		}
+	}
+
+
+	//TODO: ??? Brauchen wir Setter, wo findet Überprüfung der Walzennr. statt.
+
+	/**
+	 * 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");
+		}
+	}
 
 }
-- 
GitLab