Skip to content
Snippets Groups Projects
Commit be012675 authored by Michael's avatar Michael
Browse files

Walze-Klasse überarbeitet

parent a14a7e2e
No related branches found
No related tags found
No related merge requests found
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;
/**
* 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");
}
}
}
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