Übungsblatt 2. Sitzung Diskussion / Musterlösungen der letzten

Abteilung Informatik und
Angewandte Kognitionswissenschaft
Nino Simunic, M.A.
Fachgebiet Computerlinguistik
Übungsblatt 2. Sitzung
Der erste Teil dieses Dokuments enthält Informationen und Musterlösungen zu den letzten Aufgaben.
Im Anschluss daran finden Sie die Beschreibung neuer Inhalte, die Sie unter anderem für die Lösung der neuen Aufgaben benötigen.
Der letzte Teil dieses Dokuments enthält neue Aufgaben, die Sie bitte bis zu letzten Sitzung lösen und auch zur Übung mitbringen.
Diskussion / Musterlösungen der letzten Aufgaben
Aufgabe 1
Konsolen Befehle, Interpretation der Code−
Code−Fragmente
Fragen, Diskussion
Aufgabe 2 c
String−
String−Konkatenation
Mittels Konkatenation (Verkettung) können auch in Java einzelne Zeichenketten zur einer größeren Zeichenkette
zusammengefügt bzw. verkettet werden. Dazu wird der Konkatenationsoperator + verwendet, der wie im folgenden Fall
keine arithmetische Operation durchführt, sondern "Hello, " und "Dave" zu "Hello, Dave" konkateniert:
System.out.print("Hello, "+"Dave");
Nach diesem Muster könnten beliebig viele Zeichenketten konkateniert werden.
System.out.print("Hello, "+"Dave"+
" how are you today?");
Beachten Sie beim letzten Beispiel, dass der Zeilenumbruch und die Leerzeichen nicht mit ausgegeben werden, da sie nicht
Teil der Zeichenkette sind! Sie können also wie im Beispiel oberhalb auch einen Zeilenumbruch oder beliebig viele
Leerzeichen vor oder nach dem + Operator einfügen, ohne dass die tatsächliche Ausgabe verändert wird:
Hello, Dave, how are you today?
Das nächste Beispiel verhält sich jedoch bei der Ausgabe anders, da die Leerzeichen innerhalb der Delimiter (hier " und ")
der Zeichenkette liegen:
System.out.print("Hello, "+"Dave
Hello, Dave
" +
" how are you today?");
how are you today?
Wenn Sie einen Zeilenumbruch in Ihrer Ausgabe haben möchten, verwenden Sie zwei separate println-Anweisungen
(fügt Umbruch automatisch ans Ende der Zeichenkette ein), oder aber Sie verwenden eine entsprechende EscapeSequenz. (Mehr zu Escape-Sequenzen später).
// String über mehrere Zeilen (1)
System.out.println("Hello, Dave!");
System.out.println("How are you today?");
// String über mehrere Zeilen (2)
System.out.println("Hello, Dave!\nHow are you today?");
Grundlegende Programmiertechniken (Programmierung)
Wintersemester 2007/2008
Seite 1
Abteilung Informatik und
Angewandte Kognitionswissenschaft
Nino Simunic, M.A.
Fachgebiet Computerlinguistik
Hello, Dave!
How are you today?
Anstelle von Literalen können auch entsprechende Variablen der print oder println als Argumente übergeben bzw.
dort konkateniert werden. Wie in der Vorlesung gesehen, speichern wir Zeichenketten in Variablen vom Typ String. Die
Konkatenation erfolgt wie bei/mit Literalen:
String hello = "Hello";
String world = "World";
String helloWorld = hello +", "+ world;
System.out.println( helloWorld );
Achten Sie darauf, dass Variablen nicht Teil der Zeichenkette sein dürfen, da sie nicht (wie in anderen
Programmiersprachen) automatisch interpoliert werden. Bei gleicher Variablendefinition wie oberhalb ergibt die Anweisung
System.out.println( "helloWorld" ); folglich helloWorld und nicht Hello World.
Grundlegende Programmiertechniken (Programmierung)
Wintersemester 2007/2008
Seite 2
Abteilung Informatik und
Angewandte Kognitionswissenschaft
Nino Simunic, M.A.
Fachgebiet Computerlinguistik
VERTIEFUNG / NEUES
Kommentare (in Java): Sinn, Verwendung, javadoc.exe
Argumentübergabe beim Programmstart
KOMMENTARE (IN JAVA)
KOMMENTIERUNG VON QUELLTEXT IM ALLGEMEINEN
Wie in anderen Programmiersprachen existieren natürlich auch neben eigentlichem Code auch Textstellen im Programm, die
der Kommentierung dienen und nicht ausgeführt werden. Generell dabei wird zwischen Block- und Zeilenkommentaren
unterschieden.
Zeilenkommentare gehen bis zum Zeilenende müssen nicht explizit durch eine Endmarkierung beendet werden.
Blockkommentare dagegen können sich über mehrere Zeilen erstrecken – sie enden erst beim explizit vorhandenen
Endzeichen.
In der Regel werden Kommentare in „menschlicher“ Sprache festgehalten, entweder in der Muttersprache des Autors oder in
einer Lingua Franca wie dem Englischen. Kommentare bestehen meist nur aus Text (d.h. keine Formatierungen, Grafiken,
Klänge, etc.), da die meisten Sprachen nur solche Kommentare zulassen.
Kommentare dienen unterschiedlichen Zwecken. Einige der häufigeren Einsatzwecke werden nachstehende kurz erläutert:
Kommentierung des gesamten Quelltexts
Zu Beginn eines Quelltextes vermerkt der Programm-Autor Vorbemerkungen zum gesamten Quelltext. Dazu
zählen vornehmlich Informationen wie die Angabe des Autors, der Funktionalität/des Zwecks des
Programms/Quelltext, des Erstellungsdatums, der Version, der E-Mail Adresse, etc.
Strukturierung
Kommentare werden auch zur »inhaltlichen« Gliederung des Quelltexts verwendet. Z.B:
// <--------------------- Konstantendefinition ab hier ----------------------------->
… KONSTANTEN …
// <--------------------- Klassenvariablen ab hier --------------------------------->
… KLASSENVARIABLEN …
// <--------------------- Methoden ab hier ------------------------------------------->
…
Neben Prosa-Text zeichnen sich strukturierende Kommentare häufig auch durch zusätzliches, grafisches
Segmentieren innerhalb des Kommentars aus: <---- Struktureinheit 1 ---->
Erläuterung einzelner Zeilen/Anweisungen
Kommentare dienen in vielen Fällen der natürlichen Beschreibung der Funktion(-alität) oder Semantik eines
Textteils (z. B. Anweisung, Datenstruktur,…). Dies erleichtert anderen (oder gar dem Autor selbst), diese später
leichter zu verstehen.
Kenntlichmachung von To-do's (noch zu erledigende Aufgaben)
Kommentare können unzureichende Codestücke kennzeichnen (»Hier muss noch die Unterstützung von
Umlauten verbessert werden«) oder Platzhalter für komplett fehlende Codestücke sein (»Getter-Methode fehlt
noch«).
Debugging bzw. Auskommentieren von Quellcode
Soll ein Bestandteil des Codes vorübergehend gelöscht bzw. deaktiviert werden, später jedoch eventuell wieder
eingesetzt werden, so wird er auskommentiert. Das Codestück ist, sobald es im Kommentar verpackt ist, aus
Sicht des Compilers kein Code mehr und wird nicht wie eine Anweisung ausgeführt bzw. kompiliert.
Grundlegende Programmiertechniken (Programmierung)
Wintersemester 2007/2008
Seite 3
Abteilung Informatik und
Angewandte Kognitionswissenschaft
Nino Simunic, M.A.
Fachgebiet Computerlinguistik
KOMMENTARE IN JAVA
Java unterscheidet insgesamt zwischen drei Kommentar-Typen mit unterschiedlicher »Funktionalität«: //, /* */, /** */
Zeilen-Kommentar. Der Kommentar fängt bei // an und hört am Ende der Zeile auf:
//
int x = 10; // Kommentar 1
// Kommentar 2
int y = 20;
// int z = 50; -> auskommentierte Zeile, keine Ausführung
Block-Kommentar. Der Kommentar fängt bei /* and und hört bei */ auf:
/*
*/
/*
/**
*/
javadoc-Block-Kommentar zur automat. Dokumentationsgenerierung . Fängt bei /** an und hört bei */ auf:
/**
@autor Nino Simunic
@date 2007
*/
Ein langer Kommentar,
der sich über mehrere Zeilen erstreckt */
Vorsicht: Schachteln Sie keine Block-Kommentare!
Fehlerhafte Kommentierung (verschachtelter Block-Kommentar).
/*
System.out.println("DEBUGGING: "+x);
/* System.out.println("OK1");
System.out.println("OK2"); */
der sich über mehrere Zeilen erstreckt
*/
Grundlegende Programmiertechniken (Programmierung)
Wintersemester 2007/2008
Seite 4
Abteilung Informatik und
Angewandte Kognitionswissenschaft
Nino Simunic, M.A.
Fachgebiet Computerlinguistik
JAVADOC-KOMMENTARE (EINFÜHRUNG)
Einleitung
javadoc-Kommentare (/** Kommentar */) stellen die »mächtigste« Form der Kommentierung (in Java) dar. In
Verbindung mit dem javadoc.exe Programm können damit HTML-Dokumentationen Ihres Quelltexts (autmoatisch) erzeugt
werden. Einige wichtige Informationen im Überblick:
javadoc ist im JDK enthalten (…/JAVAVERZEICHNIS/bin/javadoc.exe)
Generiert HTML-Dokumentation aus mit /** */ annotiertem Quelltext
Es gibt vordefinierte Tags zur Annotation von wichtigen Kommentarelementen (@author, @param, …)
javadoc-Kommentare sind unmittelbar vor einer Klassen- oder Methodendeklaration zu schreiben
Zur Erzeugung der Kommentare werden die .java-Quelltext Dateien (nicht .class Dateien) verwendet
Die wichtigsten Tags und Ihre Syntax im Überblick:
@author <NAME>
Name des Autors
@version <ID>
Versionsbezeichnung
@param <PARAMETER-NAME> <BESCHREIBUNG>
Parametername & Bedeutung
@return <BESCHREIBUNG>
Erläuterung des Rückgabewertes
@see <REFERENZ>
Schafft einen Querverweis auf einen anderen dokumentierten Namen
Innerhalb von javadoc-Kommentaren werden auch gängige HTML-Formatierungen bei der Erzeugung der Dokumentation
berücksichtigt. Dazu zählen …
… das Setzen des Texts innerhalb der Markierungen auf kursiv via <i>:
<i>myMethod or something else</i>
… das Erzwingen eines Zeilenumbruchs mit <br>:
Ende im Gelände. <br>Das war aber noch nicht alles
… weitere HTML-Tags.
Grundlegende Programmiertechniken (Programmierung)
Wintersemester 2007/2008
Seite 5
Abteilung Informatik und
Angewandte Kognitionswissenschaft
Nino Simunic, M.A.
Fachgebiet Computerlinguistik
Ein Beispiel für eine mit javadoc-Kommentaren versehene Java-Klasse bzw. Quelltextdatei:
/**
* <p><b>Kontext</b>:
Grundlegende Programmiertechniken, WS 2007/2008<br>
*
Übung, Sitzung 2</p>
*
* @author Nino Simunic, Universität Duisburg-Essen
*/
public class JDocTest {
/**
* Die <i>main</i>-Methode: </br> Der Einstiegspunkt ins Programm.
* @param args Die bei Programmaufruf übergebenen Argumente</br>
*/
public static void main(String[] args) {
// Bildschirmausgabe
System.out.println("Hallo");
}
}
JDocTest.java
Die daraus erzeugbare HTML-Dokumentation via javadoc.exe sieht wie folgt aus:
Grundlegende Programmiertechniken (Programmierung)
Wintersemester 2007/2008
Seite 6
Abteilung Informatik und
Angewandte Kognitionswissenschaft
Nino Simunic, M.A.
Fachgebiet Computerlinguistik
Erzeugen der HTML-Dokumentation mit javadoc.exe
Analog zum Kompilieren und Ausführen wird das Programm javadoc.exe zur Erzeugung der Dokumentation in der
Windows-Konsole mit entsprechender Syntax und Argumenten aufgerufen. Um die HTML-Dokumentation für eine einzelne
Java-Quelltextdatei (bzw. –Klasse) zu erstellen, befolgen Sie die folgende simple Syntax:
javadoc.exe <QUELLTEXTDATEI.java>
Vorausgesetzt, Sie befinden sich im selben Verzeichnis wie die Java-Datei JDocTest.java, kann so bspw.
(JDocTest.java) eine HTML-Dokumentation erzeugt werden:
javadoc.exe JDocTest.java
Im Verzeichnis der .java-Datei werden nun mehrere Dokumentationsdateien erstellt., darunter befindet sich die Datei
index.html. Öffnen Sie diese, um sich Dokumentation anzuschauen. Standardmäßig werden Annotationen mit dem Tag
@author nicht mitberücksichtig. Wenn Sie also keinen Autor sehen können, liegt das daran, dass Sie die Option beim
Erstellen explizit angeben müssen:
javadoc.exe JDocTest.java -author
Wenn Sie nur javadoc.exe eingeben und bestätigen, sehen Sie weitere Flags (Optionen) für die Erstellung der
Dokumentationsdateien.
Die Java-API ist ein praktisches Beispiel für eine solche Dokumentation – sie wurde ebenfalls mit dem JDK-Tool
javadoc.exe erstellt: http://java.sun.com/javase/6/docs/api/
Weitere relevante Informationen zu Verwendung von javadoc finden Sie hier:
•
•
http://java.sun.com/j2se/javadoc/writingdoccomments/
http://java.sun.com/j2se/1.5.0/docs/tooldocs/windows/javadoc.html#tags
Lesen Sie sich insbesondere die Kapitelchen Format of a Doc Comment bis A Style Guide durch (erster Link oberhalb)!
Grundlegende Programmiertechniken (Programmierung)
Wintersemester 2007/2008
Seite 7
Abteilung Informatik und
Angewandte Kognitionswissenschaft
Nino Simunic, M.A.
Fachgebiet Computerlinguistik
ÜBERGABE VON ARGUMENTEN BEI PROGRAMMAUFRUF (IN JAVA)
Wie sie noch im Laufe des Semesters sehen werden, können Methoden so definiert werden, dass beim Aufruf Argumente
zu übergeben sind. Dies können Zahlen, Zeichenkette, aber auch komplexere Dinge (Referenzdatentypen-Objekte) sein,
mit denen die Methode innerhalb ebendieser arbeiten kann. Die main-Methode verhält sich hier nicht anders: Sie wurde so
definiert, dass eine Liste von Zeichenketten beim Aufruf übergeben werden kann. Diese Definition spiegelt sich in der
Parameterliste der/einer Methode wieder: Es wird präzise und formal definiert, welche Argumente übergeben werden
können:
public static void main ( String[] args ) {
}
Der Parameter String[] args bedeutet, dass die Methode beim Aufruf die Übergabe einer Liste von Zeichenketten
erwartet. Doch wann »erhält« diese Methode die Argumente --- sie wird in Ihrem Quelltext (z.B. HelloWorld.java) ja gar nicht
aufgerufen.
Die main-Methode wird implizit beim Aufruf/Starten des Programms via java.exe aufgerufen.
Und wie übergibt man (Zeichenketten-)Argumente an die main-Methode? Ein Blick in die Hilfe von java.exe (einfach
java.exe ohne Argument ausführen) zeigt die Syntax:
Die eckigen Klammern bedeuten »optional«, d.h. es müssen keine Optionen oder Argumente übergeben werden. Falls
doch, halten Sie sich an die Syntax. Um also bspw. die Zeichenketten "MyArg1" und "MyArg2" an die main-Methode zu
übergeben:
Grundlegende Programmiertechniken (Programmierung)
Wintersemester 2007/2008
Seite 8
Abteilung Informatik und
Angewandte Kognitionswissenschaft
Nino Simunic, M.A.
Fachgebiet Computerlinguistik
Sie können, müssen aber die Zeichenketten hier nicht zwingend in Anführungszeichen setzen. Da unsere Hello WorldProgramm jedoch die eingehenden Argumente nicht verwertet, werden Sie keinen Unterschied zur Ausführung ohne
Argumente merken. Wir entscheiden uns für eine neue Klasse mit Bezeichner ArgTest, um die eingehenden Argumente
auch nutzen zu können:
public class ArgTest {
public static void main(String[] args) {
System.out.println("Die ersten zwei Argumente sind:");
System.out.println("Argument 1:"+args[0]);
System.out.println("Argument 2:"+args[1]);
}
}
Nach erfolgreichem Kompilieren führen wir das Programm mit den zwei Zeichenketten MyArg1 und MyArg2 als
Argumente aus:
Die übergebenen Argumente werden geordnet in einer Liste/einem Array (args) gespeichert und an die Methode
übergeben. Die Reihenfolge der übergebenen Argumente bleibt also erhalten. Wenn Sie also die Reihenfolge der
Argumente beim Starten des Programms umdrehen, bleibt auch diese Ordnung erhalten:
Alle übergebenen Argumente werden in der Variable args gespeichert und indexiert, angefangen bei 0. Für das letzte
Beispiel ergäbe sich die folgende Datenstruktur:
Grundlegende Programmiertechniken (Programmierung)
Wintersemester 2007/2008
Seite 9
Abteilung Informatik und
Angewandte Kognitionswissenschaft
Nino Simunic, M.A.
Fachgebiet Computerlinguistik
args
Wert
Index
MyArg2
0
MyArg1
1
Analog dazu: Wenn Sie vier Argumente übergeben
böte sich die folgende Datenstruktur:
args
Wert
Index
MyArg2
0
MyArg1
1
MyArg3
2
MyArg4
3
Warum jedoch ist die Ausgabe bei zwei und vier Argumenten identisch? Nun, im ArgTest-Programm werden nur die
ersten beiden verwendet: args[0] und args[1]. Sie müssten also dafür sorgen, dass args[2] und args[3] auch
ausgegeben werden.
Vorsicht:
In diesem Fall übergeben Sie nur ein Argument (gespeichert an Indexposition [0]), es werden jedoch zwei Argumente im
Programm selbst verwendet ([0] und [1]) – dies führt zu einem Laufzeitfehler.
Keine Sorge, wir werden auf die Themen Methode, Parameter und Array später zurückkommen. Sie sollten jedoch
zumindest in der Lage sein, rudimentäre Benutzereingaben beim Programmstart nutzen zu können, und verstehen, dass es
Variablen gibt, die mehr als nur einen Wert (z.B. "Hello") speichern können.
Grundlegende Programmiertechniken (Programmierung)
Wintersemester 2007/2008
Seite 10
Abteilung Informatik und
Angewandte Kognitionswissenschaft
Nino Simunic, M.A.
Fachgebiet Computerlinguistik
AUFGABEN
-
-
Speichern Sie Ihren Quelltext bitte auf einem tragbaren Medium (oder schicken Sie sich den Quelltext via Mail selbst
zu), damit Sie Ihre Lösungen während der kommenden Übungssitzung parat haben.
Neben den neuen Inhalten und den Hinweisen dieses Übungsblatt lesen und verstehen Sie bitte Kapitel 2 (bis
mindestens 2.4) aus dem aus der Vorlesung bekannten Buch Sprechen Sie Java. In der kommenden Vorlesung und
Übung werden die dort (und hier) enthaltenen (neuen) Konzepte im Detail besprochen.
Die Aufgaben 3 und 4 können (bzw. sollten) zusammen gelöst werden.
Hinweis in eigener Sache: Es ist noch kein Meister vom Himmel gefallen. Nicht verzagen, wenn es beim ersten Versuch
nicht klappt, oder/und Sie nicht alles bis ins Detail verstanden haben.
Aufgabe 3
Es soll eine Klasse/Programm Wahlen zur Umrechnung und Darstellung von absoluten Wahlstimmen in relative
Prozentangaben implementiert werden.
Das Programm soll es ermöglichen, dass beim Programmstart für die sechs »wichtigen« Parteien (SPD, CDU/CSU, FDP,
Grüne/Bündnis 90, Linkspartei, Andere) in genau dieser Reihenfolge absolute Wahlergebnisse, also die Wählerstimmen,
übergeben und diese dann in Prozentangaben (bezogen auf die Gesamtzahl der Stimmen) umgerechnet werden. Die
umgerechneten Prozentangaben sind dabei auf zwei Nachkommastellen zu runden, um sie letztendlich zusammen mit der
jeweiligen Partei und den dazugehörigen Wählerstimmen auszugeben. Die Reihenfolge der Parteien (sowohl bei der Ein- als
auch der Ausgabe) ist feststehend: SPD, CDU, FDP, B90, LINKE, Andere.
Beispiel:
Aufruf des Programms:
>java Wahlen 5120433 8744200 4521000 4109000 1940000 875000
Ausgabe des Programms:
Die Wahlergebnisse:
SPD:
20.23%
CDU:
34.55%
FDP:
17.86%
b90:
16.23%
LINKE:
7.67%
Andere:
3.46%
(5120433 Wählerstimmen)
(8744200 Wählerstimmen)
(4521000 Wählerstimmen)
(4109000 Wählerstimmen)
(1940000 Wählerstimmen)
(875000 Wählerstimmen)
Grundlegende Programmiertechniken (Programmierung)
Wintersemester 2007/2008
Seite 11
Abteilung Informatik und
Angewandte Kognitionswissenschaft
Nino Simunic, M.A.
Fachgebiet Computerlinguistik
Als Vorlage für Ihren Quelltext verwenden Sie bitte den Code unterhalb, und beachten Sie die Hinweise im Code und auch
darunter:
public class Wahlen{
public static void main(String[] args) {
double grundwert = Integer.parseInt(args[0]) + Integer.parseInt(args[1]);
// Summe noch unvollständig: fdp, b90, etc. fehlen
// noch.
// Deklaration von Variablen gleichen Typs als Liste möglich:
double spdProz = 0, cduProz=0, fdpProz=0, b90Proz=0, linkeProz=0,
andereProz=0;
/* HIER PROZENTE AUSRECHNEN (UND EVTL. SCHON RUNDEN) UND DEN VARIABLEN
* spdProz, cduProz, etc. ZUWEISEN.
* Formel: prozent = prozentwert / grundwert * 100
*/
System.out.println("Die Wahlergebnisse: ");
/* AB HIER ERFOLGT DIE AUSGABE DER PARTEIEN,IHRER PROZENTE,IHRER STIMMEN*/
//System.out.println("SPD:\t"+spdProz+"% …
}
}
Wahlen.java
Hinweise
Vom Zeichen zur Zahl:
Die übergebenen Argumente sind zunächst Zeichenketten. Allerdings kann man mit Zeichenketten keine arithmetischen
Operationen (z.B. zur Berechnung der Prozente) durchführen, so dass die Zeichenkette vor der Verwendung in einer
mathematischen Operation in eine Zahl umgewandelt werden muss. Es existiert hierzu eine (statische) Methode der Klasse
Integer: Integer.parseInt(ZAHL_ALS_STRING)
Setzen Sie diese Methode überall dort ein, wo Sie auch eine Zahl, bspw. zur Addition, einsetzen würden:
double summe; // Natürlich geht hier auch int summe
summe = 1 + 2;
// Mit Zeichenketten als Operanden:
summe = Integer.parseInt("1") + Integer.parseInt("2");
Nachkommastellen runden:
Verwenden Sie die Methode Math.round(ZURUNDENDEZAHL*100.)/100., um die berechneten Prozente auf zwei
Nachkommastellen zu runden. Verwenden Sie den gezeigten Methodenaufruf überall dort, wo Sie auch "normale" Zahlen
oder Strings einsetzen würden. Ein Beispiel:
double unrundeZahl = 1.3456789;
double gerundet = Math.round(unrundeZahl*100.)/100.;
System.out.println( "Rundung von "+ unrundeZahl +" ergibt "+gerundet);
// Oder so:
System.out.println( "Rundung von "+ unrundeZahl +
" ergibt "+Math.round(unrundeZahl*100.)/100.);
Grundlegende Programmiertechniken (Programmierung)
Wintersemester 2007/2008
Seite 12
Abteilung Informatik und
Angewandte Kognitionswissenschaft
Nino Simunic, M.A.
Fachgebiet Computerlinguistik
Aufgabe 4
Dokumentieren Sie Ihr Programm aus Aufgabe 3 mit javadoc-Kommentaren und erzeugen Sie eine HTML-Dokumentation
mit javadoc.exe:
-
Dokumentieren Sie das Programm als Ganzes: Zweck/Funktionalität des Programms, verwendete Java-Version
Autor. Falls Ihnen noch relevante Informationen einfallen, fügen Sie diese natürlich hinzu.
Beschreiben Sie die main-Methode und den String[]-Parameter: Erklären Sie dabei insbesondere unter
Verwendung des entsprechenden Tags, welche Argumente in welcher Reihenfolge (SPD, CDU, …) beim
Programmstart zu übergeben sind.
Grundlegende Programmiertechniken (Programmierung)
Wintersemester 2007/2008
Seite 13