Java - Übung

Android will doch nur spielen
Java
– Übung –
Vorbereitung:
Erstellen Sie mit Eclipse zunächst ein neues Java Projekt „JavaUebungen“. Lassen Sie die restlichen
Einstellungen unverändert. Erzeugen Sie das Projekt durch einen Klick auf „Finish“. In Ihrem
Projektordner wurde ein (leerer) Ordner „src“ angelegt. Erstellen Sie darin das Paket
„ipvs.android.workshop.exercises“. Kopieren Sie die bereits für Sie vorbereitete Java Klasse
„Exercises.java“. Diese Klasse ruft Ihre bereits bearbeiteten Übungsaufgaben auf. Dazu müssen Sie
zuvor in dieser Klasse die Kommentierung (//) vor der jeweiligen Übung aufheben.
Übung 1:
Legen Sie in dem soeben erstellten Paket ein Unterpaket „exercise01“ an. Erzeugen Sie darin eine
Java-Klasse mit dem Namen „Exercise_01“ und lassen Sie Eclipse die main Methode automatisch
erstellen. Lassen Sie diese Methode „Hallo, Java!“ ausgeben.
Verwenden Sie hierfür die Methode „println“ aus dem Java Paket „System.out“. „Bauen“ Sie
Ihr soeben erzeugtes Projekt und testen Sie, ob es funktioniert.
Übung 2:
Legen Sie ein Unterpaket „exercise02“ an. Erzeugen Sie darin eine Java-Klasse mit dem Namen
„Exercise_02“ und lassen Sie Eclipse die main Methode automatisch erstellen. Lassen Sie diese
Methode Sie persönlich begrüßen. Sie soll also „Hallo, >>Ihr Name<<!“ ausgeben.
Den Namen können Sie als command-line Parameter übergeben. Diese Parameter verwaltet die main
Methode in Java im Array „args“. Prüfen Sie zunächst ab, ob nur ein Parameter angegeben wurde
(length) und verwenden Sie diesen (args[0]) für Ihre Ausgabe.
Wurden zu viele (oder zu wenige Parameter angegeben, so sollten Sie den Benutzer über seinen
Fehler aufklären!
Übung 3:
Legen Sie ein Unterpaket „exercise03“ an. Erzeugen Sie darin eine Java-Klasse mit dem Namen
„Exercise_03“ und lassen Sie Eclipse die main Methode automatisch erstellen. Lassen Sie diese
Methode Sie persönlich begrüßen. Sie soll also „Hallo, >>Ihr Name<<!“ ausgeben.
Im Gegensatz zu Übung 2 soll der Name des Benutzers aber erst zu Laufzeit Abgefragt und eingelesen
werden. Dies kann in Java mittels eines „Scanner“ implementiert werden. Implementieren Sie ein
Programm, das zunächst nach dem Namen des Benutzers fragt, diesen Einliest und anschließend
wieder ausgibt.
Wie der Scanner arbeitet können Sie in der Klasse „Exercises.java“ nachschauen.
Übung 4:
Legen Sie ein Unterpaket „exercise04“ an. Erzeugen Sie darin eine Java-Klasse mit dem Namen
„Exercise_04“ und lassen Sie Eclipse die main Methode automatisch erstellen. Diese Klasse soll für
ein angegebenes Jahr ermitteln, ob es sich dabei um ein Schaltjahr handelt.
Ein Jahr ist ein Schaltjahr, wenn
es durch 4, aber nicht durch 100 teilbar ist ODER
es durch 400 teilbar ist.
Erzeugen Sie hierfür zunächst eine statische Methode „isLeapYear“, die prüft, ob ein angegebenes
Jahr ein Schaltjahr ist und dies als Wahrheitswert zurückgibt. Diese Methode soll außerhalb dieser
Klasse nicht sichtbar sein.
Ihre main Methode soll vom Benutzer abfragen für welches Jahr er eine Berechnung durchführen
möchte, diese Angabe an „isLeapYear“ übergeben und anschließend das Ergebnis für den Nutzer
sichtbar machen.
Übung 5:
Legen Sie ein Unterpaket „exercise05“ an. Erzeugen Sie darin eine Java-Klasse mit dem Namen
„Exercise_05“ und lassen Sie Eclipse die main Methode automatisch erstellen. In dieser Übung
sollen Sie einen Taschenrechner implementieren, der die vier Grundrechenarten (+, -, *, /) im
Zahlenbereich der ganzen Zahlen beherrscht.
Gehen Sie bei der Implementierung folgendermaßen vor: Fragen Sie zunächst vom Benutzer zwei
ganze Zahlen (Integer) a, b ab. Im Anschluss soll der Benutzer eine der vier Grundrechenarten
eingeben. Führen Sie danach die entsprechende Berechnung durch und geben Sie das Ergebnis
(zusammen mit der Information was Sie soeben berechnet haben) aus.
Achten Sie bei der Division darauf, dass b = 0 nicht gestattet ist! Bedenken Sie weiterhin, dass sich,
bedingt durch die Division, das Ergebnis nicht mehr zwangsläufig im Bereich der ganzen Zahlen
befinden muss (empfohlener Datentype: double).
Übung 6:
Legen Sie ein Unterpaket „exercise06“ an. Erzeugen Sie darin eine Java-Klasse mit dem Namen
„Exercise_06“ und lassen Sie Eclipse die main Methode automatisch erstellen. In dieser Übung soll
die Summenfunktion
implementiert werden.
Der Benutzer soll eine beliebige natürliche Zahl n eingeben, von der anschließend die oben
angegebene Summe gebildet werden soll. Dafür bietet sich eine for-Schleife an. Die Syntax der forSchleife sieht folgendermaßen aus:
for (Initialisierung; Schleifenbedingung; Inkrement)
Anweisung;
Abschließend soll das Ergebnis dem Benutzer präsentiert werden.
Übung 7:
Legen Sie ein Unterpaket „exercise07“ an. Erzeugen Sie darin eine Java-Klasse mit dem Namen
„Exercise_07“ und lassen Sie Eclipse die main Methode automatisch erstellen. In dieser Übung soll
die Fakultätsfunktion (n! = n * (n – 1) * … * 1) berechnet werden.
Der Benutzer gibt eine beliebige natürliche Zahl n ein, von der anschließend n! berechnet und
ausgegeben werden soll. Diese Berechnung soll iterativ, d.h. mittels einer Schleife erfolgen. Auch für
diese Berechnung bietet sich eine for-Schleife an.
Übung 8:
Legen Sie ein Unterpaket „exercise07“ an. Erzeugen Sie darin eine Java-Klasse mit dem Namen
„Exercise_07“ und lassen Sie Eclipse die main Methode automatisch erstellen. In dieser Übung soll
erneut die Fakultätsfunktion (n! = n * (n – 1) * … * 1) berechnet werden.
Im Gegensatz zu Übung 7 soll die Berechnung nun rekursiv erfolgen. Gehen Sie dabei wie folgt vor:
1. Erzeugen Sie eine statische Methode fac, die zu einem gegebenen n n! zurückgibt.
2. fac muss zunächst überprüfen, ob n < 2 ist und somit das Ergebnis bereits direkt berechnet
werden kann (
).
3. Ist n > 1, so ist das Ergebnis
Rufen Sie von der main Methode aus fac auf und geben Sie dem Benutzer das berechnete Ergebnis
aus.
Übung 9:
Legen Sie ein Unterpaket „exercise09“ an. Erzeugen Sie darin eine Java-Klasse mit dem Namen
„Exercise_09“ und lassen Sie Eclipse die main Methode automatisch erstellen. Diese Klasse soll für
zwei angegebene Parameter die Sudanfunktion berechnen.
Die Sudanfunktion ist eine in der Informatik, hinsichtlich ihrer Berechenbarkeit, interessante
Funktion. Sie ist folgendermaßen definiert:
F0(x, y) = x + y
Fn+1(x, 0) = x, n ≥ 0
Fn+1(x, y + 1) = Fn (Fn+1 (x, y), Fn+1 (x, y) + y + 1), n ≥ 0
Erzeugen Sie eine rekursive Methode zur Berechnung der Sudanfunktion, die n, x und y als
Eingabeparameter erwartet. Geben Sie das Ergebnis der Berechnung aus.
Übung 10:
Legen Sie ein Unterpaket „exercise10“ an. Erzeugen Sie darin eine Java-Klasse mit dem Namen
„Exercise_10“ und lassen Sie Eclipse die main Methode automatisch erstellen. In dieser Übung
sollen drei ganze Zahlen der Größe nach sortiert werden.
Die vom Benutzer ausgewählten Zahlen sollen für diese Übung nicht in lokalen Variablen abgelegt
werden, sondern in einem globalen Array. Erzeugen Sie hierfür zunächst ein privates, statisches,
finales Integer Array der Größe 3 global. Dazu muss sich die Definition außerhalb aller Methoden
befinden. Lesen Sie anschließend in Ihrer main Methode drei ganzzahlige Werte ein und speichern
Sie diese direkt in den drei Zellen des Arrays. Sortieren Sie, wie unten beschrieben diese drei Felder
und geben Sie das Ergebnis aus.
Erstellen Sie eine private, statische Methode swap, die zwei Positionen des globalen Array
übergeben bekommt und diese beiden miteinander vertauscht. Dies soll aber nur geschehen, wenn
beide Positionen sich innerhalb der Grenzen des Arrays befinden. Für diese Überprüfung können Sie
auf die Methode „length“ zurückgreifen.
Erstellen Sie eine weitere private, statische Methode sort, die die Inhalte der drei Felder des Arrays
miteinander vergleicht und der Größe nach sortiert. Verwenden Sie hierfür die soeben erstellte
Methode swap. Versuchen Sie mit so wenig Vergleichen wie möglich auszukommen.
Kleine Überlegung am Rande: Sie haben das Array als final, das heißt unveränderbar definiert.
Können Sie sich erklären, warum Sie dennoch die darin befindlichen Daten manipulieren konnten?
Übung 11:
Legen Sie ein Unterpaket „exercise11“ an. Erzeugen Sie darin eine Java-Klasse mit dem Namen
„Exercise_11“ und lassen Sie Eclipse die main Methode automatisch erstellen. In dieser Übung soll
eine einfache Personenverwaltung in Ansätzen implementiert werden.
Erzeugen Sie ein Unterpaket innerhalb von „exercise11“ mit dem Namen „classes“. Erzeugen sie
darin eine abstrakte Klasse „Person“ mit eingeschränkter Sichtbarkeit. Eine Person besitzt die beiden
Attribute „firstName“ und „lastName“. Für diese Attribute soll ein Standard Setter in der Klasse
bereits definiert werden. Lassen Sie dies Eclipse automatisch generieren (Source -> Generate Getter
and Setter…). Die Getter sollen an dieser Stelle allerdings nicht implementiert, sondern als abstrakt
gekennzeichnet werden! Zusätzlich soll noch folgender Konstruktor implementiert werden:
public Person(String firstName, String lastName) {
super();
this.firstName = firstName;
this.lastName = lastName;}
Leiten Sie von dieser Klasse die finale Klasse „Employee“ ab. Ein Angestellter besitzt neben einem
Vor- und Nachnamen noch eine ihm zugeteilte Abteilung („department“). Für diese können Sie
Eclipse ebenfalls Getter und Setter generieren lassen. Der Konstruktor für eine Instanz eines
Angestellten soll folgendermaßen aussehen:
public Employee(String firstName, String lastName,
String department) {
super(firstName, lastName);
this.department = department;}
Da „Employee“ von „Person“ abgeleitet wurde, muss diese Klasse die abstrakten Methoden der
super-Klasse implementieren. Für getFirstName() könnte dies z.B. so aussehen:
@Override
public String getFirstName() {
return super.firstName;}
Zusätzlich können Sie in abgeleiteten Klassen auch nicht abstrakte Methoden der Elternklasse
verfeinern. Für die Klasse der Angestellten soll dies beispielhaft mit der Methode toString
durchgeführt werden:
@Override
public String toString() {
return "Employee " + "(" + department + ") [firstName=" +
getFirstName() + ", lastName=" +
getLastName() + "]";}
Leiten Sie mit „External“ eine weitere Klasse von „Person“ ab. Einem Besucher soll ein Angestellter
als Betreuer („tutor“) zugeteilt werden können. Implementieren Sie alle benötigten Methoden,
genau wie Sie es bereits für Mitarbeiter getan haben. Allerdings soll der Getter für den Nachnamen
nun an den Nachnamen noch die Flag „_ex“ anhängen und die Ausgabe mit toString so
folgendermaßen aussehen (einen Zeilenumbruch innerhalb eines Strings erzeugen Sie mittels \n):
External [firstName=John, lastName=Doe_ex]
supervised by: Employee (AS) [firstName=Christoph, lastName=Stach]
Testen Sie, ob Sie die Klassen richtig implementiert haben, indem Sie in Ihrer main Methode die
beiden Mitarbeiter
Christoph Stach, Abteilung AS
Lars Geiger, Abteilung VS
anlegen. Erzeugen Sie eine Instanz eines Besuchers für sich und weisen Sie sich Christoph Stach als
Betreuer zu. Geben Sie die Instanz des Besuchers mittels toString aus.
Übung 12:
Legen Sie ein Unterpaket „exercise12“ an. Kopieren Sie die vorgegebene Klasse „Exercise_12“ in
dieses Paket. In dieser Übung soll die lineare mit der binären Suche verglichen werden. Erzeugen Sie
darin das Unterpaket „algorithms“. Kopieren Sie die Klasse „SearchAlgorithms“ in dieses Paket. Füllen
Sie die darin enthaltenen Dummy-Methoden „linearSearch“ und „binarySearch“ mit Code, der dem
unten aufgeführtem Pseudocode entspricht. Testen Sie das Programm und sehen Sie sich die Laufzeit
der beiden Algorithmen an. Die binäre Suche sollte in der Regel schneller sein, als die lineare.
Pseudocode:
LineareSuche (Feld, Element)
FÜR i VON 0 BIS Feldlänge – 1
WENN Feld[i] = Element
DANN RÜCKGABE i
RÜCKGABE -1
BinäreSuche (Feld, Element)
VAR Anfang = 0
VAR Ende = Feldlänge – 1
VAR Mitte
SOLANGE Anfang <= Ende
Mitte = (Anfang + Ende) / 2
WENN Feld[Mitte] < Element
DANN Anfang = Mitte + 1
SONST WENN Feld[Mitte] > Element
DANN Ende = Mitte – 1
SONST RÜCKGABE Mitte
RÜCKGABE -1