Skip to content
GitLab
Explore
Sign in
Register
Primary navigation
Search or go to…
Project
E
Enigma
Manage
Activity
Members
Labels
Plan
Issues
0
Issue boards
Milestones
Wiki
Code
Merge requests
0
Repository
Branches
Commits
Tags
Repository graph
Compare revisions
Snippets
Build
Pipelines
Jobs
Pipeline schedules
Artifacts
Deploy
Releases
Container Registry
Model registry
Operate
Environments
Monitor
Incidents
Analyze
Value stream analytics
Contributor analytics
CI/CD analytics
Repository analytics
Model experiments
Help
Help
Support
GitLab documentation
Compare GitLab plans
Community forum
Contribute to GitLab
Provide feedback
Keyboard shortcuts
?
Snippets
Groups
Projects
Show more breadcrumbs
Dennis Eisold
Enigma
Commits
be012675
Commit
be012675
authored
5 years ago
by
Michael
Browse files
Options
Downloads
Patches
Plain Diff
Walze-Klasse überarbeitet
parent
a14a7e2e
No related branches found
Branches containing commit
No related tags found
No related merge requests found
Changes
2
Hide whitespace changes
Inline
Side-by-side
Showing
2 changed files
src/main/java/Enigma/model/Steckbrett.java
+61
-0
61 additions, 0 deletions
src/main/java/Enigma/model/Steckbrett.java
src/main/java/Enigma/model/Walze.java
+144
-118
144 additions, 118 deletions
src/main/java/Enigma/model/Walze.java
with
205 additions
and
118 deletions
src/main/java/Enigma/model/Steckbrett.java
0 → 100644
+
61
−
0
View file @
be012675
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
;
}
}
This diff is collapsed.
Click to expand it.
src/main/java/Enigma/model/Walze.java
+
144
−
118
View file @
be012675
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
(
getW
alzennr
()
)
{
switch
(
w
alzennr
)
{
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
[]
walzeAlpha
beth
=
{
'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
<
walzeAlpha
beth
.
length
;
index
++)
{
if
(
getBuchstabe
().
equals
(
walzeAlpha
beth
[
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 de
r Walze
* @return
iPosition
Buchstabe :
int : neue Position der Walz
e
* @param iPositionBuchstabe
Re
: int : Position de
s zu chiffrierenden Buchstabens
* @return
codierter
Buchstabe
Re
:
Character : chiffrierter Buchstab
e
*/
public
int
vorstellenDerWalze
(
int
iPositionB
uchstabe
)
{
public
Character
codiere2
(
char
b
uchstabe
)
{
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"
)
;
}
}
}
This diff is collapsed.
Click to expand it.
Preview
0%
Loading
Try again
or
attach a new file
.
Cancel
You are about to add
0
people
to the discussion. Proceed with caution.
Finish editing this message first!
Save comment
Cancel
Please
register
or
sign in
to comment