Skip to content
Snippets Groups Projects
Commit bcd1475b authored by Dennis Eisold's avatar Dennis Eisold
Browse files

Merge branch 'master' into 'master'

Walze-Klasse überarbeitet

See merge request !13
parents 56e2be98 be012675
No related branches found
No related tags found
1 merge request!13Walze-Klasse überarbeitet
Pipeline #165 failed with stages
in 56 seconds
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;
}
}
package Enigma.model; 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 { 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 buchstabe;
private Character ringstellung; private Character ringstellung;
private int walzennr; private int walzennr;
...@@ -13,83 +37,15 @@ public class Walze { ...@@ -13,83 +37,15 @@ public class Walze {
* Gibt die Parameter der Walze mit * Gibt die Parameter der Walze mit
* *
* @param walzennr : int : Nummer der gewaehlten Walze * @param walzennr : int : Nummer der gewaehlten Walze
* @param buchstabe : Character : Grundeinstellung der Walze
* @param ringstellung : Character : Einstellung des Notch * @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.walze = new Character[25];
this.walzennr = walzennr; this.walzennr = walzennr;
this.buchstabe = buchstabe; this.buchstabe = 'A';
this.ringstellung = ringstellung; 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. * Sortiert den Walzennummern das passenden Character-Array mittels switch zu.
* *
...@@ -104,7 +60,7 @@ public class Walze { ...@@ -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[] 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'}; 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: case 1:
walze = walzeEins; walze = walzeEins;
break; break;
...@@ -125,29 +81,80 @@ public class Walze { ...@@ -125,29 +81,80 @@ public class Walze {
return walze; return walze;
} }
/**
* Ermittelt die Position des Buchstaben auf der Alphabetswalze, um die Position mit
* der Chiffrierung auf der gewaehlten Walze abgleichen zu koennen. //walzenPosition() return int => Gibt die aktuelle Position des Buchstabens zurück
* public int walzenPosition() {
* @return iPositionBuchstabe : int : Position des Buchstaben im Array
*/
public int positionBuchstabe() {
/*Alphabetswalze*/ /*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*/ /*Ermittelt die Position des Buchstaben buchstabe auf der Alphabetswalze*/
for(int index = 0; index < walzeAlpha.length; index++) { for(int index = 0; index < walzeAlphabeth.length; index++) {
if(getBuchstabe().equals(walzeAlpha[index])) { if(getBuchstabe().equals(walzeAlphabeth[index])) {
iPositionBuchstabe = index; iPositionBuchstabe = index;
break; break;
} }
} }
return iPositionBuchstabe; 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() * Chiffriert den Buchstaben an der Position aus der Methode positionBuchstabe()
* anhand der gewaehlten Walze. * anhand der gewaehlten Walze.
...@@ -156,64 +163,83 @@ public class Walze { ...@@ -156,64 +163,83 @@ public class Walze {
* @param walze : Character[] : ausgewaehlte Walze * @param walze : Character[] : ausgewaehlte Walze
* @return chiffrierterBuchstabe : Character : chiffrierter Buchstabe * @return chiffrierterBuchstabe : Character : chiffrierter Buchstabe
*/ */
public Character codiereBuchstabe(int iPositionBuchstabe, Character[] walze) { public Character codiere(Character buchstabe) {
Character codierterBuchstabe = walze[iPositionBuchstabe]; setBuchstabe(buchstabe);
walzenPosition();
Character codierterBuchstabe = walzenNummer()[iPositionBuchstabe];
return codierterBuchstabe; return codierterBuchstabe;
} }
//codiere2(char buchstabe) => Gibt den vertauschten Buchstaben zurück (Reverse)
/** /**
* Nimmt die Startposition, die aus der Walzeneinstellung geholt wird und * Chiffriert den Buchstaben an der Position aus der Methode positionBuchstabeReverse()
* erhoeht sie um eins. * anhand der AlphaWalze.
* 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 * @param iPositionBuchstabeRe : int : Position des zu chiffrierenden Buchstabens
* @return iPositionBuchstabe : int : neue Position der Walze * @return codierterBuchstabeRe : Character : chiffrierter Buchstabe
*/ */
public int vorstellenDerWalze(int iPositionBuchstabe) { public Character codiere2(char buchstabe) {
if(iPositionBuchstabe == 25) { /*Alphawalze*/
iPositionBuchstabe = 0; 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'};
} else {
iPositionBuchstabe += 1; 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 * Gibt die Grundeinstellung der Walze ein. Nur Buchstaben von A - Z sind zugelassen.
* der Chiffrierung auf der AlphaWalze abgleichen zu koennen. * 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 * @param buchstabe : Character : Grundeinstellung der Walze
* @return iPositionBuchstabeRe : int : Position des Buchstaben im Array
*/ */
public int positionBuchstabeReverse(int walzennr) { public void setBuchstabe(Character buchstabe) {
/*Ermittelt die Position des Buchstaben buchstabe auf der Alphabetswalze*/ if(Character.isLetter(buchstabe)) {
for(int index = 0; index < walze.length; index++) { this.buchstabe = Character.toUpperCase(buchstabe);
if(getBuchstabe().equals(walze[index])) { } else {
iPositionBuchstabeRe = index; this.buchstabe = 'A';
break;
}
} }
return iPositionBuchstabeRe;
} }
//TODO: ??? Brauchen wir Setter, wo findet Überprüfung der Walzennr. statt.
/** /**
* Chiffriert den Buchstaben an der Position aus der Methode positionBuchstabeReverse() * Definiert die Walze. Es stehen fuenf Walze zur Auswahl.
* anhand der AlphaWalze.
* *
* @param iPositionBuchstabeRe : int : Position des zu chiffrierenden Buchstabens * @param walzennr : int : setzt die Walzennummer
* @return codierterBuchstabeRe : Character : chiffrierter Buchstabe
*/ */
public Character codierterBuchstabeReverse(int iPositionBuchstabeRe) { public void setWalzennr(int walzennr) {
/*Alphawalze*/ if(walzennr > 0 && walzennr < 6) {
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'}; this.walzennr = walzennr;
} else {
Character codierterBuchstabeRe = walzeAlpha[iPositionBuchstabeRe]; System.err.println("Keine gültige Walzennummer");
return codierterBuchstabeRe; }
} }
} }
0% Loading or .
You are about to add 0 people to the discussion. Proceed with caution.
Finish editing this message first!
Please register or to comment