Aufgabenblatt 2

Gruppe 1 Mejit Cosar, Ingrid Liliana Vargas Panesso, Yusuf Tanrikulu
Übungsblatt 1
Seite 1 von 4
Aufgabe 2.1
Um unser Applet-Application-Hybrid aus dem ersten Aufgabenblatt so zu erweitern, dass wir
das Fenster der Application...
a) ganz normal wie eine Anwendung durch Doppelklick auf das Programmsymbol (in Windows oben
links am Fenster) oder durch einen Klick auf das X oben rechts (nur Windows) schließen können,
erweitern wir unsere Application um einen eigenen WindowListener per WindowAdapter und
überschreiben die Methode windowClosing() mit System.exit(0). Jedoch muss man vorher die
java.awt.events importiert haben, sonst klappt das ganze nicht.
b) durch Eingabe von der Tastenkombination Strg-C, direkt ins Applicationfenster, schließen können.
Die Lösung dieses Problems verläuft theoretisch gesehen analog zum ersten Problem. Doch anstatt
diesmal eine WindowListener zu verwenden, nutzt man hier den KeyListener. Dieser bietet die
Methoden keyPressed(), keyReleased() und keyTyped(). Das letztere ist einfacher zu benutzen als die
ersten beiden, weil es beides zusammen bietet. Der Nachteil von keyTyped() ist, dass es keinen Wert
an die getKeyCode()-Methode weitergeben kann, wenn modifier-Tasten, wie Strg, dabei sind! Da wir
aber so eine Taste benutzen sollen, bedienen wir uns der keyPressed()-Methode, entnehmen per
getKeyCode()-Methode den VirtualKeyCode, vergleichen diesen mit dem für die „Strg-C“ und falls
diese übereinstimmen, verbinden wir dieses Event mit dem Befehl das Fenster zu schliessen.
Aufgabe 2.2
Spezifikation: Es soll ein Morsecodeübersetzungsalgorithmus entwickelt werden, mit dem
man eine Kette von Punkten und Strichen, die ein Leerzeichen zur Trennung von Buchstaben
verwenden, in normale Buchstaben zu übersetzen. Um Versionskonflikten aus dem Weg zu gehen, soll
das angegebene Morsealphabet benutzt werden.
Entwicklungsdokumentation: Man muss nur kurz überlegen um Festzustellen, dass man das
vorliegende Morsealphabet auf jeden Fall auf irgendeine Art und Weise in seinem Quellcode
speichern muss, damit man die eingegebenen Zeichenketten mit denen des Alphabets vergleichen
kann. Es ist auch klar, dass man keine normalen Buchstaben mit denen des Morsealphabets
vergleichen kann, von daher geht man anders vor: Man nimmt sich den ersten Buchstaben (also die
ersten Zeichen bis zum ersten Leerzeichen der gesamten eingegebenen Zeichenkette von Punkten und
Strichen, und vergleicht dieses mit denen des gespeicherten Morsealphabets. Je nachdem wo es eine
positiven Vergleich gibt, wird der jeweilige Buchstabe ausgegeben.
import java.util.*;
Wir müssen java.util importieren, da wir den StringTokenizer benutzen werden, um die Zeichenkette
in ihre einzelnen Buchstaben aufzuteilen.
public class Morse2
{
public static String translate (String s)
{
String[] alphabet = {".-","-...","-.-.","-..",".","..-.","-.","....",
".---","..","-.-",".-..","--","-.","---",".--.","--.-",".-.",
"...","-","..-","...-",".--","-..-","-.--","--.."};
StringTokenizer tok = new StringTokenizer(s);
String st="";
String ende="";
while (tok.hasMoreElements())
{
st = tok.nextToken();
int index=27;
for (int i= 0;i<26;i++)
{
if (st.equals(alphabet[i])) index =i;
Gruppe 1 Mejit Cosar, Ingrid Liliana Vargas Panesso, Yusuf Tanrikulu
Übungsblatt 1
Seite 2 von 4
}
switch (index)
{
case 0: {ende=ende + "A"; break;}
case 1: {ende=ende + "B"; break;}
case 2: {ende=ende + "C"; break;}
case 3: {ende=ende + "D"; break;}
case 4: {ende=ende + "E"; break;}
case 5: {ende=ende + "F"; break;}
case 6: {ende=ende + "G"; break;}
case 7: {ende=ende + "H"; break;}
case 8: {ende=ende + "I"; break;}
case 9: {ende=ende + "J"; break;}
case 10: {ende=ende + "K"; break;}
case 11: {ende=ende + "L"; break;}
case 12: {ende=ende + "M"; break;}
case 13: {ende=ende + "N"; break;}
case 14: {ende=ende + "O"; break;}
case 15: {ende=ende + "P"; break;}
case 16: {ende=ende + "Q"; break;}
case 17: {ende=ende + "R"; break;}
case 18: {ende=ende + "S"; break;}
case 19: {ende=ende + "T"; break;}
case 20: {ende=ende + "U"; break;}
case 21: {ende=ende + "V"; break;}
case 22: {ende=ende + "W"; break;}
case 23: {ende=ende + "X"; break;}
case 24: {ende=ende + "Y"; break;}
case 25: {ende=ende + "Z"; break;}
default: {ende=ende + "(Ungültige Eingabe)"; break;}
}
}return ende;
}
}
Der Algorithmus sieht folgendermaßen aus: man wir erzeugen eine Klasse Morse2 mit der einzigen
Methode translate(). Unser kleines Programm basiert auf dem vorgegebene Morsezeichenalphabet, das
in einem array mit 26 Feldern, die jeweils mit einem String-Wert (nämlich mit Punkten und Strichen)
gefüllt sind erzeugen. Inzwischen wird das erste Token der Eingabe in der Variable "st" gespeichert,
welches dann auch gleich mit den Zeichen des Morsezeichenalphabets verglichen wird. Nun folgt das
spannendste Stück des Programms: mit Hilfe der switch'n'case-Methode und der for-Schleife wird die
erste Zeichenkette mit dem Alphabet verglichen, sobald der Vergleich positiv ist, merkt sich unser
Programm die Indexnummer des gewählten Buchstabens aus dem Alphabeten. Diese Nummer ist auch
gleichzeitig die Nummer der verschiedenen Cases, womit auch der richtige „lesbare“ Buchstabe
gefunden wird. Falls es keine Übereinstimmung gefunden wird, geht man davon aus, dass der
Benutzer die falschen Zeichen eingegeben hat und die Meldung „Ungültige Eingabe“ erscheint im
Ausgabetextfeld. Der Gag bei dieser Geschichte ist einfach dass die Indexnummern des arrays mit der
Anzahl der cases übereinstimmen, weshalb man den cases die normalen Buchstaben A bis Z zuordnen
kann.
Nachdem das nun für das erste Token geschehen ist, geht es mit dem nächsten Token weiter, bis die
Zeichenkette aus dem der StringTokenizer seine Zeichen zieht „leer“ ist. Dies ist auch der Grund
dafür, wieso das eigentlich Programm innerhalb einer while-Schleife abläuft.
Am Ende des Algorithmus wird die gesamte Kette von lesbaren Buchstaben in der Endvariable „ende“
gespeichert und ausgegeben.
Gruppe 1 Mejit Cosar, Ingrid Liliana Vargas Panesso, Yusuf Tanrikulu
Übungsblatt 1
Seite 3 von 4
Aufgabe 2.3
Spezifikation: Die Aufgabe besteht darin, einen Morsezeichenübersetzer als Applet zu
programmieren, und dabei den entwickelten Algorithmus zu verwenden. Es sollen nur Zeichenketten,
also Worte in Punkten und Strichen in lesbare Buchstaben übersetzt werden. Außerdem sollen zwei
Textfelder (Ein- und Ausgabefelder sozusagen) und zwei Übersetzungsbuttons erstellt werden. Hier
leuchtet einem nicht ganz genau ein, wieso man zwei Übersetzungsbuttons einfügen soll, obwohl nur
in eine Richtung übersetzt wird. Somit gehen wir hier in der Aufgabenstellung von einem
Irrtum/Versehen aus. Unser Applet sollte auch eine Ausgabe für „falsches Format“ vorsehen um den
Benutzer darüber zu informieren (Diese Teilaufgabe haben wir schon in der Aufgabe davor gelöst.
Dies sollte nicht weiter schlimm sein, da wir diesen Algorithmus für die jetzige Programmieraufgabe
benutzen werden.)
Entwicklungsdokumentation: Wir erzeugen in unserem Zeichenübersetzer-Applet die beiden
Textfelder, eines für die Eingabe von Morsezeichenketten mit Leerzeichen als Trennung zwischen den
Buchstaben, das andere Textfeld ist für die Ausgabe des Ergebnisses der Übersetzung gedacht. Dann
kommt noch ein Übersetzungsknopf hinzu. In der init()-Methode fügen wir diese Objekte unserem
Applet bei, außerdem implementieren wir den ActionListener, damit wir später den Buttons ein Befehl
zuordnen können.
import
import
import
import
import
java.awt.*;
java.applet.*;
java.awt.event.*;
java.io.*;
java.util.*;
public class MorseApplet extends Applet implements ActionListener
{
TextField textein, textaus;
Button trans ;
String eingabe;
Morse2 m;
public void init()
{
textein = new TextField(15);
textein.setEditable(true);
textaus = new TextField(15);
trans = new Button("Übersetzen!!!");
trans.addActionListener(this);
m = new Morse2();
add(textein);
add(textaus);
add(trans);
add(rand);
}
public void actionPerformed(ActionEvent e)
{
String labl="";
labl= e.getActionCommand();
if (labl.equals("Übersetzen!!!"))
{
String eingabe = "";
String ausgabe = "";
eingabe = textein.getText();
Gruppe 1 Mejit Cosar, Ingrid Liliana Vargas Panesso, Yusuf Tanrikulu
Übungsblatt 1
Seite 4 von 4
}
ausgabe = m.translate(eingabe);
textaus.setText(ausgabe);
}
}
Ganz wichtig ist die Erzeugung der Instanz „m“ der Klasse Morse2. Dies ist nämlich die Klasse,
welche wir aus Aufgabe 2.2 entwickelt hatten. Das heißt, es ist mit Java möglich auf schon
geschriebene Klassen zu zugreifen. (Es soll nur erwähnt werden, dass über ein Import als package oder
ein Klassenimport nachgedacht worden ist, was natürlich eleganter wäre. Jedoch kam es nicht dazu,
weil das Applet auch so schon ganz effizient und nicht zu unübersichtlich wirkt.)
In der Actionperformed()-Methode des ActionListeners geben wir den Wert des Textfeldes in die
Variable „eingabe“ und von hier zu der Instanz „m“ weiter, damit dieser per Morse2 übersetzt werden
kann. Das Ergebnis wird schließlich in der Ausgabevariable gespeichert und somit auch im
Ausgabefeld gezeigt.
Aufgabe 2.4
Spezifikation: Dem Applet soll noch ein Button „Zufall“ hinzugefügt werden, mit dem sich
zufällige Zeichenketten aus Punkten und Strichen übersetzen lassen. Es wird auf einen
Zufallszahlengenerator java.lang.Math.random() hingewiesen.
Entwicklungsdokumentation: Um den angegebenen Tipp zu folgen, den Button „Zufall“
hinzuzufügen und auch eine Aktion durchführbar zu machen, füge man folgenden Code in seine
Quelldatei ein.
import java.lang.Math.*;
Button rand = new Button("Zufallsbuchstabe");
rand.addActionListener(this);
if (labl.equals("Zufallsbuchstabe"))
{
String z="";
String[] alphabet = {".-","-...","-.-.","-..",".","..-.","-.","....",".---","..","-.-",".-..","--","-.","---",".--.","--.-","..","...","-","..-","...-",".--","-..-","-.--","--.."};
int zahl=0;
int i;
int wlaenge=0;
String zufallswort="";
Random generator = new Random();
wlaenge=generator.nextInt(10);
for (i=0;i<wlaenge;i++)
{
zahl=generator.nextInt(25);
z=(alphabet [zahl]);
zufallswort=zufallswort+" "+z;
}
textein.setText(zufallswort);
}
Somit bewirkt man die gwünschten Effekte. Dem Leser wird auffallen, dass wir hier auch das array
der Morsezeichen finden. Dies ist erforderlich, da wir zufällig ausgewählte Morsebuchstaben
auswählen. Das heißt der Zufallszahlengenerator wählt zufällig eine Indexnummer (bis 25) aus, und
fügt diesen Morsebuchstaben dem Wort „zufallswort hinzu“. Die gesamte Wortlänge wird auch per
Zufallszahlengenerator ermittelt, wobei hier die Obergrenze auf 10 Zeichen gesetzt wurde. Schließlich
wird das Zufallsmorsewort als Eingabe ins Feld geschrieben und wie eine ganz normale Zeichenkette
behandelt.