# Vigenere- Verschlüsselung



## Kampfzwereg (9. Okt 2012)

Hallo,

ich habe mich in den letzten Tagen mit der Vigenere Verschlüsselung beschäftigt. Dazu  habe ich mir ein paar Besipielcodes im Internet angegeguck und einen ausgewählt.Zu ein paar stellen habe ich noch ein paar Fragen:

Das ist der besagt Code

```
public static String vigenereVerschluesselung(String pText, String pCode) 
      {        
        StringBuilder pStringBuilder = new StringBuilder();
        for(int i = 0, j = 0; i < pText.length(); i++)
        {
            char schluessel = pCode.toUpperCase().charAt(j%pCode.length());
            char a = pText.toUpperCase().charAt(i);
            char b = ' ';
            if(a >= 65 && a <= 90) 
            {
                b = (char)(a - 65 + schluessel);
                if((int)b > 90)
                {
                    b -= 26;
                }
                if(pText.charAt(i) >= 97)
                {
                    b += 32;
                }
                pStringBuilder.append(b);
                j++;
            }
            else
            {
                pStringBuilder.append(a);
            }
            
        }
        return pStringBuilder.toString();
    }
```

1: Was hat es mit der For-Schleife auf sich. Wieso werden da zwei Variablen angegeben ? 
2:Was genau macht das "toUpperCase()" und das "%"... 


```
char schluessel = pCode.toUpperCase().charAt(j%pCode.length());
char a = pText.toUpperCase().charAt(i);
char b = ' ';
```

... und wieso kann in der darauffolgenden Zeile ein Char mit einer Zahl verglichen werden?

3: Was bedeutet das ?


```
b -= 26;
```




Für Antworten bedanke ich mich schonmal.

LG


----------



## tuxedo (9. Okt 2012)

Kampfzwereg hat gesagt.:


> 3: Was bedeutet das ?
> 
> 
> ```
> ...



Kurzform für 


```
b = b - 26;
```

Gibt's auch für Addition, Multiplikation und Division.



> 1: Was hat es mit der For-Schleife auf sich. Wieso werden da zwei Variablen angegeben ?



Offenbar werden zwei Variablen für die abarbeitung des Algorithmus gebraucht...



> 2:Was genau macht das "toUpperCase()" und das "%"...



toUpperCase() ---> :rtfm: ... Und wer englisch kann, aber kein JavaDoc lesen will könnte mutmaßen, dass der String damit in Großbuchstaben gewandelt wird.

% --> Google mal nach "Modulo".


----------



## faetzminator (9. Okt 2012)

1. Weil irgendjemand aus irgendeinem Grund Freude an dem [c]j[/c] hat...
2a. Schau in die Javadoc: [japi]String[/japi]. Abgesehen davon verrät die Methode bereits, dass sie den String in Upper Case - also Grossbuchstaben - zurückgibt.
2b. Das ist Modulo. Gibt den Rest einer Bruchrechnung zurück. Also 10 / 3 --> 3 und 10 % 3 --> 1 (weil 3*3+1=10)
3. [c]b -= 26[/c] ist die Kurzform für [c]b = b - 26[/c]


----------



## jgh (9. Okt 2012)

von hinten nach vorne^^


```
b -= 26;
//ist die Kurzschreibweise von 
b= b-26;
```


```
toUpperCase()
```
 ändert den Buchstaben, resp. den char in einen Großbuchstaben...sollte eigentlich aus dem Namen der Methode zumindest erahnbar sein, ansonsten API lesen:
_Converts all of the characters in this String to upper case using the rules of the default locale. This method is equivalent to toUpperCase(Locale.getDefault()). _


```
%
```
ist ein Modulo Operator der dir den ganzzahligen Reste einer Division ausgibt.

Jo, warum du 2 Variablen brauchst...da kannst du mal überlegen 

[edit]Dritter...immerhin noch Bronze  aber schon der zweite ist der erste Verlierer [/edit]


----------



## faetzminator (10. Okt 2012)

jgh hat gesagt.:


> [edit]Dritter...immerhin noch Bronze  aber schon der zweite ist der erste Verlierer [/edit]


Als mein Post bereits finalisiert war, hatte tuxedo erst den dritten Punkt beantwortet  Wenn ich das jeweils nach dem ersten geschreibenen Satz auch so machen würde...


----------



## tuxedo (10. Okt 2012)

Bin manchmal zu schnell was das absenden einer Antwort betrifft. Dann lese ich den Beitrag nochmal und dann fällt mir noch das eine oder andere auf das ich ergänzen könnte


----------



## Kampfzwereg (13. Okt 2012)

Danke erstmal für die zahlreichen Antworten.

@ all: Es tut mir ja leid, dass ich bei "toUpperCase" nicht sofort auf die Lösung komme und bei , für euch selbstverständlichen Sachen, nicht weiß wies funktioniert, aber gewissen kommentare sind manchmal meiner meinung nach unnötig. Und auch solche sachen wie "Jo, warum du 2 Variablen brauchst...da kannst du mal überlegen " nerven find ich nen bisschen .Als hätt ich nich schon drüber nachgedacht, desswegen frag ich doch, weil ich mir trotzdem keinen Reim draus machen kann. Wollt ich nur mal in den Raum stellen.

Naja wie gesagt, danke für die Antworten. Eine Frage ist vllt in den Hintergrund gerückt, undzwar, wieso ich in Zeile 9 einen char mit einer Zahl vergleichen kann. Was wenn der char 'a' ist?


----------



## Ark (13. Okt 2012)

Kampfzwereg hat gesagt.:


> Was wenn der char 'a' ist?




```
'a'
```
 ist nur eine andere Schreibweise im Java-Quelltext für die Zahl 97. Du hättest an dieser Stelle genausogut auch 
	
	
	
	





```
(char)97
```
 oder 
	
	
	
	





```
(char)0x61
```
 schreiben können, das hätte genau nichts geändert. Das 
	
	
	
	





```
(char)
```
 ist in den Beispielen gerade auch nur nötig, um korrekt zu bleiben: fast immer kann man sogar das weglassen.

Das Zeichen a hat im Unicode die Nummer 97, daher dieser Wert.

Ark


----------



## Kampfzwereg (13. Okt 2012)

ich dachte a wär irgendeine Variable, der ich in diesem fall ne Zahl oder was andere zuweise ?


----------



## Ark (13. Okt 2012)

Kampfzwereg hat gesagt.:


> ich dachte a wär irgendeine Variable, der ich in diesem fall ne Zahl oder was andere zuweise ?


Verzeihung, dann habe ich deine Frage wohl nicht richtig verstanden (und verstehe sie noch immer nicht).  Grund für die Verwirrung: 
	
	
	
	





```
a
```
 (ohne ' drumrum) ist was anderes als 
	
	
	
	





```
'a'
```
 (mit ' drumrum). Ersteres ist ein Bezeichner (von z.B. einer Variablen), Letzteres ist ein char-Literal für eine Konstante vom Typ char und mit dem Ganzzahlwert 97.

Ark


----------



## Kampfzwereg (13. Okt 2012)

super jetzt raff ichs ...dann müsste doch aber das hier 


```
char a = pText.toUpperCase().charAt(i);
if(a >= 65 && a <= 90)
```

nur funktionieren, wenn eine Zahl a zugewiesen wurde oder ? .... weil hier ja nich die Konstanten 97 gemeint ist... dasis wmeine frage  ;-]


----------



## vanny (13. Okt 2012)

Kampfzwereg hat gesagt.:


> ... dasis wmeine frage  ;-]


 öhm hust ^^

Wie du schon erfahren hast ist ein char auch ein entsprechender Ganzzahlwert.
das a in deinem code ist die Bezeichnung der Variable(also ihr Name) und a ist halt vom Typ-char.
der Wert hingegen ist dann jeweils 
	
	
	
	





```
pText.toUpperCase().charAt(i)
```
. und somit auch irgendein Ganzzahlwert.


----------



## Ark (13. Okt 2012)

Mal dein Code von eben, leicht umgeschrieben, macht genau das gleiche:

```
char a = pText.toUpperCase().charAt(i);
if(a >= 'A' && a <= 'Z')
```

So. Und a ist in deinem Fall eine Variable vom Typ char. Ein char wird durch 16 Bit kodiert und repräsentiert eine Ganzzahl mit einem Wert zwischen 0 und 65535 (inklusive). Wenn mit chars rumhantiert wird, dann _deutet_ man sie für gewöhnlich als Unicode-Zeichen mit der jeweiligen Nummer. Man kann aber mit chars auch ganz normal rechnen, schließlich sind das immer nur Ganzzahlen. Es sind Zahlen, die für gewöhnlich als Unicode-Zeichen gedeutet werden.

Wenn nun z.B. der Nutzer die Zeichenkette "23" eingibt, dann ergibt 
	
	
	
	





```
charAt(0)
```
, also 
	
	
	
	





```
"23".charAt(0)
```
, den Wert der Zahl 50. Warum? Weil dem Zeichen '2', das wir im deutschsprachigen Raum "Zwei" oder "Ziffer Zwei" nennen, die Unicode-Nummer 50 zugeordnet ist.

Ark


----------



## Kampfzwereg (13. Okt 2012)

alles klärchen danke ;-)


----------

