From 149300de247ce044903cf0f12f05c96f19b22609 Mon Sep 17 00:00:00 2001
From: Michael <micha.bechtel@web.de>
Date: Fri, 29 Nov 2019 11:20:56 +0100
Subject: [PATCH] =?UTF-8?q?Klasse=20Steckbrett=20und=20Reflektor:=20Kommen?=
=?UTF-8?q?tare=20hinzugef=C3=BCgt?=
MIME-Version: 1.0
Content-Type: text/plain; charset=UTF-8
Content-Transfer-Encoding: 8bit
---
src/main/java/enigma/model/Reflektor.java | 28 ++++-----
src/main/java/enigma/model/Steckbrett.java | 69 +++++++++++++++++-----
2 files changed, 65 insertions(+), 32 deletions(-)
diff --git a/src/main/java/enigma/model/Reflektor.java b/src/main/java/enigma/model/Reflektor.java
index 4aabb1b..1e58a8e 100644
--- a/src/main/java/enigma/model/Reflektor.java
+++ b/src/main/java/enigma/model/Reflektor.java
@@ -2,42 +2,40 @@ package enigma.model;
/**
* Klasse Reflektor
- * <p>
+ * <br>
* 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
+ * <br>
+ * Prinzipiell verhält sich die Klasse Reflektor wie die Klasse Walze, außer das sie sich
+ * nach Betätigung einer Taste nicht dreht (quasi starr montiert ist) und sie gibt keine Signale
* an andere Walzen zum drehen.
*/
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'};
+
+ /**
+ * WALZE_REFLEKTOR : konstanter Char-Array mit den Werten des Reflektors (26 Werte)
+ */
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>
+ * Funktion codiere
+ * <br>
* 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
+ * @return WALZE_REFLEKTOR[iPositionReflektor]: Character: Der kodierte Buchstabe aus dem Reflektor
*/
public char codiere(Character buchstabe) {
int iPositionReflektor = 0;
- /*Ermittelt die Position des Buchstaben buchstabe auf der Alphabetswalze*/
+ //Ermittelt die Position des Buchstaben "buchstabe" auf der Alphabetswalze
for (int index = 0; index < WALZE_ALPHABET.length; index++) {
if (buchstabe.equals(WALZE_ALPHABET[index])) {
iPositionReflektor = index;
@@ -45,8 +43,6 @@ public class Reflektor {
}
}
- /*Im Char-Array WALZE_REFLEKTOR wird der Character an der Position iPositionReflektor ausgegeben*/
return WALZE_REFLEKTOR[iPositionReflektor];
}
-
}
diff --git a/src/main/java/enigma/model/Steckbrett.java b/src/main/java/enigma/model/Steckbrett.java
index 63bf834..58971ec 100644
--- a/src/main/java/enigma/model/Steckbrett.java
+++ b/src/main/java/enigma/model/Steckbrett.java
@@ -1,18 +1,34 @@
package enigma.model;
/**
- *TODO: Dokumentieren
+ * Klasse Steckbrett
+ * <br>
+ * Das Steckbrett diente dazu Buchstaben paarweise zu vertauschen noch bevor diese durch die Walzen codiert werden.
+ * Die Klasse Steckbrett nimmt bis zu 10 paarweise zu vertauschende Buchstabenpaare entgegen, prueft diese auf
+ * Zulaessigkeit und tauscht diese dann paarweise aus.
*/
public class Steckbrett {
+
/**
- *TODO: Dokumentieren
+ * zaehler: Int, der als Laufvariable genutzt wird
*/
private int zaehler;
+
+ /**
+ * orginalBuchstaben: Character-Array, der jeweils den ersten zu vertauschenden Buchstaben enthält
+ */
private Character[] orginalBuchstaben;
+
+ /**
+ * getauschteBuchstaben: Character-Array, der jeweils den zweiten zu vertauschenden Buchstaben enthält
+ */
private Character[] getauschteBuchstaben;
+
/**
- *TODO: Dokumentieren
+ * Konstruktor Steckbrett
+ * <br>
+ * Erzeugt zwei Charakter-Arrays (orginalBuchstaben und getauschteBuchstaben) der Länge 10.
*/
public Steckbrett() {
@@ -21,14 +37,20 @@ public class Steckbrett {
}
/**
- *TODO: Dokumentieren
+ * TODO: Fehlerfall kommentieren, bzw. Exceptions werfen ?????
+ * TODO: Überprüfe Vertauschungen für jeden Buchstaben aufrufen
+ * Funktion setzeVertauschung
+ * <br>
+ * Der Funktion setzeVertauschung werden 2 Buchstaben (buchstabe1 und buchstabe2) übergeben.
+ * buchstabe1 wird in das Character-Array orginalBuchstaben geschrieben.
+ * buchstabe2 wird in das Character-Array getauschteBuchstaben geschrieben.
+ * Anschließend wird die Funktion ueberpruefeVertauschungen aufgerufen.
*
- * @param buchstabe1 : char
- * @param buchstabe2 : char
- * @return boolean
+ * @param buchstabe1 : char: Gibt den ersten Buchstaben an, der getauscht werden soll.
+ * @param buchstabe2 : char: gibt den zweiten Buchstaben an, mit dem der erste getauscht werden soll.
+ * @return ueberpruefeVertauschungen(): Ueberprueft ob die Vertauschungen zulaessig sind.
*/
public boolean setzeVertauschung(char buchstabe1, char buchstabe2) {
-
if (zaehler < orginalBuchstaben.length) {
orginalBuchstaben[zaehler] = buchstabe1;
getauschteBuchstaben[zaehler++] = buchstabe2;
@@ -40,15 +62,29 @@ public class Steckbrett {
}
/**
- *TODO: Dokumentieren
+ * TODO: Fehlerfall kommentieren, bzw. Exceptions werfen ?????
+ * TODO: Buchstabe zum überpüfen übergeben
+ * Funktion ueberpruefeVertauschungen
+ * <br>
+ * Die Funktion ueberpruefeVertauschungen prueft ob die Buchstabenvertauschung zulaessig ist.
+ * Eine Buchstabenvertauschung ist zulaessig, wenn keine Dopplungen der zu vertauschenden Buchstaben auftritt
+ * (ein Buchstabe nicht mehrmals vertauscht wird).
*
- * @return boolean
+ * @return boolean : result : Flag, der die Zulassigkeit der Vertauschungen zurueckgibt.
*/
public boolean ueberpruefeVertauschungen() {
-
boolean result = true;
+
+ /*Es wird geprüft:
+ 1. Ob im Array originalBuchstaben Dopplungen enthalten sind.
+ 2. Ob im Array originalBuchstaben Buchstaben im Array getauschteBuchstaben enthalten sind.
+ 3. Ob im Array getauschteBuchstaben Dopplungen enthalten sind.
+ Tritt einer der Fälle ein, erfolgt eine Konsolenausgabe und der Flag wird auf false gesetzt.
+ */
for (int n = 0; n < orginalBuchstaben.length; n++) {
- if (orginalBuchstaben.equals(orginalBuchstaben[n]) || getauschteBuchstaben.equals(orginalBuchstaben[n]) || getauschteBuchstaben.equals(getauschteBuchstaben[n])) {
+ if (orginalBuchstaben.equals(orginalBuchstaben[n]) ||
+ getauschteBuchstaben.equals(orginalBuchstaben[n]) ||
+ getauschteBuchstaben.equals(getauschteBuchstaben[n])) {
System.err.println("Vertauschungen enthalten unzulässige Dopplungen");
result = false;
}
@@ -58,13 +94,14 @@ public class Steckbrett {
}
/**
- * TODO: Dokumentieren
+ * Funktion codiere
+ * <br>
+ * Die Funktion codiere tauscht den uebergebenen Character buchstabe mit dem zu tauschenden Character aus.
*
- * @param buchstabe : Character
- * @return char
+ * @param buchstabe : Character : Buchstabe der codiert werden soll.
+ * @return buchstabe : Character : Codierter Buchstabe.
*/
public char codiere(Character buchstabe) {
-
for (int index = 0; index < getauschteBuchstaben.length; index++) {
if (buchstabe.equals(getauschteBuchstaben[index])) {
buchstabe = orginalBuchstaben[index];
--
GitLab