Vorgaben verwenden!

In der Aufgabenstellung wurde erwähnt, dass wir ein Übungsprogramm aus der Vorlesung anpassen sollen. Das heißt ein bisschen im Skript rumstöbern, oder sich einfach erinnern wo es gesteckt hat und es dann in eine .java - Datei kopieren.

Achtung: Der Dateiname muss dem Namen der Klasse entsprechen! Wir werden ihn aber gleich ändern ;)

Dies ist das Beispielprogramm aus der Vorlesung:

/** reads one char from standard in, 
 * checks if it is of type lower case letter, 
 * if yes converts to upper case letter. 
 */ 
public class InputToUppercase  { 
   public static void main(String[] args) throws Exception { 
       
       int i; 
       
       // read code of one character from standard in 
       i = System.in.read(); // value is in the range 0..255 
       
       if (! (i>='a' && i<='z'))  { 
           System.out.println("No lowercase character, nothing to do!"); 
           return; // exit main() 
       }     
       
       i = i - 'a' + 'A'; // translation 
       
       char c = (char) i; // return to char type 
       
       System.out.println("uppercase: " + c);          
   } 
} 

Anpassen

Wir passen den Namen unsere Klasse - sowie den Dateinamen nun unserer Aufgabe an. z. B.: "java1_krypt"

Wir lassen die Kommentare zur Übersicht weg.

/* java1_krypt.java */
public class java1_krypt  { 
   public static void main(String[] args) throws Exception { 
       
       int i; 
       i = System.in.read();
       
       if (! (i>='a' && i<='z'))  { 
           System.out.println("No lowercase character, nothing to do!"); 
           return;
       }     
       
       i = i - 'a' + 'A';
       
       char c = (char) i;
       
       System.out.println(c);          
   } 
} 

Bis jetzt liest unser Programm nur die übergebene Zeichenkette ein und schreibt das erste Zeichen groß, wenn es sich zwischen 'a' und 'z' befindet.

Wir werden jetzt die "if-Abfrage" ein bisschen verändern. Unser Programm soll nun etwas machen, wenn ein Zeichen in einem gewissen Bereich liegt.

Konkret heißt das, dass aus

       if (! (i>='a' && i<='z'))  { 
           System.out.println("No lowercase character, nothing to do!"); 
           return;
       } 

dieser Code wird:

       if (i>='a' && i<='z')  { 
           i = i - 'a' + 'A';
       } 

Wir haben nun das "nicht-Zeichen" (--> "!"), das die Bedingung umhüllt hat entfernt und die Argumente, die vorhin außerhalb des if-Blocks waren, in den if-Block mit aufgenommen. Wenn man das Programm nun testet, so stellt man fest, dass sich nichts geändert hat! Und das bedeutet für uns, dass wir bis jetzt nichts falsch gemacht haben!

Ändern

Nun... Unser Programm soll ja nicht ein Zeichen in ein großgeschriebenes Zeichen umwandeln, sondern kleingeschriebene Buchstaben "verschlüsseln". (alle anderen Zeichen sollen unverändert bleiben)

Wir werden nun dazu dieses Codestück aus dem "if-Block" verändern:

           i = i - 'a' + 'A';

Unser i ist eine Zahl - klingt im ersten Moment komisch, da wir ja nicht mit Zahlen, sondern mit Zeichen arbeiten, aber alles halb so wild ;) Das i bekommt den ASCII-Wert eines Zeichens von "System.in.read()" übergeben, also eine Zahl zwischen 0 und 255.

Wenn wir diese Zahl nun verändern und wieder in ein ASCII-Zeichen zurückverwandeln (mit char c = (char) i) bekommen wir ein anderes ASCII-Zeichen. Bisher wurde unser Zeichen in den Bereich der großgeschriebenen Zeichen verschoben - wir aber wollen etwas viel einfacheres machen:

Es um 1 vergrößern.

           i = i + 1;

Um unser Programm wie gefordert ausführen zu können, also womöglich einen ganzen Satz einzulesen und diesen dann zu verarbeiten, müssten wir diesen Codeblock

       i = System.in.read();
       
       if (i>='a' && i<='z')  { 
           i = i + 1;
       }

       char c = (char) i;
       System.out.print(c);

sehr oft in unserem Programm haben. Das wirft allerdings mehrere Probleme auf: Wie oft muss dieser Codeblock vorkommen? (Man kennt die Anzahl der übergebenen Zeichen nicht) - Unser Code wird seeeehr unübersichtlich und uneffektiv. etc.

Diese Probleme können wir mit einem einfachen Mittel lösen:

Schleife

Eine Schleife macht im prinzip nichts anderes, als einen Codeblock unendlich lange zu wiederholen. Einigen wird bei dem Begriff "unendlich" bestimmt ein bisschen mulmig... Zurecht! Wir dürfen nicht vergessen ein Abbruchkriterium einzubauen!

while(true){
    // Innenleben
}

Wir packen nun unseren Codeblock in eine solche Schleife:

       while (true){
           i = System.in.read();
           if (i>='a' && i<='z')  { 
               i = i + 1;
           } 
           char c = (char) i;    
           System.out.println(c);
       }

Wenn wir das Programm jetzt testen, haben wir ein Monster erschaffen, das unendlich lange läuft - aaaaber es funktioniert! Um nicht immer bei Eclipse auf den "Roten-Knopf" drücken zu müssen um das Programm zu beenden, werden wir ein Abbruchkriterium einbauen:

Das drücken der Enter-Taste.

Nun müssen wir etwas beachten: Wenn man bei Windows auf die Enter-Taste drückt, bekommt man ein carriage return('\r') und ein linefeed('\n') - Bei Unix oder Mac OS X ist es nur '\n'.

Für unser Beispiel reicht es also den gemeinsamen Nenner - das '\n' zu berücksichtigen:

       while (true){
           i = System.in.read();
           if (i>='a' && i<='z')  { 
               i = i + 1;
           } else if (i=='\n') {
               System.out.println("du hast enter gedrückt!");
           }
           char c = (char) i;    
           System.out.println(c);
       }

Wir haben nun zwar bemerkt, dass Enter gedrückt wurde - das Programm läuft aber immer noch! Dies wird nun durch ein "return" verbessert. Dieses return beendet das Programm.

       while (true){
           i = System.in.read();
           if (i>='a' && i<='z')  { 
               i = i + 1;
           } else if (i=='\n') {
               return;
           }
           char c = (char) i;    
           System.out.println(c);
       }

Alternativ zum "return" gibt es das "break". Mit "break" springt das Programm nur aus der Schleife, d.h. es kann nach der Schleife noch Code folgen! Hier zum Beispiel eine Meldung dass das Programm beendet wurde:

       while (true){
           i = System.in.read();
           if (i>='a' && i<='z')  { 
               i = i + 1;
           } else if (i=='\n') {
               break;
           }
           char c = (char) i;    
           System.out.println(c);
       }
       System.out.println("___Programm wurde beendet");

Als kleine Schönheitskorrektur können wir noch das "ln" bei "println" weglassen.

               System.out.println(c);

Das führt dazu, dass nicht nach jedem Zeichen eine neue Zeile angefangen wird, sondern das ganze Wort oder der ganze übergebene Satz in einer Zeile stehen.

               System.out.print(c);

Wenn wir nun unser Programm starten und in die Konsole "java ist toll" eingeben, gibt uns das Programm ein "kbwb jtu upmm" zurück :P

Ist das nicht toll? :P

Hinweise zur den "Bit-Aufgaben"