![[Java]Verschlüsselung mit der monoalphabetischen Substitution](https://www.elitepvpers.com/forum/iconimages/general-coding/java-verschl-sselung-mit-der-monoalphabetischen-substitution_ltr.gif){kind=small}
da ich in der Schule Java lerne/mache bekamen wir eine Aufgabe:
Ich lerne zu Hause Java vor als in der Schule, das heißt arrays etc kann ich schon machen. Da wir aber in der Schule keine arrays bis jetzt gemacht haben, hat uns die lehrerin verboten, arrays zu benutzen, für die die es schon können.Quote:
Die Klasse Verschluesselung soll ein allgemeines Substitutionsverfahren implementieren. Diese soll Verschlüsselungen nach dem Prinzip der einfachen monoalphabetischen Substitution realisieren. Dabei wird ein Geheimalphabet erstellt. Dieses muss alle erwünschten Zeichen abdecken, z.B.
Klaralphabet: 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
Geheimalphabet: U F L P W D R A S J M C O N Q Y B V T E X H Z K G I
Dieses Geheimalphabet soll als Attribut in der Klasse gespeichert werden. Die Verschlüsselung erfolgt nun so, dass der Text Buchstabe, für Buchstabe durchgegangen wird, und das aktuelle Zeichen durch den entsprechenden Buchstabe im Geheimalphabet ersetzt wird. So wird kann Hallo z.B. folgendermaßen verschlüsselt werden:
Klartext: hallo
Geheimtext: AUCCQ
Es ist üblich verschlüsselte Texte in Großbuchstaben und unverschlüsselte Texte in Kleinbuchstaben auszugeben. Es soll neben den Konstruktoren, sowie den setter- und getter-Methoden für das Attribut eine Methode verschluesseln und eine Methode entschluesseln, je mit einem Text als Parameter geben. Beide Methoden sollen den ver- bzw. entschluesselten Text zurück geben. Teste deine Klasse mit einer eigenen Testklasse.
Also habe ich das ohne arrays gemacht und sogar ohne Switch und tausende if´s !
Jedoch habe ich das Problem das ich den verschlüsselten Text iwie nicht entschlüsseln kann.
Hier der Code ohne Arrays:
Klasse Verschluesselung
Code:
/**
* Eine Klasse die ein allgemeines Substitutionsverfahren implementiert.
* Diese soll Verschlüsselungen nach dem Prinzip der einfachen monoalphabetischen Substitution realisieren.
*
* @author *****
* @version 2011-10-05
*/
public class Verschluesselung
{
//Attribut für das GeheimAlphabet
private String geheimAlphabet;
/**
* Erstellt eine Verschluesselung mit dem geheimAlphabet
*/
public Verschluesselung(String g){
if(g.length() == 26){
geheimAlphabet = g;
}
else{
geheimAlphabet = "uflpwdrasjmconqybvtexhzkgi";
}
}
/**
* Das Wort wird mit dem geheim Alphabet verschlüsselt
* @param ver der eingegebene Text
* @return den verschlüsselten Text
*/
public String verschluesseln(String ver){
String verschluesselterText = "";
for(int i = 0; i < ver.length(); i++){
verschluesselterText = verschluesselterText + geheimAlphabet.charAt((int)ver.charAt(i)-97);
}
return verschluesselterText.toUpperCase();
}
/**
* Das verschlüsselte Wort wird wieder entschlüsselt
* @param ent das zu entschlüsselte Wort
* @return den entschlüsselten Text
*/
// Funktioniert nicht bzw. weiß nicht wie ich das anstellen soll
public String entschlüsseln(String ent){
String entschluesselterText = "";
String x = this.verschluesseln(ent);
for(int i = 0; i < ent.length(); i++){
entschluesselterText = entschluesselterText + x.charAt((int)ent.charAt(i)-97);
}
return entschluesselterText.toLowerCase();
}
}
Klasse VerschluesselungTest
Code:
import javax.swing.JOptionPane;
/**
* TestKlasse zur Klasse Verschlüsselung. Eingabe wird eingelesen und diese wird verschlüsselt und
* wieder entschlüsselt
*
* @author ******
* @version 2011-10-05
*/
public class VerschluesselungTest
{
public static void main(String[] args){
String wort = "hallo";
Verschluesselung v = new Verschluesselung("uflpwdrasjmconqybvtexhzkgi");
String x = v.verschluesseln(wort);
String y = v.entschlüsseln(wort);
System.out.println(wort);
System.out.println(x);
System.out.println(y);
}
}
Und hier die Klasse Verschluesselung mit arrays(falls ihr mir ned glaubt das ichs nicht mit arrays kann^^):
Code:
/**
* Das hier ist eine Klasse Verschlüsseln die die monoalphabetische Substitution anwendet
* @author *****
* @version 2011-10-5
*/
public class Verschluesselung {
private char[] geheim;
public char[] getArray() { // getter-Methode
return geheim;
}
public void setArray(char[] geheim) { // setter-Methode
this.geheim = geheim;
}
/**
* Ein default Konstruktor der im falle das nix im Paramter steht,automatisch das Alphabet um 3 Stellen verschiebt
*/
public Verschluesselung () {
int zahl = 0;
geheim = new char [((int)'z')];
for(char i ='a';i<'z';i++) {
geheim[i] = "DEFGHIJKLMNOPQRSTUVWXYZABC".charAt(zahl);
zahl++;
}
}
/**
* Ein Konstruktor der jeden Buchstaben des Geheimalphabets durchgecheckt und immer weiter checkt bis es zu Ende ist
* @param geheim das übergeben Geheimalphabet
*/
public Verschluesselung (String geheimniss) {
int zahl = 0;
geheim = new char [((int)'z')];
for(char i ='a';i<'z';i++) {
geheim[i] = geheimniss.charAt(zahl);
zahl++;
}
}
/**
* Die Methode verschlüsseln die den Klartext in einen Geheimtext umwandelt
* @param eingabe der Klartext
* @return den verschlüsselten Text
*/
public String verschluesseln(String klartext) {
klartext = klartext.toLowerCase();
for(char i ='a';i<'z';i++) {
klartext = klartext.replace(i,geheim[i]); // hier wird das "ursprüngliche" Alphabet durch Geheimalphabet das im [i] gespeichert ist ersetzt
}
return klartext;
}
/**
* Die Methode entschlüsseln die den Geheimtext in einen Klartext umwandelt
* @param eingabe der Geheimtext
* @return den Klartext
*/
public String entschluesseln(String geheimtext) {
geheimtext = geheimtext.toUpperCase();
for(char i ='a';i<'z';i++) {
geheimtext = geheimtext.replace(geheim[i],i); // hier wird das Geheimalphabet durch das "ursprüngliche" Aplhabet ersetzt
}
return geheimtext;
}
}
xD
