FreitagsrundenWiki - Benutzerbeiträge [de]

Javakurs/Übungsaufgaben

2011-03-22T11:21:25Z

130.149.17.40: /* Die Aufgaben */ Mehr lösungen!

Wir haben jeder Aufgabe eine Einschätzung ihrer Schwierigkeit auf einer Skala von 1 bis 10 vorangestellt. Bei dieser Einschätzung sind wir von einem Gehirn ausgegangen, für welches das jeweilige Themengebiet völlig neu ist, das jedoch schon ein ganz gutes Verständnis dafür hat wie eine Programmiersprache denn so funktioniert.
Entsprechend kann eine schwer bewertete Aufgabe aus einem frühen Themengebiet für manch einen sehr einfach oder eine leicht bewertete aus einem späten Themengebiet für einen anderen sehr schwer sein. Es ist nur ein Wert, der euch helfen soll eure nächste Aufgabe zu wählen. Einen kleinen Überblick zu den Schwierigkeitsgraden findet ihr ganz unten auf dieser Seite.

Falls ihr Anmerkungen zu den Aufgaben habt, könnt ihr die Diskussionsseiten der jeweiligen Aufgaben nutzen.

== Die Aufgaben ==

{| class="wikitable sortable" border="0" cellpadding="4" cellspacing="2"
|- bgcolor="#D8D8D8"
!Aufgabe
!Schwierigkeit
!Vorwissen
!Lerneffekte
!Überprüfer(Status)
!Musterlösung

|- bgcolor="#E8E8E8"
| [[Javakurs/Übungsaufgaben/Von der Console zum HelloWorld | Vom Arbeiten mit der Konsole bis "Hallo Welt"]]
| align="center" |1
| align="center" |1. VL
| Einfaches Arbeiten mit der Kommandozeile Kompilieren und Ausführen von Javacode
|
|[[Javakurs/Übungsaufgaben/Von der Console zum HelloWorld/Musterloesung | Musterlösung]]

|- bgcolor="#F5F5F5"
| [[Javakurs/Übungsaufgaben/Variablen_und_Zuweisungen | Variablen und Zuweisungen]]
| align="center" |1
| align="center" |1. VL
| Deklarieren und definieren von Variablen Grundlegende Regeln der Codeformatierung
|
| [[Javakurs/Übungsaufgaben/Variablen_und_Zuweisungen/Musterloesung | Musterlösung]]

|- bgcolor="#E8E8E8"
| [[Javakurs/Übungsaufgaben/Cowsay | Cowsay oder "Wie macht die Kuh?"]]
| align="center" |3
| align="center" |1. VL
| etwas mehr Bildschirmausgabe schöne Graphiken
|
| [[Javakurs/Übungsaufgaben/Cowsay/Musterloesung | Musterlösung]]

|- bgcolor="#F5F5F5"
| [[Javakurs/Übungsaufgaben/Kassenbon | Erstellen eines Kassenbons]]
| align="center" |2
| align="center" |1. VL
| Arbeiten mit Variablen Fallunterscheidungen
|
| [[Javakurs/Übungsaufgaben/Kassenbon/Musterloesung | Musterlösung]]

|- bgcolor="#E8E8E8"
| [[Javakurs/Übungsaufgaben/Javamenue | Ein eigenes Menü]]
| align="center" |3
| align="center" |1. VL
| Lesen von Benutzereingaben über die Konsole Fallunterscheidungen
|
| [[Javakurs/Übungsaufgaben/Javamenue/Musterloesung | Musterlösung]]

|- bgcolor="#F5F5F5"
| [[Javakurs/Übungsaufgaben/Glücksspiel | Glücksspiel]]
| align="center" |2
| align="center" |1. VL
| Anwenden von Fallunterscheidungen
|
| [[Javakurs/Übungsaufgaben/Glücksspiel/Musterloesung | Musterlösung]]

|- bgcolor="#E8E8E8"
| [[Javakurs/Übungsaufgaben/Arrays | Quickies Arrays]]
| align="center" |1
| align="center" |2. VL
| Verwenden von Arrays
|
| [[Javakurs/Übungsaufgaben/Arrays/Musterloesung | Musterlösung ]]

|- bgcolor="#F5F5F5"
| [[Javakurs/Übungsaufgaben/Verschachtelte_Schleifen | Verschachtelte Schleifen]]
| align="center" |3
| align="center" |2. VL
| Umgang mit mehreren verschachtelten Schleifen
|
| [[Javakurs/Übungsaufgaben/Verschachtelte Schleifen/Musterloesung|Musterlösung]]

|- bgcolor="#E8E8E8"
| [[Javakurs/Übungsaufgaben/Primzahlenaufgabe | Primzahlen]]
| align="center" |2-5
| align="center" |2. VL
| Geschicktes Einsetzen von Schleifen und Arrays
|
| [[Javakurs/Übungsaufgaben/Primzahlenaufgabe/Musterloesung|Musterlösung]]

|- bgcolor="#F5F5F5"
| [[Javakurs/Übungsaufgaben/Wetterstation | Wetterstation]]
| align="center" |4
| align="center" |2. VL
| Schleifen und Arrays
|
| [[Javakurs/Übungsaufgaben/Wetterstation/Musterloesung | Musterlösung]]

|- bgcolor="#E8E8E8"
| [[Javakurs/Übungsaufgaben/Geometrie | Geometrie]]
| align="center" |2
| align="center" |2. VL
| Volumenberechnung Lesen von Programmargumenten
|
|

|- bgcolor="#F5F5F5"
| [[Javakurs/Übungsaufgaben/Zweierpotenzen | Zweierpotenzen]]
| align="center" |3
| align="center" |2. VL
| Schleifen und Arrays
|
| [[Javakurs/Übungsaufgaben/Zweierpotenzen/Musterloesung | Musterlösung]]

|- bgcolor="#E8E8E8"
| [[Javakurs/Übungsaufgaben/Schleifen_und_Modulo | Schleifen und Modulo]]
| align="center" |5
| align="center" |2. VL
| Verwendung von Schleifen Benutzung des Modulo-Operators
|
| [[Javakurs/Übungsaufgaben/Schleifen_und_Modulo/Musterloesung | Musterlösung]]

|- bgcolor="#F5F5F5"
| [[Javakurs/Übungsaufgaben/Methoden | Quickies zu Methoden]]
| align="center" |2
| align="center" |3. VL
| Zusammenfassung der Vorlesung
|
|

|- bgcolor="#E8E8E8"
| [[Javakurs/Übungsaufgaben/MathematischeMethoden | Mathematische Methoden]]
| align="center" |3
| align="center" |3. VL
| Schreiben eigener Methoden
|
| [[Javakurs/Übungsaufgaben/MathematischeMethoden/Musterloesung | Musterlösung]]

|- bgcolor="#F5F5F5"
| [[Javakurs/Übungsaufgaben/Schaltjahr | Schaltjahr]]
| align="center" |3
| align="center" |3. VL
| Schreiben von Methoden Fallunterscheidungen Benutzerinteraktion
|
| [[Javakurs/Übungsaufgaben/Schaltjahr/Musterloesung | Musterlösung]]

|- bgcolor="#E8E8E8"
| [[Javakurs/Übungsaufgaben/Crack_the_Password | Crack the Password]]
| align="center" |3
| align="center" |2/3. VL
| Passwörter knacken ;-)
|
| [[Javakurs/Übungsaufgaben/Crack_the_Password/Musterloesung | Musterlösung]]

|- bgcolor="#F5F5F5"
| [[Javakurs/Übungsaufgaben/Rekursion_vs._Iteration | Rekursion vs. Iteration]]
| align="center" |5
| align="center" |3. VL
| Fehler finden
|
| [[Javakurs/Übungsaufgaben/Rekursion_vs._Iteration/Musterloesung | Mister Lösung]]

|- bgcolor="#E8E8E8"
| [[Javakurs/Übungsaufgaben/Lineare_Funktionen | Lineare Funktionen]]
| align="center" |5
| align="center" |3. VL
| Verwendung von Methoden Schleifen und Arrays
|
| [[Javakurs/Übungsaufgaben/Lineare_Funktionen/Musterloesung | Musterlösung]]

|- bgcolor="#F5F5F5"
| [[Javakurs/Übungsaufgaben/Fibonacci | Fibonaccizahlen]]
| align="center" |4
| align="center" |3. VL
| Schleifen und Arrays
|
| [[Javakurs/Übungsaufgaben/Fibonacci/Musterloesung | Musterlösung]]

|- bgcolor="#E8E8E8"
| [[Javakurs/Übungsaufgaben/Brainfuck | Brainfuck vs Turingmaschine]]
| align="center" |6
| align="center" |3. VL
| Arbeiten mit Arrays Allgemeinwissen :-)
|
| [[Javakurs/Übungsaufgaben/Brainfuck/Musterloesung | Musterlösung]]

|- bgcolor="#F5F5F5"
| [[Javakurs/Übungsaufgaben/Gau%C3%9F-Algorithmus | Gauß-Algorithmus]]
| align="center" |6
| align="center" |3. VL
| Arrays und Matrizen
|
| [[Javakurs/Übungsaufgaben/Gau%C3%9F-Algorithmus/Musterloesung | Musterlösung]]

|- bgcolor="#E8E8E8"
| [[Javakurs/Übungsaufgaben/Zahlenumrechner | Zahlenumrechner]]
| align="center" |4
| align="center" |3. VL
| Arbeiten mit Methoden mathematisches Denken
|
| [[Javakurs/Übungsaufgaben/Zahlenumrechner/Musterloesung | Musterlösung]]

|- bgcolor="#F5F5F5"
| [[Javakurs/Übungsaufgaben/Democracy | Der Fehler im System]]
| align="center" |3
| align="center" |3. VL
| Fehler finden
|
| [[Javakurs/Übungsaufgaben/Democracy/Musterloesung | Musterlösung]]

|- bgcolor="#E8E8E8"
| [[Javakurs/Übungsaufgaben/Quersumme | Spaß mit Quersummen]]
| align="center" |5 - 7
| align="center" |3. VL
| Benutzung des Modulo-Operators Auslagern von Funktionalität in Methoden
|
| [[Javakurs/Übungsaufgaben/Quersumme/Musterloesung | Musterlösung]]

|- bgcolor="#F5F5F5"
| [[Javakurs/Übungsaufgaben/Appleman | Appleman und Fraktale]]
| align="center" |7
| align="center" |3. VL
| Schleifen, Umgang mit Fließkommazahlen
|
| [[Javakurs/Übungsaufgaben/Appleman/Musterloesung | Musterlösung]]

|- bgcolor="#F5F5F5"
| [[Javakurs/Übungsaufgaben/DiffusionLimitedAggregation | Diffusion Limited Aggregation]]
| align="center" |7
| align="center" |3. VL
| 2-dimensionale Arrays, Methoden, Schleifen, Grafische Ausgabe
|
| [[Javakurs/Übungsaufgaben/DiffusionLimitedAggregation/Musterloesung | Musterlösung]]

|- bgcolor="#E8E8E8"
| [[Javakurs/Übungsaufgaben/Palindrome | Palindrome]]
| align="center" |3
| align="center" |4. VL
| Entwurf von Programmen Parameterübergabe beim Programmaufruf
|
| [[Javakurs/Übungsaufgaben/Palindrome/Musterloesung | Musterlösung]]

|- bgcolor="#E8E8E8"
| [[Javakurs/Übungsaufgaben/DDDText | DDDText]]
| align="center" | 3
| align="center" | 4. VL
| Ausgabe von Buchstaben als 3D Buchstaben
|
| [[Javakurs/Übungsaufgaben/DDDText/Musterloesung | Musterlösung]]

|- bgcolor="#F5F5F5"
| [[Javakurs/Übungsaufgaben/Hangman | Hangman]]
| align="center" |5
| align="center" |4. VL
| Entwurf von Programmen Arbeiten mit Methoden
|
| [[Javakurs/Übungsaufgaben/Hangman/Musterloesung | Musterlösung]]

|- bgcolor="#E8E8E8"
| [[Javakurs/Übungsaufgaben/SelectionSort | Selection Sort]]
| align="center" |5
| align="center" |4. VL
| Verstehen von komplexeren Algorithmen Schleifen und Arrays (Hilfs-)Methoden
|
| [[Javakurs/Übungsaufgaben/SelectionSort/Musterloesung | Musterlösung]]

|- bgcolor="#F5F5F5"
| [[Javakurs/Übungsaufgaben/Cäsar-Chiffre | Chiffrierung/Dechiffrierung (Cäsar)]]
| align="center" |7
| align="center" |4. VL
| Eigenständiges Problemlösen. Alle Konzepte des Kurses
|
|

|- bgcolor="#E8E8E8"
| [[Javakurs/Übungsaufgaben/Abzaehlspiel | Abzählspiel]]
| align="center" |8
| align="center" |4. VL
| Analyse von Aufgabenstellungen Entwurf eines komplexen Programms von Grund auf
|
|

|- bgcolor="#F5F5F5"
| [[Javakurs/Übungsaufgaben/Rennschnecke | Schneckenrennen]]
| align="center" |5
| align="center" |5. VL
| Objektorientierte Programmierung
|
|

|- bgcolor="#E8E8E8"
| [[Javakurs/Übungsaufgaben/Studentendatenbank | Studentendatenbank]]
| align="center" |4
| align="center" |5. VL
| Vertiefung in objektorientiertes Programmieren
|
|

|- bgcolor="#F5F5F5"
| [[Javakurs/Übungsaufgaben/Kassenbon++ | Erstellen eines Kassenbons mit Kapselung]]
| align="center" |5
| align="center" |5. VL
| Arbeiten mit Klassen Kapselung JavaAPI
|
|

|- bgcolor="#E8E8E8"
| [[Javakurs/Übungsaufgaben/Multiarray| Mehrdimensionale Arrays]]
| align="center" |5-9
| align="center" |5. VL
| Methoden, Schleifen, Arrays Objektorientierung
|
|

|- bgcolor="#F5F5F5"
| [[Javakurs/Übungsaufgaben/Canvas | Virtuelles Canvas mit 3D-Objekten]]
| align="center" |5
| align="center" |6. VL
| Arbeiten mit Methoden mathematisches Denken
|
|

|- bgcolor="#E8E8E8"
| [[Javakurs/Übungsaufgaben/Doom | ASCII DOOM ]]
| align="center" |7-10
| align="center" |6. VL
| Vertiefung in objektorientierte Programmierung Benutzung der Java-API
|
|

|- bgcolor="#F5F5F5"
| [[Javakurs/Übungsaufgaben/Textwordcount | Texte lesen und analysieren]]
| align="center" |7
| align="center" |6. VL
| Eigenständiges Problemlösen Goethe vs. Karl May
|
|

|- bgcolor="#E8E8E8"
| [[Javakurs/Übungsaufgaben/OOPStateCharts | StateCharts ]]
| align="center" |5
| align="center" |6. VL
| Zustandsdiagramme (StateCharts) und OOP
|
|

|- bgcolor="#F5F5F5"
| [[Javakurs/Übungsaufgaben/AsciiCraft | ASCII Craft ]]
| align="center" |5-10
| align="center" |1-6. VL
| CodeLesen, Zusammenfassung, [http://www.minecraft.net minecraft] in 2D und ASCII
|
| <nicht anwendbar>

|}

== Schwierigkeitsgrade ==

# Reines Tutorial. Man muss nicht viel selbst denken
# ...
# Leichte Übungsaufgabe. Studies, die noch eher unsicher sind werden hier gut begleitet.
# ...
# Typische Aufgabe. Man muss den Kopf benutzen, bekommt an schwierigen Stellen aber Hilfestellungen.
# ...
# Herausfordernd, eher etwas für Studies die etwas fitter sind.
# ...
# Auch erfahrene Programmierer weden hier ein bis zwei Übungen beschäftigt sein 
# Tja, die Idee war da. Wir finden sie auch gut, aber es könnte wirklich anstrengend werden.

== Kleine und große Probleme ==

- Die Tubit-Accounts haben nicht /bin/bash als shell, so dass die Cursortasten nicht funktionieren. Workaround: als erstes Kommando 'bash' eingeben, man sieht dann auch in welchem Verzeichnis man gerade ist.

== Links ==
* [[Javakurs_2011/Feedback|Feedback zum Kurs 2011]]
* [[Javakurs_2010/Feedback|Feedback zum Kurs 2010]]

[[Kategorie:Java]]
[[Kategorie:Java_Aufgaben]]

C-Kurs/ckdu

2010-09-17T15:03:56Z

130.149.17.40: Alles besser :-)

Diese Aufgabe ist eine besondere Aufgabe. Sie wird/wurde in der 7. Vorlesung live fast komplett implementiert. Da dies sehr viel ist und damit wichtige Fragen dort geklaert werden koennen, probiert diese Aufgabe zu Hause '''übers Wochenende''' doch schon mal '''selbst zu implementieren'''.

= Aufbau dieser Seite =
Es gibt mehrere Stufen. Das heißt wir haben diese große Aufgabe schon für euch in kleine Happen geteilt. Wenn ihr also ''wirklich'' nicht weiterkommt, könnt ihr euch in der Vorgabe (base1.c bis base 3.c) der nächst höheren Stufe angucken wie wir es gelöst haben. Aber bedenke: Jede Stufe wird ein bisschen anspruchsvoller!

= Funktion =
ckdu soll wie das Tool ''du'' auch, eine Auflistung aller Dateien/Ordner und deren Größe. Zusätzlich soll ckdu diese Liste auch sortieren und menschlich Lesbar gestalten (in KB, MB, GB).

= Stufen =
== 1. Stufe ==
Ordnerinhalt einlesen und ausgeben.
Ähnliche wie: ls -1s

''so koennte das dann aussehen:''
<pre>
4 img
29832 HelloWorld.pdf
0 HelloWorld.snm
36 HelloWorld.tex
</pre>

=== Vorgabe ===
* [http://git.goodpoint.de/?p=ckdu-live.git;a=blob_plain;f=base1.c;hb=HEAD Download (base1.c)]

== 2. Stufe ==
Refactoring !
Eingelesene Inhalte in einer Liste speichern.
Diese Liste wieder Ausgaben.

=== Vorgabe ===
* [http://git.goodpoint.de/?p=ckdu-live.git;a=blob_plain;f=base2.c;hb=HEAD Download (base2.c)]

== 3. Stufe ==

Ordnerinhalte rekursiv aufaddieren

''so koennte das dann aussehen:''
<pre>
0.0M HelloWorld.snm
30.0M HelloWorld.pdf
36.0K HelloWorld.tex
153.0M img/
12.0M uebung.png
24.0M vortrag.png
86.0M world2.png
3.0M world.png
</pre>

=== Vorgabe ===
* [http://git.goodpoint.de/?p=ckdu-live.git;a=blob_plain;f=base3.c;hb=HEAD Download (base3.c)]

== 4. Stufe ==
sortieren nach Groesse (absteigend)

''so koennte das dann aussehen:''
<pre>
153.0M img/
12.0M uebung.png
24.0M vortrag.png
86.0M world2.png
3.0M world.png
30.0M HelloWorld.pdf
36.0K HelloWorld.tex
0.0M HelloWorld.snm
</pre>

=== Vorgabe ===
* ''Absichtlich keine Vorgabe. Bitte erweitert eure Lösung von Stufe 3.''

== 5. Stufe ==
In dieser Stufe folgen alle wichtigen Sachen, die man noch beachten '''muss''', wenn man auf dem Dateisystem operiert.
Außerdem bieten wir einige Ideen mit denen du dein ckdu erweiteren kannst :)

* Symlinks nur einmal folgen (Parameter)
* Hardlinks nur einmal folgen
* Oredntliches Fehler-handling
* du-parameter-kompatible:
** "--max-depth"
** basierend auf getopt
** Device verlassen verbieten
* Wird nicht von den Betreuern betreut:
** Farbige Ausgabe
** Interaktivität
** Einlesen mit mehreren Threads?

=== Vorgabe ===
* ''Absichtlich keine Vorgabe. Bitte erweitert eure Lösung von Stufe 4.''

C-Kurs/ckdu

2010-09-17T15:00:04Z

130.149.17.40: /* 3. Stufe */ Stufe 3 Output anpassen

Diese Aufgabe ist eine besondere Aufgabe. Sie wird/wurde in der 7. Vorlesung live fast komplett implementiert. Da dies sehr viel ist und damit wichtige Fragen dort geklaert werden koennen, probiert diese Aufgabe zu Hause '''übers Wochenende''' doch schon mal '''selbst zu implementieren'''.

= Aufbau dieser Seite =
Es gibt mehrere Stufen. Das heißt wir haben diese große Aufgabe schon für euch in kleine Happen geteilt. Wenn ihr also ''wirklich'' nicht weiterkommt, könnt ihr euch in der Vorgabe (base1.c bis base 3.c) der nächst höheren Stufe angucken wie wir es gelöst haben. Aber bedenke: Jede Stufe wird ein bisschen anspruchsvoller!

= Funktion =
ckdu soll wie das Tool ''du'' auch, eine Auflistung aller Dateien/Ordner und deren Größe. Zusätzlich soll ckdu diese Liste auch sortieren und menschlich Lesbar gestalten (in KB, MB, GB).

= Stufen =
== 1. Stufe ==
Ordnerinhalt einlesen und ausgeben.
Ähnliche wie: ls -1s

''so koennte das dann aussehen:''
<pre>
4 img
29832 HelloWorld.pdf
0 HelloWorld.snm
36 HelloWorld.tex
</pre>

=== Vorgabe ===
* [http://git.goodpoint.de/?p=ckdu-live.git;a=blob_plain;f=base1.c;hb=HEAD Download (base1.c)]

== 2. Stufe ==
Refactoring !
Eingelesene Inhalte in einer Liste speichern.
Diese Liste wieder Ausgaben.

=== Vorgabe ===
* [http://git.goodpoint.de/?p=ckdu-live.git;a=blob_plain;f=base2.c;hb=HEAD Download (base2.c)]

== 3. Stufe ==

Ordnerinhalte rekursiv aufaddieren

''so koennte das dann aussehen:''
<pre>
153.0M img/
12.0M uebung.png
24.0M vortrag.png
86.0M world2.png
3.0M world.png
30.0M HelloWorld.pdf
0.0M HelloWorld.snm
36.0K HelloWorld.tex
</pre>

=== Vorgabe ===
* [http://git.goodpoint.de/?p=ckdu-live.git;a=blob_plain;f=base3.c;hb=HEAD Download (base3.c)]

== 4. Stufe ==
sortieren nach Groesse (absteigend)

''so koennte das dann aussehen:''
<pre>
153M img/
86,1M img/world2.png
24,9M img/vortrag.png
12,9M img/uebung.png
3,9M img/world.png
30M HelloWorld.pdf
36K HelloWorld.tex
0 HelloWorld.snm
</pre>

=== Vorgabe ===
* ''Absichtlich keine Vorgabe. Bitte erweitert eure Lösung von Stufe 3.''

== 5. Stufe ==
In dieser Stufe folgen alle wichtigen Sachen, die man noch beachten '''muss''', wenn man auf dem Dateisystem operiert.
Ausserdem bieten wir einige Ideen mit denen du dein ckdu erweiteren kannst :)

* Symlinks nur einmal Folgen (parameter)
* Hardlinks nur einmal Folgen

* Fehler-handling

* du-parameter-kompatible:
** "--max-depth"
** getopt
** device verlassen

* Wird nicht von den Betreuern betreut:
** Farbige ausgabe
** interaktive

=== Vorgabe ===
* ''Absichtlich keine Vorgabe. Bitte erweitert eure Lösung von Stufe 4.''

C-Kurs/ckdu

2010-09-17T14:58:12Z

130.149.17.40:

Diese Aufgabe ist eine besondere Aufgabe. Sie wird/wurde in der 7. Vorlesung live fast komplett implementiert. Da dies sehr viel ist und damit wichtige Fragen dort geklaert werden koennen, probiert diese Aufgabe zu Hause '''übers Wochenende''' doch schon mal '''selbst zu implementieren'''.

= Aufbau dieser Seite =
Es gibt mehrere Stufen. Das heißt wir haben diese große Aufgabe schon für euch in kleine Happen geteilt. Wenn ihr also ''wirklich'' nicht weiterkommt, könnt ihr euch in der Vorgabe (base1.c bis base 3.c) der nächst höheren Stufe angucken wie wir es gelöst haben. Aber bedenke: Jede Stufe wird ein bisschen anspruchsvoller!

= Funktion =
ckdu soll wie das Tool ''du'' auch, eine Auflistung aller Dateien/Ordner und deren Größe. Zusätzlich soll ckdu diese Liste auch sortieren und menschlich Lesbar gestalten (in KB, MB, GB).

= Stufen =
== 1. Stufe ==
Ordnerinhalt einlesen und ausgeben.
Ähnliche wie: ls -1s

''so koennte das dann aussehen:''
<pre>
4 img
29832 HelloWorld.pdf
0 HelloWorld.snm
36 HelloWorld.tex
</pre>

=== Vorgabe ===
* [http://git.goodpoint.de/?p=ckdu-live.git;a=blob_plain;f=base1.c;hb=HEAD Download (base1.c)]

== 2. Stufe ==
Refactoring !
Eingelesene Inhalte in einer Liste speichern.
Diese Liste wieder Ausgaben.

=== Vorgabe ===
* [http://git.goodpoint.de/?p=ckdu-live.git;a=blob_plain;f=base2.c;hb=HEAD Download (base2.c)]

== 3. Stufe ==

Ordnerinhalte rekursiv aufaddieren

''so koennte das dann aussehen:''
<pre>
153M img/
12,9M img/uebung.png
24,9M img/vortrag.png
86,1M img/world2.png
3,9M img/world.png
30M HelloWorld.pdf
0 HelloWorld.snm
36K HelloWorld.tex
</pre>

=== Vorgabe ===
* [http://git.goodpoint.de/?p=ckdu-live.git;a=blob_plain;f=base3.c;hb=HEAD Download (base3.c)]

== 4. Stufe ==
sortieren nach Groesse (absteigend)

''so koennte das dann aussehen:''
<pre>
153M img/
86,1M img/world2.png
24,9M img/vortrag.png
12,9M img/uebung.png
3,9M img/world.png
30M HelloWorld.pdf
36K HelloWorld.tex
0 HelloWorld.snm
</pre>

=== Vorgabe ===
* ''Absichtlich keine Vorgabe. Bitte erweitert eure Lösung von Stufe 3.''

== 5. Stufe ==
In dieser Stufe folgen alle wichtigen Sachen, die man noch beachten '''muss''', wenn man auf dem Dateisystem operiert.
Ausserdem bieten wir einige Ideen mit denen du dein ckdu erweiteren kannst :)

* Symlinks nur einmal Folgen (parameter)
* Hardlinks nur einmal Folgen

* Fehler-handling

* du-parameter-kompatible:
** "--max-depth"
** getopt
** device verlassen

* Wird nicht von den Betreuern betreut:
** Farbige ausgabe
** interaktive

=== Vorgabe ===
* ''Absichtlich keine Vorgabe. Bitte erweitert eure Lösung von Stufe 4.''

C-Kurs/ckdu

2010-09-17T14:51:19Z

130.149.17.40: Fixes

Diese Aufgabe ist eine besondere Aufgabe. Sie wird/wurde in der 7. Vorlesung live fast komplett implementiert. Da dies sehr viel ist und damit wichtige Fragen dort geklaert werden koennen, probiert diese Aufgabe zu Hause '''übers Wochenende''' doch schon mal '''selbst zu implementieren'''.

= Aufbau dieser Seite =
Es gibt mehrere Stufen. Das heißt wir haben diese große Aufgabe schon für euch in kleine Happen geteilt. Wenn ihr also ''wirklich'' nicht weiterkommt, könnt ihr euch in der Vorgabe (base1.c bis base 3.c) der nächst höheren Stufe angucken wie wir es gelöst haben. Aber bedenke: Jede Stufe wird ein bisschen anspruchsvoller!

= Funktion =
ckdu soll wie das Tool ''du'' auch, eine Auflistung aller Dateien/Ordner und deren Groesse. Zusätzlich soll ckdu diese Liste auch sortieren und menschlich Lesbar gestalten (in KB, MB, GB).

= Stufen =
== 1. Stufe ==
Ordnerinhalt einlesen und ausgeben.
Ähnliche wie: ls -1s

''so koennte das dann aussehen:''
<pre>
4 img
29832 HelloWorld.pdf
0 HelloWorld.snm
36 HelloWorld.tex
</pre>

=== Vorgabe ===
* [http://git.goodpoint.de/?p=ckdu-live.git;a=blob_plain;f=base1.c;hb=HEAD Download (base1.c)]

== 2. Stufe ==
Refactoring !
Eingelesene Inhalte in einer Liste speichern.
Diese Liste wieder Ausgaben.

=== Vorgabe ===
* [http://git.goodpoint.de/?p=ckdu-live.git;a=blob_plain;f=base2.c;hb=HEAD Download (base2.c)]

== 3. Stufe ==

Ordnerinhalte rekursiv aufaddieren

''so koennte das dann aussehen:''
<pre>
153M img/
12,9M img/uebung.png
24,9M img/vortrag.png
86,1M img/world2.png
3,9M img/world.png
30M HelloWorld.pdf
0 HelloWorld.snm
36K HelloWorld.tex
</pre>

=== Vorgabe ===
* [http://git.goodpoint.de/?p=ckdu-live.git;a=blob_plain;f=base3.c;hb=HEAD Download (base3.c)]

== 4. Stufe ==
sortieren nach Groesse (absteigend)

''so koennte das dann aussehen:''
<pre>
153M img/
86,1M img/world2.png
24,9M img/vortrag.png
12,9M img/uebung.png
3,9M img/world.png
30M HelloWorld.pdf
36K HelloWorld.tex
0 HelloWorld.snm
</pre>

=== Vorgabe ===
* ''Absichtlich keine Vorgabe. Bitte erweitert eure Lösung von Stufe 3.''

== 5. Stufe ==
In dieser Stufe folgen alle wichtigen Sachen, die man noch beachten '''muss''', wenn man auf dem Dateisystem operiert.
Ausserdem bieten wir einige Ideen mit denen du dein ckdu erweiteren kannst :)

* Symlinks nur einmal Folgen (parameter)
* Hardlinks nur einmal Folgen

* Fehler-handling

* du-parameter-kompatible:
** "--max-depth"
** getopt
** device verlassen

* Wird nicht von den Betreuern betreut:
** Farbige ausgabe
** interaktive

=== Vorgabe ===
* ''Absichtlich keine Vorgabe. Bitte erweitert eure Lösung von Stufe 4.''

C-Kurs/ckdu

2010-09-17T14:14:22Z

130.149.17.40: Vorgaben ausfüllen (Text und Links)

Diese Aufgabe ist eine besondere Aufgabe. Sie wird(wurde) in der 7.Vorlesung fast komplett Implementiert. Da dies sehr viel ist - und damit wichtige Fragen dort geklaert werden koennen, probiert diese Aufgabe zu Hause uebers Wochenende doch schon mal selbst zu implementieren.

= Aufbau dieser Seite =
Es gibt mehrere Stufen. D.h. wir haben diese grosse Aufgabe schon fuer euch in kleine Happen geteilt. Wenn ihr also _wirklich_ nicht weiterkommt, koennt ihr euch in der Vorgabe (base) der naechst hoeheren Stufe angucken wie wir es geloest haben. Aber bedenke: Jede Stufe wird anspruchsvoller!

= Funktion =
ckdu soll wie das Tool ''du'' auch, eine Auflistung aller Dateien/Ordner und deren Groesse. Zusaetzlich soll ckdu diese Liste auch sortieren und menschlich Lesbar gestalten (in KB,MB,GB).

= Stufen =
== 1. Stufe ==
Ordnerinhalt einlesen und ausgeben.
Aehnliche wie: ls -1s

''so koennte das dann aussehen:''
<pre>
4 img
29832 HelloWorld.pdf
0 HelloWorld.snm
36 HelloWorld.tex
</pre>

=== Vorgabe ===
* [http://git.goodpoint.de/?p=ckdu-live.git;a=blob_plain;f=base1.c;hb=HEAD Download (base1.c)]

== 2. Stufe ==
Refactoring !
Eingelesene Inhalte in einer Liste speichern.
Diese Liste wieder Ausgaben.

=== Vorgabe ===
* [http://git.goodpoint.de/?p=ckdu-live.git;a=blob_plain;f=base2.c;hb=HEAD Download (base2.c)]

== 3. Stufe ==

Ordnerinhalte rekursiv aufaddieren

''so koennte das dann aussehen:''
<pre>
153M img/
12,9M img/uebung.png
24,9M img/vortrag.png
86,1M img/world2.png
3,9M img/world.png
30M HelloWorld.pdf
0 HelloWorld.snm
36K HelloWorld.tex
</pre>

=== Vorgabe ===
* [http://git.goodpoint.de/?p=ckdu-live.git;a=blob_plain;f=base3.c;hb=HEAD Download (base3.c)]

== 4. Stufe ==
sortieren nach Groesse (absteigend)

''so koennte das dann aussehen:''
<pre>
153M img/
86,1M img/world2.png
24,9M img/vortrag.png
12,9M img/uebung.png
3,9M img/world.png
30M HelloWorld.pdf
36K HelloWorld.tex
0 HelloWorld.snm
</pre>

=== Vorgabe ===
* ''Absichtlich keine Vorgabe. Bitte erweitert eure Lösung von Stufe 3.''

== 5. Stufe ==
In dieser Stufe folgen alle wichtigen Sachen, die man noch beachten '''muss''', wenn man auf dem Dateisystem operiert.
Ausserdem bieten wir einige Ideen mit denen du dein ckdu erweiteren kannst :)

* Symlinks nur einmal Folgen (parameter)
* Hardlinks nur einmal Folgen

* Fehler-handling

* du-parameter-kompatible:
** "--max-depth"
** getopt
** device verlassen

* Wird nicht von den Betreuern betreut:
** Farbige ausgabe
** interaktive

=== Vorgabe ===
* ''Absichtlich keine Vorgabe. Bitte erweitert eure Lösung von Stufe 4.''

C-Kurs/ckdu

2010-09-17T14:09:48Z

130.149.17.40: /* Vorgabe */ Link einfügen

Diese Aufgabe ist eine besondere Aufgabe. Sie wird(wurde) in der 7.Vorlesung fast komplett Implementiert. Da dies sehr viel ist - und damit wichtige Fragen dort geklaert werden koennen, probiert diese Aufgabe zu Hause uebers Wochenende doch schon mal selbst zu implementieren.

= Aufbau dieser Seite =
Es gibt mehrere Stufen. D.h. wir haben diese grosse Aufgabe schon fuer euch in kleine Happen geteilt. Wenn ihr also _wirklich_ nicht weiterkommt, koennt ihr euch in der Vorgabe (base) der naechst hoeheren Stufe angucken wie wir es geloest haben. Aber bedenke: Jede Stufe wird anspruchsvoller!

= Funktion =
ckdu soll wie das Tool ''du'' auch, eine Auflistung aller Dateien/Ordner und deren Groesse. Zusaetzlich soll ckdu diese Liste auch sortieren und menschlich Lesbar gestalten (in KB,MB,GB).

= Stufen =
== 1. Stufe ==
Ordnerinhalt einlesen und ausgeben.
Aehnliche wie: ls -1s

''so koennte das dann aussehen:''
<pre>
4 img
29832 HelloWorld.pdf
0 HelloWorld.snm
36 HelloWorld.tex
</pre>

=== Vorgabe ===
* [http://git.goodpoint.de/?p=ckdu-live.git;a=blob_plain;f=base1.c;hb=HEAD Download (base1.c)]

== 2. Stufe ==
Refactoring !
Eingelesene Inhalte in einer Liste speichern.
Diese Liste wieder Ausgaben.

== 3. Stufe ==

Ordnerinhalte rekursiv aufaddieren

''so koennte das dann aussehen:''
<pre>
153M img/
12,9M img/uebung.png
24,9M img/vortrag.png
86,1M img/world2.png
3,9M img/world.png
30M HelloWorld.pdf
0 HelloWorld.snm
36K HelloWorld.tex
</pre>

== 4. Stufe ==
sortieren nach Groesse (absteigend)

''so koennte das dann aussehen:''
<pre>
153M img/
86,1M img/world2.png
24,9M img/vortrag.png
12,9M img/uebung.png
3,9M img/world.png
30M HelloWorld.pdf
36K HelloWorld.tex
0 HelloWorld.snm
</pre>

== 5. Stufe ==
In dieser Stufe folgen alle wichtigen Sachen, die man noch beachten '''muss''', wenn man auf dem Dateisystem operiert.
Ausserdem bieten wir einige Ideen mit denen du dein ckdu erweiteren kannst :)

* Symlinks nur einmal Folgen (parameter)
* Hardlinks nur einmal Folgen

* Fehler-handling

* du-parameter-kompatible:
** "--max-depth"
** getopt
** device verlassen

* Wird nicht von den Betreuern betreut:
** Farbige ausgabe
** interaktive

C-Kurs/ckdu

2010-09-17T14:06:10Z

130.149.17.40: /* Aubau dieser Seite */ typo

Diese Aufgabe ist eine besondere Aufgabe. Sie wird(wurde) in der 7.Vorlesung fast komplett Implementiert. Da dies sehr viel ist - und damit wichtige Fragen dort geklaert werden koennen, probiert diese Aufgabe zu Hause uebers Wochenende doch schon mal selbst zu implementieren.

= Aufbau dieser Seite =
Es gibt mehrere Stufen. D.h. wir haben diese grosse Aufgabe schon fuer euch in kleine Happen geteilt. Wenn ihr also _wirklich_ nicht weiterkommt, koennt ihr euch in der Vorgabe (base) der naechst hoeheren Stufe angucken wie wir es geloest haben. Aber bedenke: Jede Stufe wird anspruchsvoller!

= Funktion =
ckdu soll wie das Tool ''du'' auch, eine Auflistung aller Dateien/Ordner und deren Groesse. Zusaetzlich soll ckdu diese Liste auch sortieren und menschlich Lesbar gestalten (in KB,MB,GB).

= Stufen =
== 1. Stufe ==
Ordnerinhalt einlesen und ausgeben.
Aehnliche wie: ls -1s

''so koennte das dann aussehen:''
<pre>
4 img
29832 HelloWorld.pdf
0 HelloWorld.snm
36 HelloWorld.tex
</pre>

=== Vorgabe ===
* ''hier Link zur Vorgabe einfuegen''
== 2. Stufe ==
Refactoring !
Eingelesene Inhalte in einer Liste speichern.
Diese Liste wieder Ausgaben.

== 3. Stufe ==

Ordnerinhalte rekursiv aufaddieren

''so koennte das dann aussehen:''
<pre>
153M img/
12,9M img/uebung.png
24,9M img/vortrag.png
86,1M img/world2.png
3,9M img/world.png
30M HelloWorld.pdf
0 HelloWorld.snm
36K HelloWorld.tex
</pre>

== 4. Stufe ==
sortieren nach Groesse (absteigend)

''so koennte das dann aussehen:''
<pre>
153M img/
86,1M img/world2.png
24,9M img/vortrag.png
12,9M img/uebung.png
3,9M img/world.png
30M HelloWorld.pdf
36K HelloWorld.tex
0 HelloWorld.snm
</pre>

== 5. Stufe ==
In dieser Stufe folgen alle wichtigen Sachen, die man noch beachten '''muss''', wenn man auf dem Dateisystem operiert.
Ausserdem bieten wir einige Ideen mit denen du dein ckdu erweiteren kannst :)

* Symlinks nur einmal Folgen (parameter)
* Hardlinks nur einmal Folgen

* Fehler-handling

* du-parameter-kompatible:
** "--max-depth"
** getopt
** device verlassen

* Wird nicht von den Betreuern betreut:
** Farbige ausgabe
** interaktive

C-Kurs 2009/forschleife/Musterlösung

2009-09-24T09:22:09Z

130.149.17.40: Die Seite wurde neu angelegt: „Die Forschleife im Programm überschreitet beim Schreiben auf das Array a die Arraygrenze. Es wird damit die Speicherstelle nach dem Array überschrieben. Bei ein...“

Die Forschleife im Programm überschreitet beim Schreiben auf das Array a die Arraygrenze.
Es wird damit die Speicherstelle nach dem Array überschrieben.
Bei einigen Rechnerarchitekturen befindet sich dort die Zählervariable i,
die daraufhin wieder auf 0 gesetzt wird.

C-Kurs/Übungsaufgaben

2009-09-24T09:00:05Z

130.149.17.40: /* Die Aufgaben */

Wir haben jeder Aufgabe eine Einschätzung ihrer Schwierigkeit auf einer Skala von 1 bis 10 vorangestellt. Bei dieser Einschätzung sind wir von einem Gehirn ausgegangen, für welches das jeweilige Themengebiet völlig neu ist, das jedoch schon ein ganz gutes Verständnis dafür hat wie eine Programmiersprache denn so funktioniert.
Entsprechend kann eine schwer bewertete Aufgabe aus einem frühen Themengebiet für manch einen sehr einfach oder eine leicht bewertete aus einem späten Themengebiet für einen anderen sehr schwer sein. Es ist nur ein Wert, der euch helfen soll eure nächste Aufgabe zu wählen.

Falls ihr Anmerkungen zu den Aufgaben habt, könnt ihr die Diskussionsseiten der jeweiligen Aufgaben nutzen.

== Schwierigkeitsgrade ==

# Reines Tutorial. Man muss nicht viel selbst denken
# ...
# Leichte Übungsaufgabe. Studies, die noch eher unsicher sind werden hier gut begleitet.
# ...
# Typische Aufgabe. Man muss den Kopf benutzen, bekommt an schwierigen Stellen aber Hilfestellungen.
# ...
# Herausfordernd, eher etwas für Studies die etwas fitter sind.
# ...
# Auch erfahrene Programmierer werden hier ein bis zwei Übungen beschäftigt sein 
# Tja, die Idee war da. Wir finden sie auch gut, aber es könnte wirklich anstrengend werden.

== Die Aufgaben ==

{| border="0" cellpadding="4" cellspacing="2"
|- bgcolor="#D8D8D8"
!Aufgabe
!Schwierigkeit
!Vorwissen
!Lerneffekte
!Bearbeiter
!Korrektur gelesen
!Musterlösung
|- bgcolor="#F5F5F5"
| [[Ckurs2009/Von der Konsole zum HelloWorld | Von der Konsole zum HelloWorld]]
| align="center" |1
| align="center" |1. VL
| Konsole benutzen, Hello World
| Sebastian D.
| [[Benutzer:Mario|Mario]]
|
|- bgcolor="#E8E8E8"
| [[Ckurs2009/Fakultät | Fakultät]]
| align="center" |2
| align="center" |1. VL
| Schleifen
| Sebastian D.
| Daniel
|
|- bgcolor="#F5F5F5"
| [[Ckurs2009/Base64 | Base64]]
| align="center" |6
| align="center" |1. VL
| Operatoren
| Sebastian D.
|
| [[Ckurs2009/Base64/Musterlösung | Base64]]
|- bgcolor="#E8E8E8"
| [[Ckurs2009/EingabeAusgabe | Ein- und Ausgabe]]
| align="center" |1
| align="center" |2. VL
| Einlesen von Benutzereingaben Ausgabe derselben
| [[Benutzer:Mario|Mario]]
| nion
| [[Ckurs2009/EingabeAusgabe/Musterlösung | Ein- und Ausgabe]]
|- bgcolor="#F5F5F5"
| [[Ckurs2009/Taschenrechner | Taschenrechner]]
| align="center" |3
| align="center" |2. VL
| Eingabe+Ausgabe Mathematische Operatoren
| [[Benutzer:Mario|Mario]]
| [[Benutzer:Tkroenert|TKroenert]]
| [[Ckurs2009/Taschenrechner/Musterlösung | Taschenrechner]]
|- bgcolor="#E8E8E8"
| [[Ckurs2009/VerschachtelteSchleifen | Verschachtelte Schleifen]]
| align="center" |3
| align="center" |2. VL
| Umgang mit mehreren verschachtelten Schleifen
| [[Benutzer:Dank|Daniel K.]]
| AlexanderK
|
|- bgcolor="#F5F5F5"
| [[Ckurs2009/Glückspiel | Glücksspiel]]
| align="center" |3
| align="center" |2. VL
| Anwenden von Fallunterscheidungen und Einlesen von Werten aus der Konsole
| [[Benutzer:Dank|Daniel K.]]
| AlexanderK
| [[Ckurs2009/Glückspiel/Musterlösung | Glückspiel]]
|- bgcolor="#E8E8E8"
| [[Ckurs2009/Wochentag | Wochentagsrechnung]]
| align="center" |5
| align="center" |2. VL
| Einlesen von Benutzereingaben Mathematikverständniss
| [[Benutzer:Mario|Mario]]
| nion (Musterlösung noch nicht vorhanden)
|
|- bgcolor="#F5F5F5"
| [[Ckurs2009/Taschenrechner2.0 | Taschenrechner ''2.0'']]
| align="center" |8
| align="center" |2. VL
| Knobeln Komplexes Aufgaben lösen
| [[Benutzer:Mario|Mario]]
| Martin K.
| [[Ckurs2009/Taschenrechner2.0/Musterlösung | Taschenrechner ''2.0'']]
|- bgcolor="#E8E8E8"
| [[Ckurs2009/Call by reference | Call by reference]]
| align="center" |4
| align="center" |3. VL
| Einfache Anwendung von &/*
| sping
| nion
| [[Ckurs2009/Call by reference/Musterlösung | Call by reference]]
|- bgcolor="#F5F5F5"
| [[Ckurs2009/Text processing | Text processing]]
| align="center" |4, 6
| align="center" |3. VL
| Strings Pointer-Arithmetik Pointer auf Pointer Refactoring
| sping
| [[Benutzer:Mario|Mario]]
| [[Ckurs2009/Text processing/Musterlösung | Text processing]]
|- bgcolor="#E8E8E8"
| [[Ckurs2009/Palindrome | Palindrome]]
| align="center" |4
| align="center" |3. VL
| Pointer und Strings
| [[Benutzer:Dank|Daniel K.]]
|
|
|- bgcolor="#F5F5F5"
| [[Ckurs2009/(Pointer) Swapping | (Pointer) Swapping]]
| align="center" |5
| align="center" |3. VL
| Pointer und Arrays benutzen, generisches swap
| Katrin
|
|
|- bgcolor="#E8E8E8"
| [[Ckurs2009/Matrizenmultiplikation | Matrizenmultiplikation]]
| align="center" |6
| align="center" |3. VL
| Mehrdimensionale Arrays const correctness
| sping
| [[Benutzer:Mario|Mario]]
| [[Ckurs2009/Matrizenmultiplikation/Musterlösung | Matrizenmultiplikation]]
|- bgcolor="#F5F5F5"
| [[Ckurs2009/Arrayuebergabe | Arrayuebergabe]]
| align="center" |4/5
| align="center" | 4. VL
| Einlesen von Benutzereingaben Pointer und Pointerarithmetik
| nion
| Martin K.
| [[Ckurs2009/Arrayuebergabe/Musterlösung | Arrayuebergabe]]
|- bgcolor="#E8E8E8"
| [[Ckurs2009/Studentendatenbank | Studentendatenbank]]
| align="center" |4
| align="center" | 4. VL
| struct, Pointer, Arrays
| AlexanderK
|
| [[Ckurs2009/Studentendatenbank/Musterlösung | Studentendatenbank]]
|- bgcolor="#F5F5F5"
| [[Ckurs2009/Sammelbestellung | Sammelbestellung]]
| align="center" |2-5
| align="center" |4. VL
| Listen, Pointer, Speicherverwaltung
| Florian S.
| [[Benutzer:Mario|Mario]]
| [[Ckurs2009/Sammelbestellung/Musterlösung | Eine Lösung]]
|- bgcolor="#E8E8E8"
| [[Ckurs2009/Zahlen_sagen | Zahlen sagen]]
| align="center" |5
| align="center" |4. VL
| Umgang mit Zeichenketten
| Martin K.
|
| [[Ckurs2009/Zahlen_sagen/Musterlösung | Zahlen sagen]]
|- bgcolor="#E8E8E8"
| [[Ckurs2009/Compiler, Präprozessor, Header Files | Compiler, Präprozessor, Header Files]]
| align="center" |3
| align="center" |5. VL
| Arbeiten mit mehreren Quellcode-Dateien, Kompilieren und Linken, Header-Dateien und #include, debugging-Makro verwenden
| Katrin
|
| siehe Folien
|- bgcolor="#F5F5F5"
| [[Ckurs2009/Bus Error | Bus Error]]
| align="center" |8
| align="center" |5. VL
| Pointer, wie entsteht ein bus error
| Katrin
|
|
|- bgcolor="#E8E8E8"
| [[Ckurs2009/BubbleSortDebug | BubbleSort Debugging]]
| align="center" | 5
| align="center" | 6. VL
| Debuggen eines Programmes mit gdb
| aeichner
|
| vorhanden
|- bgcolor="#F5F5F5"
| [[Ckurs2009/Debug | Debugging]]
| align="center" | 1-8
| align="center" | 6. VL
| Debuggen einer Anwendung nach Wahl
| aeichner
|
| gibt es nicht
|- bgcolor="#E8E8E8"
| [[Ckurs2009/Code Layout | Code Layout]]
| align="center" |3
| align="center" |7. VL
| Kleinere Codeschipsel mit kleinen Unsauberkeiten
| Daniel
|
|
|- bgcolor="#F5F5F5"
| [[Ckurs2009/Refactoring | Refactoring]]
| align="center" |5-9
| align="center" |7. VL
| Wie verbessere ich den Quellcode eines Programmes.
| Daniel
|
| vorhanden
|- bgcolor="#E8E8E8"
| [[Ckurs2009/Cat | Cat]]
| align="center" | 6
| align="center" | ....
| Arbeiten mit Dateien Kommandozeilenparameter
| nion
| sping
| vorhanden
|- bgcolor="#F5F5F5"
| [[Ckurs2009/Pong | Pong]]
| align="center" | 7
| align="center" | ...
| allgemeiner Programmablauf, fortgeschrittene Konsolenausgaben/eingaben
| AlexanderK
|
| vorhanden
|- bgcolor="#E8E8E8"
| [[Ckurs2009/Buchhaltung | Buchhaltung]]
| align="center" | 6
| align="center" | ....
| Lesen aus Dateien
| reiner
|
|
|- bgcolor="#F5F5F5"
| [[Ckurs2009/StringArraySortieren | StringArraySortieren]]
| align="center" | 7
| align="center" | ...
| Konsolparameter, Funktionspointer, stdlib
| reiner
|
| vorhanden
|- bgcolor="#E8E8E8"
| [[Ckurs/integral | integral]]
| align="center" | 2
| align="center" | ....
| Funktionspointer
| reiner
|
| vorhanden
|- bgcolor="#F5F5F5"
| [[Ckurs/forschleife | forschleife]]
| align="center" | 2
| align="center" | ...
| Bug
| reiner
| nion
| vorhanden
|}

== Kleine und große Probleme ==

* Die Tubit-Accounts haben nicht /bin/bash als shell, so dass die Cursortasten nicht funktionieren. Workaround: als erstes Kommando 'bash' eingeben, man sieht dann auch in welchem Verzeichnis man gerade ist.
* wenn man nur den Promt 'bash-0.12' oder so erhält, also ohne das Verzeichnis in dem man ist, folgendes Kommando eingeben: <tt>export PS1='\u@\h:\w$ '</tt> oder zum dauerhaften Speichern: <tt> echo "export PS1='\u@\h:\w$ '" >> ~/.bashrc </tt>

== Musterlösungen ==
Die Lösungen zu den Aufgaben werden nach den jeweiligen Übungen hier veröffentlicht. Falls dies nicht geschieht, bitte den zuständigen Tutor fragen.

== Links ==

* [[Ckurs2009/Feedback|Feedback zum Kurs 2009]]

[[Kategorie:CKurs]]
[[Kategorie:CKurs Aufgaben]]

C-Kurs/StringArraySortieren/Musterlösung

2009-09-24T08:56:59Z

130.149.17.40: Die Seite wurde neu angelegt: „ #include <string.h> #include <stdlib.h> #include <stdio.h> int cmp_lex(void *a, void *b) { return strcmp(*(char **)a,*(char **)b);} int cmp_std(void *a,...“

#include <string.h>
#include <stdlib.h>
#include <stdio.h>

int cmp_lex(void *a, void *b)
{ return strcmp(*(char **)a,*(char **)b);}

int cmp_std(void *a, void *b)
{int len_diff=strlen(*(char **)a)-strlen(*(char **)b);
if(len_diff) return len_diff;
else
return strcmp(*(char **)a,*(char **)b);}

int main(int argc,char **argv)
{ int i;

if(argc < 2) {
printf("Program sortiert Argumente der Komandozeile\n");
printf("Usage: %s arg1 arg2 ...\n",argv[0]);
return 0;}

qsort(argv+1,argc-1,sizeof(char *),&cmp_lex);

printf("Argumente sortiert nach lex. Ordnung\n");

for(i=1;i<argc;i++) printf("%s\n",argv[i]);
printf("Argumente sortiert nach Standart- Ordnung\n");
qsort(argv+1,argc-1,sizeof(char *),&cmp_std);
for(i=1;i<argc;i++) printf("%s\n",argv[i]);
}

C-Kurs/integral/Musterlösung

2009-09-24T08:48:30Z

130.149.17.40: Die Seite wurde neu angelegt: „ #include <stdio.h> #include <math.h> double hoch2(double x){return x*x;} double integral(double (*fp)(double),double a,double b,double h) { double erg=0...“

#include <stdio.h>
#include <math.h>

double hoch2(double x){return x*x;}
double integral(double (*fp)(double),double a,double b,double h)
{
double erg=0.0;
for(;a<b;a+=h) erg+=(*fp)(a);
return erg*h;

}

int main(){

printf("%lf \n",integral(&hoch2,0.0,3.0,0.005));
}

Eclipsekurs 2008/Tag 2

2008-11-15T13:08:12Z

130.149.17.40: /* Subversion Repository */

== Aufgabe: Grundlagen ==
* Falls du noch etwas Übung in Java brauchst, dann besuche den [[Javakurs2008/Übungspool | Übungspool des Javakurses 2008]] und mache einfach von dort noch einige Aufgaben.
* Die folgenden Aufgaben beschäftigen sich weniger mit der Programmierung von Java. Viel mehr stehen die Features von Eclipse im Vordergrund.

==Aufgabe: Importieren und Exportieren ==
* Lade dir Marios [http://docs.freitagsrunde.org/Veranstaltungen/eclipsekurs_2008/tutorial/Visualizer.jar Framework für Formen] herunter
* Informiere dich über den Allgemeinen [[Eclipsekurs_2008/Tag2/VisualizerFramework | Aufbau des Frameworks]]
* Erstelle ein neues Projekt
* Lade das JAR in das Projekt (BuildPath -> Add Jars)
* Schreibe eine '''main''' Methode, die den Visualizer erstellt ('''addVisualElement()''') und anzeigt ('''visualize()''')
* Wie wäre es, wenn du nach dem [[WhishfullThinking | WhishfullThinking-Prinzip]] versuchst weitere VisualElements zu schreiben? Beispielsweise ein Rechteck oder ein Dreieck? Oder gar eine bunte Form?
** Gibt es eine Möglichkeit, diese mit anderen Studierenden auszutauschen?
** Wenn ja, dann tue dies doch einfach ...

== Subversion Repository ==

''' Folgende Aufgabe kann leider nur von Benutzern mit einem CS-Account bearbeitet werden! '''

Wir haben für dich und die anderen Teilnehmer ein Subversion-Repository im CS-Netz angelegt, das ihr für die folgenden Aufgaben nutzen könnt.

* Check dir ein eigenes Verzeichnis davon aus und füge deine Lösungen hinzu.
* Stell sicher, dass dein eclipse mit dem [http://subclipse.tigris.org/ Subclipse-Plugin] versehen ist. Wenn du eclipse im cs-Netz nutzt, fügst du einfach die "Repository Location" wie auf dem Beipackzettel beschrieben hinzu. Falls nicht, füge es über "Help->Software Updates" hinzu.
* Erstelle ein neues Java-SVN-Projekt. (RMB auf PackageExplorer -> new Project -> SVN)
svn+ssh://cs.tu-berlin.de/home/theclaw/eclipse2008/svn/[NUMMER]
* Gebe als Repository Location den obigen Text ein
* Lass dir von einem Tutor eine Nummer zwischen 0 und 9 geben
* Trage diese als [NUMMER] ein.
* gebe deinen CS Benutzernamen und dein CS Passwort ein
* klicke danach auf '''Next''' - noch nicht auf '''Finish''':
* Folge den weiteren Schritten des Dialoges, und bearbeite die Aufgabe, die im SVN als README.txt gestellt wurde
* Schau dir auch die CommitKommentare (LogMessages) an, evtl.findest du weitere Aufgaben ....

==Aufgabe: Refactoring ==

Herzlichen Glückwunsch, du wurdest bei der "Luft- und Bodenverkehr AG" eingestellt! Deine erste Aufgabe als neuer Entwickler der firmeneigenen Software ist es, diese in einen wartbaren und besser verständlichen Zustand zu bringen. Dein Vorgänger, ein Java-Crack, der auf den Programmier-Editor HackPad schwört, musste aufgrund geringer Produktivität leider von dieser Aufgabe abgezogen werden. Nun darfst du dich mit Eclipse daran versuchen!

* Importiere die folgende Zip-Datei in ein leeres Projekt [http://docs.freitagsrunde.org/Veranstaltungen/eclipsekurs_2007/Verkehr.zip Verkehr.zip].
* Zu deinem Schrecken findest du ein Chaos vor. Bringe zuerst die Klassen in eine sinnvolle Ordnung, indem du sie per Drag-and-Drop in die richtigen Java-Packages einordnest.
* Dir wird aufgefallen sein, dass einige Klassen sehr seltsame und/oder falsch geschriebene Namen haben. Gib diesen Klassen bessere Namen. Benutze dafür die Refactoring-Funktion ''Rename''.
* Beim Durchsehen der Klassen ist dir bestimmt folgendes aufgefallen:
** Die Klassen mit den (ehemaligen) Namen ''Farrad'' und ''MeinAuto'' enthalten beide Code, der die Anzahl der Räder zurückgibt. Benutze die Refactoring-Funktion ''Pull Up'', so dass in einem Schritt der identische Code von ''anzahl()'' aus beiden Klassen entfernt und in die gemeinsame Superklasse verschoben wird. Führt Eclipse diese Aktion aus, ohne sich zu beschweren? Falls nicht, nicht nutze das von Eclipse erzeugte Preview um das Problem zu erkennen. Dann gehe zurück im Refactoring-Dialog und versuche das Problem zu beseitigen.
*** ''Tipp:'' Es hat mit dem Attribut "anzahlRaeder" zu tun!
** Alle Klassen, die ein Verkehrsmittel modellieren (Auto, Fahrrad, Flugzeug, ...), haben Funktionen um die Farbe zurückzuliefern. Verschiebe diese zusammen mit dem Attribut "farbe" in die gemeinsame Superklasse.
** In der (ehemaligen) Klasse ''MeinAuto'' kommt Code mehrfach vor. Benutze die Refactoring-Funktion ''Extract Method'' um dieses Problem zu beseitigen.
** Während du den soeben extrahierten Code durchliest, fällt dir auf, dass er viel verständlicher wäre, wenn die Variablen sprechende Namen hätten. Nutze erneut die Refactoring-Funktion ''Rename'' um dies zu erreichen.

==Aufgabe: Standardnormalverteilung (einfach)==
* Lade die Datei [http://docs.freitagsrunde.org/Veranstaltungen/eclipsekurs_2006/StandardNormalVerteilung.java StandardNormalVerteilung.java] herunter und importiere sie in das Projekt "Einstein".
* Setze einen Breakpoint in der main-Methode (siehe TODO) und starte das Programm im Debug-Modus.
* Benutze die '''Step into/Step over/Run to return/Resume''' Buttons im Debugger, um Folgendes herauszufinden:
** Im ersten Aufruf von ''normalVerteilung()'':
*** Welcher Wert wird ''xi'' im 2. Durchlauf der 1. Schleife zugewiesen?
*** Welcher Wert wird ''summe'' im 2. Durchlauf der 2. Schleife zugewiesen?
*** ''Tipp:'' Um letzteres herauszufinden kannst du ''zur Laufzeit des Programms'' noch einen Breakpoint einfügen!
** Im zweiten Aufruf von ''normalVerteilung()'':
*** Welchen Wert hat ''summe'' am Ende des Methodenaufrufs? Ermittle dies '''innerhalb''' des Aufrufs von ''normalVerteilung()''!
*** ''Tipp:'' Auch hier kannst du zur Laufzeit wieder Breakpoints einfügen und entfernen!
** Lass das Programm bis zum Ende laufen (es erscheint eine Ausgabe auf der Konsole).

==Aufgabe: Micki Maus im Labyrinth (etwas schwerer)==

* Bei dieser Aufgabe geht es auch darum, den Eclipse Debugger ein wenig kennenzulernen.
* Lade dir die Aufgabe unter [http://docs.freitagsrunde.org/eclipsekurs2008/MickiMaus.jar MickiMaus.jar] herunter und importiere diese wie in Aufgabe 1.

Micki die Maus, befindet sich in einem Labyrinth und muss den Käse finden. Du sollst nun
ihren Weg mit Hilfe des Debuggers verfolgen. Setze dazu einen Breakpoint auf den Methodenaufruf von '''Mouse.dfs()''',
also in Zeile 30 und in Zeile 40 am '''return'''. Starte den Debugger, indem du auf das Käfer-Symbol
klickst. Um zu sehen, welchen Weg Micki wählt, schau dir in der '''Variables View''' die Variable '''this.currentNode an'''. Micki sollte auf den Koordinaten (1,1) stehen. Nun könnt ihr mit der Funktion '''Resume''' einen Schritt weitergehen. (Es ist normal, dass sich Micki beim ersten Schritt nicht bewegt :-). Probiert auch mal die anderen Debugger-Funktionen '''Step into''', '''Step over''' und '''Step return''' aus. Am Ende sollte Micki den Käse gefunden haben.

Das Labyrinth sieht folgendermaßen aus:

01234567
0 ########
1 #M# ##
2 # #K# #
3 # #### #
4 # #### #
5 # X #
6 #### ###
7 ########

Die Stelle '''X''' ist beipielsweise mit den Koordinaten (4,5) beschrieben. Micki befindet sich anfangs bei (1,1) also '''M''' und der Käse ist mit einem '''K''' markiert also (3,2).

=== Wer macht was ===
Zur Erinnerung: Der Debugger bietet dir mehrere Möglichkeiten, dein Programm fortzusetzen:
* Terminate: Beendet das Programm sofort
* Step Into: Überspringt die Methode nicht (F5)
* Step Over: Überspringt die Beobachtung einer Methode (F6)
* Step Return: Führt die Methode bis zum Ende aus (F7)
* Resume: Setzt das Programm bis zum nächsten Haltepunkt fort (F8)

= Zusatzaufgaben =

== Refactoring II ==
Verwende für diese Aufgabe das Projekt '''Verkehr''' von der ersten Refactoring Aufgabe. Im Folgenden sind ein paar Vorschläge von Refactoring Aktionen, die du noch durchführen kannst:
* In der (ehemaligen) Klasse ''MyHupschrauber'':
** Benenne die Instanzvariable ''x'', ''y'', ''z'' und ''blabla'' um, so dass sie aussagekräftige Namen haben. Ihre Bedeutung erfährst du aus den JavaDoc-Kommentaren
** Kapsle die (ehemaligen) Instanzariablen ''x'', ''y'', ''z'' und ''blabla'' (immer nur eine auf einmal). Was bewirkt dies? Dazu schaue dir in der Vorschau den Unterschied an. Warum könnte das sinnvoll sein?
** Wende die Refactoring-Funktion ''Extract Interface'' auf ''MyHupschrauber'' an. Was bewirkt sie und was bewirken die einzelnen Einstellungen?
* In der (ehemaligen) Klasse ''MyFlugzeug'': Lies dir kurz den Code der Klasse durch (man beachte die Warnungen). Benutze die Refactoring-Funktion ''Infer Generic Type Arguments'' und schau was passiert.

== Debugging II ==
* Lade dir die Datei [http://docs.freitagsrunde.org/Veranstaltungen/eclipsekurs_2006/Calc.java Calc.java] runter. Erstelle ein Java-Projekt ''Einstein'' und importiere die Datei in das Projekt und führe es aus.
* Im Quellcode wurden zwei Stellen markiert, an denen du den aktuellen Wert einer Variable auslesen sollst. Dies lässt sich sehr einfach mit Hilfe von Breakpoints lösen.

* Setze eine Watch Expression auf die Variable ''b'' und beobachte wie sie sich im Laufe des Programms verändert.

* Exportiere das Programm als JAR-Datei. Damit die Datei später über die Konsole ausgeführt werden kann, gehst du wie folgt vor:
** Der komplette Projektordner muss exportiert werden
** Wähle einen Namen für die Datei und einen Ordner als Exportziel.
** Klicke zweimal auf '''Next''' und wähle die Hauptklasse des Projekts aus.
** Um zu testen, ob du Alles richtig gemacht hast, öffne eine Konsole, wechsle in den Ordner, in dem die JAR-Datei liegt und führe den Befehl ''java -jar filename.jar'' aus. (filename.jar ist der Name der JAR ...)

==Aufgabe: Eclipse Plug-Ins==

* Informiere dich über die Massen an PlugIns, die es für eclipse gibt über [http://www.eclipseplugincentral.com/ Eclipse Plugin Central].
* Findest du ein Plugin, mit dem du Sokoban in Eclipse Spielen kannst?

== Eigenes Subversion-Repository im Fakultätsnetz ==

Richte in deinem eigenen Verzeichnis im CS-Netz ein SVN-Repository ein und lade deine Gruppenmitglieder aus MPGI3 oder MPGI4 in eine eigene Gruppe ein. Setze für diese Gruppe die entsprechenden Rechte im Respository. Checke dieses Verzeichnis mit Subclipse aus und lade eure fertigen und angefangenen Hausaufgaben darin hoch.

Hinweise zur Einrichtung findet ihr im Artikel [[Subversion im CS-Netz]].

----

[[Eclipsekurs 2008|Zurück zu Eclipsekurs 2008]]

PS: Wenn du Fehler in den Aufgaben findest, benutze den "Bearbeiten"-Link oben auf der Seite. Oder spreche einfach mit einem der Tutoren ...

Informatik-Rechnerbetrieb

2008-04-22T12:01:16Z

130.149.17.40: Rechtschreibfehlerchen

Der Informatik-Rechnerbetrieb (IRB) hält das [[UNIX]]- und PC-Rechnernetz am laufen. Im IRB-Sekretariat [[FR]] 5091 erhaltet Ihr Euren [[UNIX-Account]], der für das weitere Studium sehr wichtig ist.

== Häufig gestellte Fragen ==

* Wie komme ich von Zuhause auf die IRB-Server/in das IRB-Netz?
** Mittels [[SSH]].
** Mit dem [[IRB VPN]].
* Wie kann ich meinen IRB-Email-Account von zu Hause aus benutzen?
** Siehe [[Email]].
* Wo ist finde ich meinen USB-Stick nach dem einstoepseln?
** USB Geraete erscheinen in dem Verzeichnis /tmp/SUNWut/mnt/$USER/ und koennen mit dem utdiskadm Befehl verwaltet werden.
* Wie kann ich KDE Programme (z.B. Kate) aus der Shell starten?
** Dazu muss der Shell verraten werden, wo KDE zu finden ist:
echo "kde::sol10::/opt/csw/kde-gcc/bin:/opt/csw/kde-gcc/man:: KDE" >> ~/.applications
echo kde >> ~/.applrc

== Weblinks ==
[http://irb.cs.tu-berlin.de/ Offizielle Website des IRB]

[[Kategorie: Fakultäts-ABC]]
[[Kategorie: Überleben im Fakultätsnetz]]

Informatik-Rechnerbetrieb

2008-04-22T11:44:21Z

130.149.17.40: Hinweis zum Starten von KDE Programmen aus der Shell

Der Informatik-Rechnerbetrieb (IRB) hält das [[UNIX]]- und PC-Rechnernetz am laufen. Im IRB-Sekretariat [[FR]] 5091 erhaltet Ihr Euren [[UNIX-Account]], der für das weitere Studium sehr wichtig ist.

== Häufig gestellte Fragen ==

* Wie komme ich von Zuhause auf die IRB-Server/in das IRB-Netz?
** Mittels [[SSH]].
** Mit dem [[IRB VPN]].
* Wie kann ich meinen IRB-Email-Account von zu Hause aus benutzen?
** Siehe [[Email]].
* Wo ist finde ich meinen USB-Stick nach dem einstoepseln?
** USB Geraete erscheinen in dem Verzeichnis /tmp/SUNWut/mnt/$USER/ und koennen mit dem utdiskadm Befehl verwaltet werden.
* Wie kann ich KDE Programme (z.B. Kate) aus der Shell starten?
** Dazu muss der Shell veraten werden, wo KDE zu finden ist:
echo "kde::sol10::/opt/csw/kde-gcc/bin:/opt/csw/kde-gcc/man:: KDE" >> ~/.applications
echo kde >> ~/.applrc
== Weblinks ==
[http://irb.cs.tu-berlin.de/ Offizielle Website des IRB]

[[Kategorie: Fakultäts-ABC]]
[[Kategorie: Überleben im Fakultätsnetz]]

Informatik-Rechnerbetrieb

2008-04-22T11:33:21Z

130.149.17.40: Hinweis wohin USB Geraete gemountet werden

Der Informatik-Rechnerbetrieb (IRB) hält das [[UNIX]]- und PC-Rechnernetz am laufen. Im IRB-Sekretariat [[FR]] 5091 erhaltet Ihr Euren [[UNIX-Account]], der für das weitere Studium sehr wichtig ist.

== Häufig gestellte Fragen ==

* Wie komme ich von Zuhause auf die IRB-Server/in das IRB-Netz?
** Mittels [[SSH]].
** Mit dem [[IRB VPN]].
* Wie kann ich meinen IRB-Email-Account von zu Hause aus benutzen?
** Siehe [[Email]].
* Wo ist finde ich meinen USB-Stick nach dem einstoepseln?
** USB Geraete erscheinen in dem Verzeichnis /tmp/SUNWut/mnt/$USER/ und koennen mit dem utdiskadm Befehl verwaltet werden.
== Weblinks ==
[http://irb.cs.tu-berlin.de/ Offizielle Website des IRB]

[[Kategorie: Fakultäts-ABC]]
[[Kategorie: Überleben im Fakultätsnetz]]

Javakurs/Übungsaufgaben/Democracy

2008-04-10T10:37:18Z

130.149.17.40: /* Fehler im System */

=== Fehler im System ===

Führende PolitikwissenschaftlerInnen haben festgestellt, dass Demokratie einfach nicht funktioniert. Deshalb haben sie sich überlegt, dass es klüger wäre, wenn einfach der/die Älteste entscheidet. Sie haben ein Programm geschrieben, das unter den Parteivorsitzenden der großen Parteien, den/die älteste heraussucht. Leider sind sie keine gelernten Java-Programmierer und haben es nicht geschafft, lauffähigen Code zu produzieren. Findest du die Fehler im System?

<nowiki>
public class DemocracyV2 {
public static void main(String[] args) {
String[] names = String[5];
int[] ages = int[5];

generateNamesAndAges(names, ages);
System.out.println(whosTheOldest(names, ages));
}

private static void generateNamesAndAges(String[] names, int[] ages) {
names[0] = Angela;
ages[0] = 52;

names[1] = Kurt;
ages[1] = 58;

names[2] = Lothar;
ages[2] = 66;

names[3] = Doppelspitze Claudia und Reinhard;
ages[3] = 51 + 54;

names[4] = Guido;
ages[4] = 45;
}

private static void whosTheOldest(String[] names, int[] ages) {
int oldest;
for(int i; i <= 5; i++) {
if ( oldest < ages[i] ) {
int indexOfOldest = i;
}
}

return "Oldest and wisest person is " + names[indexOfOldest] + " with an age of " + ages[indexOfOldest] + ".";
}
}
</nowiki>

Nachdem du die Fehler gefunden hast, wie könntest du sie beseitigen und so die Gesellschaft vor ihrem Untergang bewahren?
Wie könnte mit dem Fall umgegangen werden, dass zwei PolitikerInnen gleich alt sind?

== Kommentare ==
Wenn du Anmerkungen zur Aufgabe hast oder Lob und Kritik loswerden möchtest, ist hier die richtige Stelle dafür. Klicke einfach ganz rechts auf "bearbeiten" und schreibe deinen Kommentar direkt ins Wiki. Keine Scheu, es geht nichts kaputt ;)

Javakurs/Übungsaufgaben/Methoden

2008-04-08T12:55:04Z

130.149.17.40: /* Argumente */

'''Hinweis:''' Alle in diese Übung verwendeten Klassen findest du auch als Vorgabedateien unter http://docs.freitagsrunde.org/Veranstaltungen/javakurs_2007/vorgaben/Methoden.tar

== Argumente ==
* Überlege dir, was der folgende Code macht. Was erwartest du als Ausgabe?
* Führe den Code aus und vergleiche das Ergebnis mit deinen Erwartungen.

<nowiki>
class Beispiel {
public static void main ( String [] arguments ) {
ausgabe( 1, "Martin" );
ausgabe( 2, "Arthur" );
ausgabe( 3, "Florian" );
ausgabe( 4, "Robert" );
}

static void ausgabe ( int zahl, String name ) {
System.out.println( zahl + ": " + name );
}
}
</nowiki>

== Rückgabewert ==
* Überlege dir, was der folgende Code in den folgenden Beispielen macht. Was erwartest du als Ausgabe?
* Führe den Code jeweils aus und vergleiche das Ergebnis mit deinen Erwartungen.

<nowiki>
//file: Methoden1.java
class Methoden1 {
public static void main ( String[] arguments ) {
System.out.println( gibMirNeZahl() );
}

public static double gibMirNeZahl() {
return 15.3;
}
}
</nowiki>

<nowiki>
//file: Methoden2.java
class Methoden2 {
public static void main ( String[] arguments ) {
System.out.println( mathematik( 1, 2 ) );
}

public static boolean mathematik ( int argument1, int argument2 ) {
return ( argument1 + 5 ) < ( argument2 * 2 );
}
}
</nowiki>

<nowiki>
//file: Methoden3.java
class Methoden3 {
public static void main ( String[] arguments ) {
System.out.println ( mathematik( 1, 2 ) );
System.out.println ( mathematik( 1, 5 ) );
System.out.println ( mathematik( 3, 4 ) );
}

public static boolean mathematik ( int argument1, int argument2 ) {
return ( argument1 + 5 ) < ( argument2 * 2 );
}
}
</nowiki>

<nowiki>
//file: Methoden4.java
class Methoden4 {
public static void main ( String[] arguments ) {
int eineZahl = 2;
System.out.println ( mathematik( 4, eineZahl ) );
eineZahl = 5;
System.out.println ( mathematik( 2, eineZahl ) );
System.out.println ( mathematik( eineZahl, 4 ) );
}

public static boolean mathematik(int argument1, int argument2) {
return (argument1 + 5) < (argument2 * 2);
}
}
</nowiki>

== Kommentare ==
Wenn du Anmerkungen zur Aufgabe hast oder Lob und Kritik loswerden möchtest, ist hier die richtige Stelle dafür. Klicke einfach ganz rechts auf "bearbeiten" und schreibe deinen Kommentar direkt ins Wiki. Keine Scheu, es geht nichts kaputt ;)



====Ran====
das:
//file: Methoden2.java
class Methoden3

soll so:
//file: Methoden2.java
class Methoden2 {
sein...

====Robert====
Danke, ist geändert. -- [[Benutzer:Buchholz|Robert Buchholz]] 11:20, 11. Apr. 2007 (CEST)

====Mario====
Jetzt auch den Fehler im Archiv verändert ... -- [[Benutzer:Mario|Mario Bodemann]] 11:26, 08. Apr. 2008 (CEST)

====Fehler?====
<strike>Beispiel.java werden die Methoden mit falscher Reihenfolge der Parameter aufgerufen:

ausgabe("Arthur", 2); -> fehler

ausgabe("Robert", 4); -> fehler</strike>

fixed, siehe oben -- Mario

Javakurs/Übungsaufgaben/Variablen und Zuweisungen

2008-04-07T10:18:29Z

130.149.17.40: /* Kommentare */

'''Hinweis:''' Alle in diese Übung verwendeten Klassen findest du auch als Vorgabedateien unter [http://docs.freitagsrunde.org/Veranstaltungen/javakurs_2007/vorgaben/VariablenUndZuweisungen.tar http://docs.freitagsrunde.org/Veranstaltungen/javakurs_2007/vorgaben/VariablenUndZuweisungen.tar]

(Die Datei wird mit dem Kommando tar -xf entpackt)

== Deklaration und Initialisierung ==

* An welcher Stelle im folgenden Programm wird die Variable ''aWholeNumber'' deklariert?
* An welcher Stelle im folgenden Programm wird die Variable ''aWholeNumber'' initialisiert?
* Beantworte diese Fragen auch für die Variablen: ''notAWholeNumber'', ''aString'', ''anotherWholeNumber'', ''anotherNotSoWholeNumber'', ''anotherString''

* Erkläre deine Meinung einem Tutor oder diskutiere sie mit der Person am Rechner nebenan.

<nowiki>
class DeklarationUndInitialisierung {
public static void main(String [] ignored) {
int aWholeNumber;
double notAWholeNumber;
String aString;

aWholeNumber = 0;
notAWholeNumber = 0.0;
aString = "";
System.out.println(aWholeNumber);
System.out.println(notAWholeNumber);
System.out.println(aString);

int anotherWholeNumber = 0;
double anotherNotSoWholeNumber = 0;
String anotherString = "";
System.out.println(anotherWholeNumber);
System.out.println(anotherNotSoWholeNumber);
System.out.println(anotherString);
}
}
</nowiki>

== Selber Deklarationen und Definitionen durchführen ==

* Realisiere die Kommentare im folgenden Codestück.
* Teste deinen Code.

<nowiki>
class SelbstDeklarierenUndDefinieren {
public static void main(String [] ignored) {
// deklariere eine Variable "birnen" vom Typ int

// weise ihr den Wert drei zu

// System.out.println("3 erwartet: " + birnen);
// addiere fuenf zu dem Wert

// System.out.println("8 erwartet: " + birnen);
// deklariere eine Variable "aepfel" und weise ihr den Wert fuenf zu

// System.out.println("5 erwartet: " + aepfel);
// subtrahiere zwei von dem Wert

// System.out.println("3 erwartet: " + aepfel);

}
}
</nowiki>

== Zuweisung an Variablen ==

* Überlege dir, was für eine Ausgabe der folgende Code erzeugen würde.
* Compiliere den Code, führe ihn aus und vergleiche das Resultat mit deinen Erwartungen.
* Was sind die Unterschiede?
* Diskutiere die Unterschiede mit der Person am Rechner nebenan, oder einem Tutor.

<nowiki>
class ZuweisungenAnVariablen {
public static void main(String [] ignored) {
System.out.println(0);
int zero = 0;
System.out.println(zero);
int one = 1;
int whatsThis = zero;
System.out.println(whatsThis);
whatsThis = one;
System.out.println(whatsThis);
}
}
</nowiki>

== Variablen ändern ihre Werte ==

* Überlege dir, was für eine Ausgabe der folgende Code erzeugen würde.
* Compiliere den Code, führe ihn aus und vergleiche das Resultat mit deinen Erwartungen.
* Was sind die Unterschiede?
* Diskutiere die Unterschiede mit der Person am Rechner nebenan, oder einem Tutor.

<nowiki>
class VariablenAendernIhreWerte {
public static void main(String [] ignored) {
int number = 1;
System.out.println(number);
number = 1;
System.out.println(number);
number = 2;
System.out.println(number);
number = 3;
System.out.println(number);
number = 1;
System.out.println(number);
number = 17;
System.out.println(number);
}
}
</nowiki>

== Formatierung und Namen ==

* Wieso haben wir die Code-Beispiele nach den geschweiften Klammern eingerückt und die Variablen so benannt, wie wir es taten und nicht so:

<nowiki>
class _{static long _
(long __,long ___) {
return __==0 ?___+ 1:
___==0?_(__-1,1):_(__
-1,_(__, ___-1)) ; }
static {int _=2 ,___
= 2;System.out.print(
"a("+_+’,’+___+ ")="+
_ (_, ___) ) ;System
.exit(1);}}//(C) Ulli
</nowiki>

* Etwas weniger Extrem: Was ist im folgenden Beispiel bei der Formatierung schief gelaufen?

<nowiki>
class Formatierung1 {public static void main
(String [] ignored) {
System.out.println(0); int zero = 0;
System.out.println(zero);
int one = 1;
int whatsThis = zero;
System.out.
println(whatsThis);
whatsThis = one; System.out.println(whatsThis)
;}}
</nowiki>

* Warum ist der folgende Code so schlecht lesbar?
* Woran erinnert er dich?

<nowiki>
class b {
public static void main(String [] i) {
System.out.println(0);
int a = 0;
System.out.println(a);
int b = 1;
int c = a;
System.out.println(c);
c = b;
System.out.println(c);
}
}
</nowiki>

== Kommentare ==
Wenn du Anmerkungen zur Aufgabe hast oder Lob und Kritik loswerden möchtest, ist hier die richtige Stelle dafür. Klicke einfach ganz rechts auf "bearbeiten" und schreibe deinen Kommentar direkt ins Wiki. Keine Scheu, es geht nichts kaputt ;)


hallo alle freitagsrunde Team,

diese lehrveranstaltung finde ich persönlich super megageil, aber ich wünsche,dass die Musterlösungen von solchen schweren Aufgaben im Netz gestellt werden.

ich wünsche Euch viel Erfolg und weiterso...:-)


Bisher laeuft alles ganz klasse, weiter so!

Die erste Aufgabe "SelbstDeklarieren und Definieren" ist etwas unverständlich. Das mit den eingebauten "Testfunktionen" kapiert man als Anfänger nicht unbedingt, also dass man da zum testen die Kommentarzeichen löschen muss.

Javakurs/Übungsaufgaben/Kassenbon

2008-04-07T09:19:29Z

130.149.17.40: /* Kommentare */

== Kassenbon ==
Es soll ein Programm geschrieben werden, dass einen Kassenbon auf der Konsole anzeigt (mit ''System.out.println'').
Am Anfang des Programmes werden in Form von Variablen folgende Werte festgelegt:

* Anzahl von mindestens vier verschiedenen Waren, die gekauft werden sollen.
* Einzelpreise der Waren. (Ja, jede Warensorte hat einen anderen Preis)
* Inhalt der Brieftasche.

Das Programm soll den Gesamtpreis der eingangs festgelegten Waren ermitteln. Übersteigt der
Gesamtpreis den Inhalt der Brieftasche, wird der Benutzer auf den fehlenden Betrag hingewiesen.
Reicht der Inhalt der Brieftasche für den Einkauf aus, wird ein Kassenbon ausgegeben, der
die gekauften Waren mit Anzahl und Preis sowie am Ende den Gesamtpreis auflistet.

'''Hinweis:''' Erstellt zuerst die Ausgabe des Kassenbons und füllt sie anschließend mit Berechnungen und der Fallunterscheidung.

== Kassenbon + automatischer Einkauf ==
Erstellt eine Kopie eures soeben geschriebenden Programmes.
Verändert das Programm so, dass nun der Kassenbon solange mit Waren gefüllt wird, bis der
Inhalt der Brieftasche für keine weiteren Einkäufe ausreicht. Betrachtet der Einfachheit halber
mehrere Produkte eines Typs als einen Einkauf.

'''Hinweis:''' Viele, viele Fallunterscheidungen!

== Kommentare ==
Wenn du Anmerkungen zur Aufgabe hast oder Lob und Kritik loswerden möchtest ist hier die richtige Stelle dafür. Klicke einfach ganz rechts auf "bearbeiten" und schreibe deinen Kommentar direkt ins Wiki. Keine Scheu, es geht nichts kaputt ;) /// RETTET DIE WALE !!! ///



==== Unknown User ====
hallo alle freitagsrunde Team,

diese lehrveranstaltung finde ich persönlich super megageil, aber ich wünsche,dass die Musterlösungen von solchen schweren Aufgaben im Netz gestellt werden.

ich wünsche Euch viel Erfolg und weiterso...:-)

==== Robert ====

Der Eine oder Andere hat darauf bestanden auf seinem Kassenbon keine Hundertstelcent ausgeben zu wollen. Diese entstehen mitunter dadurch, dass Doublewerte mit einer gewissen Toleranz gespeichert werden.
Hier ein Vorschlag für einen Workaround:

double kommazahl = 123.290402;

int ganzzahl = (int)kommazahl; // Nachkommastelle abschneiden
int kommastelle = (int)(kommazahl * 100)%10 ; // zwei Nachkommastellen extrahieren

System.out.println("Preis=" + ganzzahl + "." + kommastelle ); // Zahl in der Ausgabe zusammensetzen

==== Ich ====
Wie ist das gemeint, mit Kassenbon automatisch füllen?
Man kann doch nicht "zufällig" einkaufen...
: Die Idee der Aufgabe war es, so lange dasselbe Produkt zu kaufen, wie du kannst. Aber (da am Anfang des Kurses) nicht mit einer Schleife, sondern mit mehreren if's. -- [[Benutzer:Buchholz|Robert Buchholz]] 02:13, 4. Jun. 2007 (CEST)

Javakurs/Übungsaufgaben/Studentendatenbank

2007-04-13T12:54:56Z

130.149.17.40:

Im Rahmen dieser Aufgabe wollen wir eine kleine "Studentendatenbank" erstellen.

'''1.1.''' Schreibe eine Klasse ''Student'', die Informationen wie Name, Matrikelnummer etc. über einen Studenten speichert. Erzeuge ein Objekt dieser Klasse und belege die Objektvariablen mit Werten. Lies diese Werte aus den Objektvariablen wieder aus und gib sie auf dem Bildschirm aus.

'''1.2.''' Schreibe einen Konstruktor für deine Klasse, der die Objektvariablen des erzeugten Objekts mit Werten füllt. Erzeuge mit Hilfe dieses Konstruktors ein Objekt, lies seine Werte aus und gib sie auf dem Bildschirm aus.

'''1.3.''' Erweitere deine Klasse um eine Methode ''printMe()'', die die Daten des Studentenobjekts auf dem Bildschirm ausgibt. Teste deine Methode!

'''1.4.''' Lege ein Feld (Array) mit 100 Studentenobjekten an, die verschiedene Matrikelnummern haben und gib alle auf dem Bildschirm aus.

'''1.5.''' Das in der vorherigen Aufgabe angelegte Feld ist schon eine Art Studentendatenbank. Schreibe daher eine neue Klasse ''StudentDatabase'', die ein Feld von Studentenobjekten enthält. Die Klasse soll einen Konstruktor haben, dem die Größe des zu erzeugenden Feldes übergeben wird. Implementiere auch eine Methode ''printMe()'', die alle Datensätze ausgeben soll, sowie eine Methode ''addStudent()'', die ein Studentenobjekt mit den zu übergebenen Daten anlegen soll und dieses in die Datenbank einfügen soll.

'''1.6. Zusatzaufgabe:''' Erweitere die Studentendatenbank um eine Methode ''deleteStudent()'', die das Studentenobjekt mit der übergebenen Matrikelnummer aus der Datenbank löschen soll. Funktionert nach dem Löschen einiger Objekte deine Ausgabemethode printMe() noch?

'''1.7. Zusatzaufgabe:''' Erweitere die Studentendatenbank um eine Methode ''numberOfStudents()'', die die Anzahl der in der Datenbank gespeicherten Studentenobjekte zurückliefert.

'''1.8. Zusatzaufgabe:''' Schreibe Methoden, die statistische Daten über die Studenten ermitteln. Beispiele sind: die Durchschnittsnote, das Durchschnittsalter . . .

== Kommentare ==
Wenn du Anmerkungen zur Aufgabe hast oder Lob und Kritik loswerden möchtest, ist hier die richtige Stelle dafür. Klicke einfach ganz rechts auf "bearbeiten" und schreibe deinen Kommentar direkt ins Wiki. Keine Scheu, es geht nichts kaputt ;)

Informatik 4 (StuPO90)/Stichpunkte zur Klausur SoSe 2006

2006-07-21T10:12:46Z

130.149.17.40: /* Aufgabe 1: Allgemeine Fragen */ fernaufrufpunkt erklärt

== Allgemeines ==
Diese Seite sammelt die Information vom "Pre-Release" der aktuellen [[Informatik 4|Info4]]-Klausur.
* Die Aufgaben sind vermutlich nicht ganz die gleichen, die in der Klausur vorkommen. Aber hoffentlich ähnlich. Insgesamt sind 50 Punkte zu erreichen.

== Aufgabe 1: Allgemeine Fragen ==
''5 Punkte.''
# Unterschied zwischen 2 gegebenen Assemblerbefehlen erklären
# Welche Methoden der Javaklasse ... werden für die Realisierung des Methodenfernaufrufs benötigt.
# Bestimmtes Verhalten bei Monitoren
# Verbindungsanfrage eines Clients an einem Server ausprogrammieren in Java
# Spezielles Verhalten zu Semaphoren

== Aufgabe 2: Assembler ==
''9 Punkte.''
# Textaufgabe, Algorithmus realisieren
# Kellerspeicher aufzeichnen

== Aufgabe 3: Semaphore ==
''11 Punkte.'' 
# 2 Prozesse, die sich nach vorgegebenen Regeln verhalten programmieren
# ein weiterer Prozess kommt hinzu - ausprogrammieren

== Aufgabe 4: Monitore ==
''12 Punkte.'' 
Gegeben ist die Beschreibung eines Synchronisierungsproblems.
3 Threads schreiben, in Java ausprogrammieren

== Aufgabe 5: Nachrichtenaustausch ==
''12 Punkte.'' 
Sockets benutzen, Java programmieren, Nachrichtenaustausch

== Aufgabe 6: Speicherverwaltung ==
''4 Punkte.'' 
# Strategien bei seitenverwalteten Systemen
# Konkrete Speicherverwaltung
# Anfragen in der Speicherverwaltung behandeln

Javakurs/Übungsaufgaben/Rennschnecke

2006-05-06T11:43:49Z

130.149.17.40: /* Rennschnecke */

[[Javakurs2006| <- Zurück zur Übersicht]]

== Rennschnecke ==
#Erstelle eine Klasse "Rennschnecke"
#:
#Rennschnecken sollen folgende Eigenschaften(Objektvariablen) besitzen:
#* einen Namen
#* eine Rasse
#* eine Maximalgeschwindigkeit
#* die Schnecke soll wissen welchen Weg sie bereits zurück gelegt hat
#:
# Erstelle für die Klasse Rennschnecke einen [[Javakurs2006/Java_Kurzreferenz#Konstruktor|Konstruktor]], der den Instanzvariablen beim Erstellen einer neuen Instanz(Objekt zu dieser Klasse) Werte zuweist.
#:
#Lege in der Klasse "Rennschnecke" eine Methode "krieche()" an, welche die Schnecke abhängig von ihrer Maximalgeschwindigkeit eine zufällige Strecke weiter bewegt.
#* Tipp: Schaut euch die Methode Math.random() aus der Java API an.
#:
#Lege in der Klasse "Rennschnecke" eine Methode "public String toString()" an, welche die Daten der Schnecke mit return als String zurückgibt.
#:
# Teste deine Klasse, indem du probehalber ein Rennschneckenobjekt erzeugst und seine Daten auf der Konsole ausgibst.
#*Tipp:Verwende zum Ausgeben der Daten die toString() Methode der Rennschnecke.
#:
#:

== Rennen ==

#Erstelle eine Klasse "Rennen"
#:
#Ein Rennen hat folgende Eigenschaften:
#*einen Namen
#*die Anzahl der teilnehmenden Schnecken
#*die teilnemenden Schnecken selbst (z.B. in einer ArrayList)
#*die Länge der zu kriechenden Strecke
#:
#Überlege dir, welche dieser Werte bereits im Konstructor gesetzt werden sollten.
#:
#Lege in der Klasse "Rennen" eine Methode "void addRennschnecke(Rennschnecke neueSchnecke)" an, welche dem Rennen eine Schnecke hinzufügt.
#:
#Lege in der Klasse "Rennen" eine Methode "void removeRennschnecke(String name)" an, welche eine Schnecke aus dem Rennen entfernt.
#:
#Lege in der Klasse "Rennen" eine Methode "public String toString()" an, welche die Daten des Rennens mit return als String zurückgibt.
#*Tipp: Um die Daten der beteiligten Schnecken zurückzugeben, könnt ihr deren toString() Funktion benutzen.
#:
#Teste deine Klasse vom Hauptprogramm aus!
#:
#Lege in der Klasse "Rennen" eine Methode "Rennschnecke ermittleGewinner()" an, welche '''null''' zurückliefert, wenn noch keine der teilnemenden Schnecken das Ziel erreicht hat und anderenfalls die Gewinnerschnecke zurückgibt.
#:
#Lege in der Klasse "Rennen" eine Methode "void lasseSchneckenKriechen()" an, welche alle teilnemenden Schnecken einmal kriechen lässt.
#:
#Lege in der Klasse "Rennen" eine Methode "void durchfuehren()" an, welche so lange lasseSchneckenKriechen() aufruft, bis eine der Schnecken das Ziel erreicht hat.
#* Tipp: Ob eine Schnecke im Ziel angekommen ist, kannst du mit deiner Methode ermittleGewinner() herrausfinden.

== Wettbüro ==

#Erstelle eine Klasse Wettbuero.
#:
#:Ein Wettbuero hat die folgenden Eigenschaften:
#* Es weiß, für welches Rennen es seine Wetten entgegennimmt.
#* Es verfügt über eine Liste (z.B. eine Arraylist) von angenommenden Wetten.
#* Es hat einen festen Faktor, mit welchem Wetteinsätze bei einem Gewinn multipliziert werden.
#:
#Lege in der Klasse "Wettbuero" eine Methode "wetteAnnehmen(String schneckenName, int wetteinsatz, String spieler)" an, welche eine Wette entgegennimmt. Die Wette ist bezogen auf eine Schnecke für das Rennen, das von dem Büro bearbeitet wird.
#* Um die einzelnen Wetten speichern zu können, sollten ihre Daten in eigenen Objekten der Klasse "Wette" gespeichert werden. Erstellt euch diese Klasse selbst.
#* Tipp: Denkt an toString().
#:
#Lege in der Klasse "Wettbuero" eine Methode "rennenDurchfueren()" an, welche das betreute Rennen durchfuert.
#:
#Lege in der Klasse "Wettbuero" eine Methode "toString()" an, welche die Daten des Wettbueros, die Daten des Rennens sowie sämtliche abgeschlossende Wetten als String zurückgibt.
#:
# Teste dein Programm!
#:
# Tausche die Klasse Rennen mit einem Kommilitonen, der ebenfalls bereits fertig ist.
#* Sollten eure Programme immer noch laufen?
#* Treten Fehler auf? Wenn ja: ändert eure Programme so ab, dass ihr problemlos Klassen austauschen könnt.

== Zusatz ==

Es gibt noch ein paar Dinge, die in unserem Wettbüro nicht so laufen wie sie sollten.
Macht sie besser.

* Dieselbe Schnecke kann in ein Rennen zweimal eingetragen werden.
* Es können negative Wetten abgeschlossen werden.
* Gehen zwei Schnecken gleichzeitig durchs Ziel, wird die Schnecke ausgegeben, auf die die Suche nach dem Gewinner zuerst stößt. Das ist ganz schön ungerecht.

== Zusatz Vererbung ==

* Wo Geld im Spiel ist wird auch betrogen. Aus diesem Grund wollen wir jezt auch gedopte Rennschnecken an unseren Rennen teilnehmen lassen.
** Erstelle eine Klasse "Dopingschnecke", welche alle Attribute und Methoden der gemeinen "Rennschnecke" erbt.
** Überschreibe den geerbten Constructor, so das "Dopingschnecken" eine wesentlich höhere Maximalgeschwindigkeit erhalten als normale "Rennschnecken".
** Überschreibe die geerbte Methode "String toString()" so dass Dopingschnecken anders ausgegeben werden als Rennschnecken (z.B. durch einen zusatz wie "rote Augen" oder ähnliches)
** Mische in einem Rennen Dopingschnecken unter deine Rennschnecken. Du musst dafür keinerlei Funktionalitäten änder. Dein Programm muss nicht wissen ob es sich um eine Dopingschnecke handelt, denn sie ist ja auch eine Rennschnecke.

[[Javakurs2006| <- Zurück zur Übersicht]]

Javakurs/Übungsaufgaben/Rennschnecke

2006-05-06T11:33:55Z

130.149.17.40: /* Rennschnecke */

[[Javakurs2006| <- Zurück zur Übersicht]]

== Rennschnecke ==
#Erstelle eine Klasse "Rennschnecke"
#:
#Rennschnecken sollen folgende Eigenschaften(Objektvariablen) besitzen:
#* einen Namen
#* eine Rasse
#* eine Maximalgeschwindigkeit
#* die Schnecke soll wissen welchen Weg sie bereits zurück gelegt hat
#:
# Erstelle für die Klasse rennschnecke einen [[Javakurs2006/Java_Kurzreferenz#Konstruktor|Konstruktor]], der den Klassenvariablen beim Erstellen einer neuen Instanz(Objekt zu dieser Klasse) Werte zuweist.
#:
#Lege in der Klasse "Rennschnecke" eine Methode "krieche()" an, welche die Schnecke abhängig von ihrer Maximalgeschwindigkeit eine zufällige Strecke weiter bewegt.
#* Tipp: Schaut euch die Methode Math.random() aus der Java API an.
#:
#Lege in der Klasse "Rennschnecke" eine Methode "public String toString()" an, welche die Daten der Schnecke mit return als String zurückgibt.
#:
# Teste deine Klasse, indem du probehalber ein Rennschneckenobjekt erzeugst und seine Daten auf der Konsole ausgibst.
#*Tipp:Verwende zum Ausgeben der Daten die toString() Methode der Rennschnecke.
#:
#:

== Rennen ==

#Erstelle eine Klasse "Rennen"
#:
#Ein Rennen hat folgende Eigenschaften:
#*einen Namen
#*die Anzahl der teilnehmenden Schnecken
#*die teilnemenden Schnecken selbst (z.B. in einer ArrayList)
#*die Länge der zu kriechenden Strecke
#:
#Überlege dir, welche dieser Werte bereits im Konstructor gesetzt werden sollten.
#:
#Lege in der Klasse "Rennen" eine Methode "void addRennschnecke(Rennschnecke neueSchnecke)" an, welche dem Rennen eine Schnecke hinzufügt.
#:
#Lege in der Klasse "Rennen" eine Methode "void removeRennschnecke(String name)" an, welche eine Schnecke aus dem Rennen entfernt.
#:
#Lege in der Klasse "Rennen" eine Methode "public String toString()" an, welche die Daten des Rennens mit return als String zurückgibt.
#*Tipp: Um die Daten der beteiligten Schnecken zurückzugeben, könnt ihr deren toString() Funktion benutzen.
#:
#Teste deine Klasse vom Hauptprogramm aus!
#:
#Lege in der Klasse "Rennen" eine Methode "Rennschnecke ermittleGewinner()" an, welche '''null''' zurückliefert, wenn noch keine der teilnemenden Schnecken das Ziel erreicht hat und anderenfalls die Gewinnerschnecke zurückgibt.
#:
#Lege in der Klasse "Rennen" eine Methode "void lasseSchneckenKriechen()" an, welche alle teilnemenden Schnecken einmal kriechen lässt.
#:
#Lege in der Klasse "Rennen" eine Methode "void durchfuehren()" an, welche so lange lasseSchneckenKriechen() aufruft, bis eine der Schnecken das Ziel erreicht hat.
#* Tipp: Ob eine Schnecke im Ziel angekommen ist, kannst du mit deiner Methode ermittleGewinner() herrausfinden.

== Wettbüro ==

#Erstelle eine Klasse Wettbuero.
#:
#:Ein Wettbuero hat die folgenden Eigenschaften:
#* Es weiß, für welches Rennen es seine Wetten entgegennimmt.
#* Es verfügt über eine Liste (z.B. eine Arraylist) von angenommenden Wetten.
#* Es hat einen festen Faktor, mit welchem Wetteinsätze bei einem Gewinn multipliziert werden.
#:
#Lege in der Klasse "Wettbuero" eine Methode "wetteAnnehmen(String schneckenName, int wetteinsatz, String spieler)" an, welche eine Wette entgegennimmt. Die Wette ist bezogen auf eine Schnecke für das Rennen, das von dem Büro bearbeitet wird.
#* Um die einzelnen Wetten speichern zu können, sollten ihre Daten in eigenen Objekten der Klasse "Wette" gespeichert werden. Erstellt euch diese Klasse selbst.
#* Tipp: Denkt an toString().
#:
#Lege in der Klasse "Wettbuero" eine Methode "rennenDurchfueren()" an, welche das betreute Rennen durchfuert.
#:
#Lege in der Klasse "Wettbuero" eine Methode "toString()" an, welche die Daten des Wettbueros, die Daten des Rennens sowie sämtliche abgeschlossende Wetten als String zurückgibt.
#:
# Teste dein Programm!
#:
# Tausche die Klasse Rennen mit einem Kommilitonen, der ebenfalls bereits fertig ist.
#* Sollten eure Programme immer noch laufen?
#* Treten Fehler auf? Wenn ja: ändert eure Programme so ab, dass ihr problemlos Klassen austauschen könnt.

== Zusatz ==

Es gibt noch ein paar Dinge, die in unserem Wettbüro nicht so laufen wie sie sollten.
Macht sie besser.

* Dieselbe Schnecke kann in ein Rennen zweimal eingetragen werden.
* Es können negative Wetten abgeschlossen werden.
* Gehen zwei Schnecken gleichzeitig durchs Ziel, wird die Schnecke ausgegeben, auf die die Suche nach dem Gewinner zuerst stößt. Das ist ganz schön ungerecht.

== Zusatz Vererbung ==

* Wo Geld im Spiel ist wird auch betrogen. Aus diesem Grund wollen wir jezt auch gedopte Rennschnecken an unseren Rennen teilnehmen lassen.
** Erstelle eine Klasse "Dopingschnecke", welche alle Attribute und Methoden der gemeinen "Rennschnecke" erbt.
** Überschreibe den geerbten Constructor, so das "Dopingschnecken" eine wesentlich höhere Maximalgeschwindigkeit erhalten als normale "Rennschnecken".
** Überschreibe die geerbte Methode "String toString()" so dass Dopingschnecken anders ausgegeben werden als Rennschnecken (z.B. durch einen zusatz wie "rote Augen" oder ähnliches)
** Mische in einem Rennen Dopingschnecken unter deine Rennschnecken. Du musst dafür keinerlei Funktionalitäten änder. Dein Programm muss nicht wissen ob es sich um eine Dopingschnecke handelt, denn sie ist ja auch eine Rennschnecke.

[[Javakurs2006| <- Zurück zur Übersicht]]

Eclipsekurs 2006/Tag 1

2006-05-06T10:49:40Z

130.149.17.40: /* Autocompletion */

== Erste Schritte ==
* Starte die Eclipse-Umgebung mit dem Kommando '''/home/pub/lib/eclipse/eclipse'''

=== Projekt anlegen ===
* Erstelle ein Java-Projekt "eclipseTutorial" mit getrennten Ordnern für den Quellcode (''src'') und kompilierte class-Dateien (''bin'').
** Konfiguriere dabei Eclipse so, das es ab jetzt diese Einstellung als Standardwert verwendet.

* Lege in diesem Projekt eine neue Klasse "Spielwiese" an, die eine ''main''-Methode enthält.
* Erweitere die Klasse zu einem "Hello World"-Programm und führe dieses in Eclipse aus.
''Tipp:'' Mit sysout [Strg+Leerzeichen] erzeugt die Eclipse-Autocompletion ein System.out.println();

=== Aufruf mit Parametern ===
* Verändere das Programm so, dass es einen beim Start übergebenden Parameter auf dem Bildschirm ausgibt.
''Tipp 1:'' Die Funktion main bekommt ihre Parameter als Array von Strings. Der Name des ersten übergebenen Parameters ist also args[0] .
''Tipp 2:'' Die Parameter des Programms kannst du in der Run-Configuration einstellen.

=== Autocompletion ===
* Lege eine neue Klasse "TinyObject" an, welche '''keine''' main Methode enthält.
* "TinyObject" soll drei Instanzvariablen enthalten. Wenn ein Objekt dieser Art erzeugt wird, sollen diese mit einem beliebigen Wert initialisiert werden.
* Erweitere "TinyObject" um eine Methode "void printYourselfAndThis(String text)", die den übergebenen Text sowie den Inhalt der Instanzvariablen auf der Konsole ausgibt.
* Sieh dir an, was passiert, wenn du in dieser Funktion "this." schreibst und anschließend kurz wartest oder die Autocompletion mit [Strg+Leerzeichen] aktivierst.
* Lege eine Instanzvariable "diesIstEinLangerName" an. Schreibe irgendwo in der Klasse "diesIst" und drücke [Strg+Leerzeichen].
* Erzeuge in der "Spielwiese" ein "TinyObject" und teste deine Methode.

=== Autokorrektur ===
* Baue Fehler in dein Programm ein (Semikolon löschen, Klammer löschen, Tippfehler) und sieh dir an, welche Korrekturvorschläge Eclipse anbietet. Spiele mit diesem Feature ein wenig herum. Du kannst Änderungen jederzeit rückgängig ([Strg+Z], Undo) machen.
''Tipp:'' Beachte die "Problems"-Ansicht, sowie die Markierungen links und rechts vom Editorfenster. Manchmal muss man Änderungen allerdings erst speichern, damit die Anzeigen aktualisiert werden.

=== Templates ===
*Unter "windows -> preferences -> java -> editor -> templates" findest du die Schlüsselwörter für alle Templates, die du in Eclipse mit [Schlüsselwort][Strg+Leerzeichen] einsetzen kannst. Probiere einige Schlüsselwörter, die dir bekannt vorkommen aus.

=== Programmabbruch ===
* Lege eine Methode "void keepLooping()" an, welche eine Endlosschleife mit einer Konsolenausgabe (z.B. "still looping") enthält. Führe diese Methode aus und brich die Ausführung mit dem roten Stop-Button ab.

=== Navigieren im Projekt ===
* Sieh dir die "Outline"-Ansicht an und probiere aus, wie du mit ihr in deinen Klassen navigieren kannst.
* Halte die [Strg] Taste gedrückt und gehe mit der Maus über einen Funktionsaufruf. Klicke ihn an. Was ist passiert?
''Tip:'' Am oberen Rand des Fensters gibt es gelbe Vorwärts- und Rückwärts-Knöpfe - mit ihnen kannst du wie in einem Web-Browser die Plätze, die du mit [Strg]-Klick angesprungen hast, wieder besuchen.

=== Javadoc ===
* Kommentiere deinen beiden Funktionen mit Javadoc.
''Tipp:'' /**[Enter] in der Zeile vor einer Methode oder Klasse legt automatisch einen Javadoc-Rumpf mit allen benutzten Parametern an.
* Bewege den Cursor in deinem Hauptprogramm auf eine Stelle, an der du eine der kommentierten Funktionen verwendest, und sieh dir die Javadoc-Ansicht an.

== Übungsaufgaben ==

Du hast jetzt einige der kleinen Helfer kennengelernt, mit denen Eclipse dich beim Programmieren unterstützt. Übung im Umgang mit Eclipse bekommst du allerdings erst, wenn du es verwendest, wofür wir euch im Folgenden zwei Übungsaufgaben gebastelt haben.
Die Zeit hier im Tutorium wird vermutlich nicht ausreichen, um die Aufgeben fertig zu stellen, sie sollen nur eine Substanz bilden, an der ihr Eclipse ausprobieren könnt.

Aufgabe 1 führt euch langsam durch ein kleines Projekt, bei dem ihr Gelegenheit habt, alle Features, die ihr eben kennengelernt habt, auszuprobieren.

Aufgabe 2 ist ausschließlich für diejenigen, die schon einiges an Erfahrung in Java mitbringen und einfach nur ein wenig mit Eclipse programmieren wollen.

Viel Spaß!

=== Aufgabe1 (für alle) ===

Für alle, die sie noch nicht kennen und alle, die sie noch einmal ordentlich schreiben wollen:

''' [[Javakurs2006/Rennschnecke| Die Rennschnecken]] '''

=== Aufgabe 2 (für Experten) ===

'''Cäsar-Chiffre'''

Im Folgenden soll ein Programm weitgehend selbstständig entwickelt werden. Lies dir das nötige Wissen zur [http://de.wikipedia.org/wiki/Caesar-Chiffre#Sicherheit Cäsar-Chiffre] im Web an und überleg dir selbst eine Struktur für dein Programm.

Mache dir auch Gedanken darüber, wie du die einzelnen Teile frühzeitig testen kannst.

#Erstelle ein Programm, das einen Text aus einer Datei einliest, mit einem Schlüssel (einer Zahl zwischen 1 und 25) durch eine [http://de.wikipedia.org/wiki/Caesar-Chiffre#Sicherheit Cäsar-Chiffre] verschlüsselt und in einer neuen Datei (z.B. mit anderer Endung) speichert.
#* Für mehr Komfort, aber nicht notwendig: Sowohl der Dateiname als auch der Schlüssel sollen über die Konsole eingegeben werden können.
#* '''Tipp:''' Das Programm wird einfacher, wenn man als erstes den Text in Kleinschreibung umwandelt. Sonderzeichen, Leerzeichen und Zahlen können unverändert übernommen werden.
#Erweitere dein Programm so, dass es einen Text entschlüsseln kann, der mit demselben Chiffrierverfahren verschlüsselt wurde. Der Schlüssel wird hierfür übergeben und der lesbare Text soll in einer separaten Datei gespeichert werden.
#Erweitere dein Programm so, dass es in der Lage ist, einen beliebigen mit einer [http://de.wikipedia.org/wiki/Caesar-Chiffre#Sicherheit Cäsar-Chiffre] verschlüsselten Text mit Hilfe von [http://de.wikipedia.org/wiki/H%C3%A4ufigkeitsanalyse Häufigkeitsanalyse] zu entschlüsseln, ohne den Schlüssel zu kennen. Gib auch den gefundenen Schlüssel aus.

'''Hinweis:''' Unsere Tutoren können dir bei allen auftretenden Javaproblemen helfen, wir können allerdings nicht garantieren, dass sie sich in ihrer Freizeit auch mit Kryptographie beschäftigen.

'''Verschlüsseln / Entschlüsseln'''

#Trage einen von dir verschlüsselten Text mit mind. 50 Zeichen hier im Wiki ein und verlinke ihn auf dieser Seite unter deinem Namen. Entschlüssle andere Texte, die hier verlinkt sind.

Wenn du willst, kannst du deinen Chiffrieralgorithmus auch verändern oder einen anderen implementieren. Du solltest das aber im Link zu deinem verschlüsselten Texten aber auch kenntlich machen. Denke daran, dass du selbst in der Lage sein solltest, deine Texte bei gegebenem Schlüssel zu entschlüsseln ;)

----

[[Eclipsekurs 2006|Zurück zu Eclipse 2006]]

Eclipsekurs 2006/Tag 1

2006-05-06T10:48:22Z

130.149.17.40: /* Autocompletion */

== Erste Schritte ==
* Starte die Eclipse-Umgebung mit dem Kommando '''/home/pub/lib/eclipse/eclipse'''

=== Projekt anlegen ===
* Erstelle ein Java-Projekt "eclipseTutorial" mit getrennten Ordnern für den Quellcode (''src'') und kompilierte class-Dateien (''bin'').
** Konfiguriere dabei Eclipse so, das es ab jetzt diese Einstellung als Standardwert verwendet.

* Lege in diesem Projekt eine neue Klasse "Spielwiese" an, die eine ''main''-Methode enthält.
* Erweitere die Klasse zu einem "Hello World"-Programm und führe dieses in Eclipse aus.
''Tipp:'' Mit sysout [Strg+Leerzeichen] erzeugt die Eclipse-Autocompletion ein System.out.println();

=== Aufruf mit Parametern ===
* Verändere das Programm so, dass es einen beim Start übergebenden Parameter auf dem Bildschirm ausgibt.
''Tipp 1:'' Die Funktion main bekommt ihre Parameter als Array von Strings. Der Name des ersten übergebenen Parameters ist also args[0] .
''Tipp 2:'' Die Parameter des Programms kannst du in der Run-Configuration einstellen.

=== Autocompletion ===
* Lege eine neue Klasse "TinyObject" an, welche '''keine''' main Methode enthält.
* "TinyObject" soll drei Instanzvariablen enthalten. Wenn ein Objekt dieser Art erzeugt wird, sollen diese mit einem beliebigen Wert initialisiert werden.
* Erweitere "TinyObject" um eine Methode "void printYourselfAndThis(String text)", die den übergebenen Text sowie den Inhalt der Klassenvariablen auf der Konsole ausgibt.
* Sieh dir an, was passiert, wenn du in dieser Funktion "this." schreibst und anschließend kurz wartest oder die Autocompletion mit [Strg+Leerzeichen] aktivierst.
* Lege eine Klassenvariable "diesIstEinLangerName" an. Schreibe irgendwo in der Klasse "diesIst" und drücke [Strg+Leerzeichen].
* Erzeuge in der "Spielwiese" ein "TinyObject" und teste deine Methode.

=== Autokorrektur ===
* Baue Fehler in dein Programm ein (Semikolon löschen, Klammer löschen, Tippfehler) und sieh dir an, welche Korrekturvorschläge Eclipse anbietet. Spiele mit diesem Feature ein wenig herum. Du kannst Änderungen jederzeit rückgängig ([Strg+Z], Undo) machen.
''Tipp:'' Beachte die "Problems"-Ansicht, sowie die Markierungen links und rechts vom Editorfenster. Manchmal muss man Änderungen allerdings erst speichern, damit die Anzeigen aktualisiert werden.

=== Templates ===
*Unter "windows -> preferences -> java -> editor -> templates" findest du die Schlüsselwörter für alle Templates, die du in Eclipse mit [Schlüsselwort][Strg+Leerzeichen] einsetzen kannst. Probiere einige Schlüsselwörter, die dir bekannt vorkommen aus.

=== Programmabbruch ===
* Lege eine Methode "void keepLooping()" an, welche eine Endlosschleife mit einer Konsolenausgabe (z.B. "still looping") enthält. Führe diese Methode aus und brich die Ausführung mit dem roten Stop-Button ab.

=== Navigieren im Projekt ===
* Sieh dir die "Outline"-Ansicht an und probiere aus, wie du mit ihr in deinen Klassen navigieren kannst.
* Halte die [Strg] Taste gedrückt und gehe mit der Maus über einen Funktionsaufruf. Klicke ihn an. Was ist passiert?
''Tip:'' Am oberen Rand des Fensters gibt es gelbe Vorwärts- und Rückwärts-Knöpfe - mit ihnen kannst du wie in einem Web-Browser die Plätze, die du mit [Strg]-Klick angesprungen hast, wieder besuchen.

=== Javadoc ===
* Kommentiere deinen beiden Funktionen mit Javadoc.
''Tipp:'' /**[Enter] in der Zeile vor einer Methode oder Klasse legt automatisch einen Javadoc-Rumpf mit allen benutzten Parametern an.
* Bewege den Cursor in deinem Hauptprogramm auf eine Stelle, an der du eine der kommentierten Funktionen verwendest, und sieh dir die Javadoc-Ansicht an.

== Übungsaufgaben ==

Du hast jetzt einige der kleinen Helfer kennengelernt, mit denen Eclipse dich beim Programmieren unterstützt. Übung im Umgang mit Eclipse bekommst du allerdings erst, wenn du es verwendest, wofür wir euch im Folgenden zwei Übungsaufgaben gebastelt haben.
Die Zeit hier im Tutorium wird vermutlich nicht ausreichen, um die Aufgeben fertig zu stellen, sie sollen nur eine Substanz bilden, an der ihr Eclipse ausprobieren könnt.

Aufgabe 1 führt euch langsam durch ein kleines Projekt, bei dem ihr Gelegenheit habt, alle Features, die ihr eben kennengelernt habt, auszuprobieren.

Aufgabe 2 ist ausschließlich für diejenigen, die schon einiges an Erfahrung in Java mitbringen und einfach nur ein wenig mit Eclipse programmieren wollen.

Viel Spaß!

=== Aufgabe1 (für alle) ===

Für alle, die sie noch nicht kennen und alle, die sie noch einmal ordentlich schreiben wollen:

''' [[Javakurs2006/Rennschnecke| Die Rennschnecken]] '''

=== Aufgabe 2 (für Experten) ===

'''Cäsar-Chiffre'''

Im Folgenden soll ein Programm weitgehend selbstständig entwickelt werden. Lies dir das nötige Wissen zur [http://de.wikipedia.org/wiki/Caesar-Chiffre#Sicherheit Cäsar-Chiffre] im Web an und überleg dir selbst eine Struktur für dein Programm.

Mache dir auch Gedanken darüber, wie du die einzelnen Teile frühzeitig testen kannst.

#Erstelle ein Programm, das einen Text aus einer Datei einliest, mit einem Schlüssel (einer Zahl zwischen 1 und 25) durch eine [http://de.wikipedia.org/wiki/Caesar-Chiffre#Sicherheit Cäsar-Chiffre] verschlüsselt und in einer neuen Datei (z.B. mit anderer Endung) speichert.
#* Für mehr Komfort, aber nicht notwendig: Sowohl der Dateiname als auch der Schlüssel sollen über die Konsole eingegeben werden können.
#* '''Tipp:''' Das Programm wird einfacher, wenn man als erstes den Text in Kleinschreibung umwandelt. Sonderzeichen, Leerzeichen und Zahlen können unverändert übernommen werden.
#Erweitere dein Programm so, dass es einen Text entschlüsseln kann, der mit demselben Chiffrierverfahren verschlüsselt wurde. Der Schlüssel wird hierfür übergeben und der lesbare Text soll in einer separaten Datei gespeichert werden.
#Erweitere dein Programm so, dass es in der Lage ist, einen beliebigen mit einer [http://de.wikipedia.org/wiki/Caesar-Chiffre#Sicherheit Cäsar-Chiffre] verschlüsselten Text mit Hilfe von [http://de.wikipedia.org/wiki/H%C3%A4ufigkeitsanalyse Häufigkeitsanalyse] zu entschlüsseln, ohne den Schlüssel zu kennen. Gib auch den gefundenen Schlüssel aus.

'''Hinweis:''' Unsere Tutoren können dir bei allen auftretenden Javaproblemen helfen, wir können allerdings nicht garantieren, dass sie sich in ihrer Freizeit auch mit Kryptographie beschäftigen.

'''Verschlüsseln / Entschlüsseln'''

#Trage einen von dir verschlüsselten Text mit mind. 50 Zeichen hier im Wiki ein und verlinke ihn auf dieser Seite unter deinem Namen. Entschlüssle andere Texte, die hier verlinkt sind.

Wenn du willst, kannst du deinen Chiffrieralgorithmus auch verändern oder einen anderen implementieren. Du solltest das aber im Link zu deinem verschlüsselten Texten aber auch kenntlich machen. Denke daran, dass du selbst in der Lage sein solltest, deine Texte bei gegebenem Schlüssel zu entschlüsseln ;)

----

[[Eclipsekurs 2006|Zurück zu Eclipse 2006]]

Benutzer Diskussion:Martin Häcker

2006-04-06T07:15:18Z

130.149.17.40:

Danke für den Bindestrich! --Jérôme

Javakurs/Übungsaufgaben/Rennschnecke

2006-04-06T07:09:09Z

130.149.17.40: /* Zusatz */

== Rennschnecke ==
#Erstelle eine Klasse "Rennschnecke"
#:
#Rennschnecken sollen folgende Eigenschaften(Klassenvariablen) besitzen:
#* einen Namen
#* eine Rasse
#* eine Maximalgeschwindigkeit
#* die Schnecke soll wissen welchen Weg sie bereits zurück gelegt hat
#:
# Erstelle für die Klasse Schnecke einen Constructor, der den Klassenvariablen beim Erstellen einer neuen Instanz(Objekt zu dieser Klasse) Werte zuweist.
#:
#Lege für in der Klasse "Rennschnecke" eine Methode "krieche()" an, welche die Schnecke abhängig von ihrer Maximalgeschwindigkeit eine zufällige Strecke weiter bewegt.
#* Tipp: schaut euch die Methode Math.random() aus der Java API an.
#:
#Lege in der Klasse "Rennschnecke" eine Methode "String toString()" an, welche die Daten der Schnecke mit return als String zurückgibt.
#:
# Teste deine Klasse indem du probehalber ein Rennschneckenobjekt erzeugst und seine Daten auf der Console ausgibst.
#*Tipp:Verwende zum Ausgeben der Daten die toString() Methode der Rennschnecke.
#:
#:
== Rennen ==

#Erstelle eine Klasse "Rennen"
#:
#Ein Rennen hat folgende Eigenschaften:
#*Einen Namen
#*Die Anzahl der teilnehmenden Schnecken
#*Die teilnemenden Schnecken selbst (z.B. in einer ArrayList)
#*die Länge der zu kriechenden Strecke
#:
#Überlege dir welche dieser Wetrte bereits im Constructor gesetzt werden sollten.
#:
#Lege in der Klasse "Rennen" eine Methode "void addRennschnecke(Rennschnecke neueSchnecke)" an, welche dem Rennen eine Schnecke hinzufügt.
#:
#Lege in der Klasse "Rennen" eine Methode "void removeRennschnecke(String name)" an, welche eine Schnecke aus dem Rennen entfernt.
#:
#Lege in der Klasse "Rennen" eine Methode "String toString()" an, welche die Daten des Rennens mit return als String zurückgibt.
#*Tipp: Um die Daten der beteiligten Schnecken zurückzugeben könnt ihr deren toString() Funktion benutzen.
#:
#Teste deine Klasse vom Hauptprogramm aus!
#:
#Lege in der Klasse "Rennen" eine Methode "Rennschnecke ermittleGewinner()" an, welche '''null''' zurückliefert wenn noch keine der Teilnemenden Schnecken das Ziel erreicht und anderenfalls die
#:Gewinnerschnecke zurückgibt.
#:
#Lege in der Klasse "Rennen" eine Methode "void lasseSchneckenKriechen()" an, welche alle teilnemenden Schnecken einmal kriechen lässt.
#:
#Lege in der Klasse "Rennen" eine Methode "void durchfuehren()" an, welche so lange lasseSchneckenKriechen() aufruft, bis eine der Schnecken das Ziel erreicht hat.
#* Tipp: ob eine Schnecke im Ziel angekommen ist kannst du mit deiner Methode ermittleGewinner() herrausfinden.

== Wettbüro ==

#Erstelle eine Klasse Wettbuero.
#:
#:Ein Wettbuero hat die folgenden Eigenschaften:
#* es weiß für welches Rennen es seine Wetten entgegennimmt
#* es verfügt über eine Liste (z.B. eine Arraylist) von angenommenden Wetten
#* es hat einen festen Faktor, mit welchem Wetteinsätze bei einem Gewinn multipliziert werden
#:
#Lege in der Klasse "Wettbuero" eine Methode "wetteAnnehmen(String schneckenName, int wetteinsatz, String spieler)" an, welche eine Wette auf eine Schnecke für das Rennen das von dem Büro bearbeitet wird entgegennimmt.
#* Um die einzelnden Wetten speichern zu können sollten ihre Daten in eigenden Objekten der Klasse "Wette" gespeichert werden. Erstellt euch diese Klasse selbst.
#* Tipp: denkt an toString()
#:
#Lege in der Klasse "Wettbuero" eine Methode "rennenDurchfueren()" an, welche das betreute Rennen durchfuert.
#:
#Lege in der Klasse "Wettbuero" eine Methode "toString()" an, welche die Daten des Wettbueros, die Daten des Rennens sowie sämtliche abgeschlossende Wetten als String zurückgibt.
#:
# Teste dein Programm!
#:
# Tausche die Klasse Rennen mit einem Komilitonen der ebenfalls bereits fertig ist.
#* Sollten eure Programme immer noch laufen?
#* Treten Fehler auf? Wenn ja: ändert eure Programme so ab das ihr problemlos Klassen austauschen könnt.

== Zusatz ==

Es gibt noch ein paar Dinge die in unserem Wettbüro nicht so laufen wie sie sollten.
Macht sie besser.

* Die selbe Schnecke kann in ein Rennen zwei mal eingetragen werden
* es können negative Wetten abgeschlossen werden.
* gehen zwei Schnecken gleichzeitig durchs Ziel wird die Schnecke ausgegeben auf die die Suche nach dem Gewinner zuerst stößt. Das ist ganz schön ungerecht.

Javakurs2006

2006-04-05T11:17:20Z

130.149.17.40:

__NOTOC__
Salve!

Herzlich Willkommen beim Java Kurs der Freitagsrunde!
Dieser Kurs richtet sich an Studenten die gerade mit dem zweiten Semester beginnen. Das heißt, wir erwarten Grundkenntnisse in Opal - sonst aber nichts.

Dieser Kurs wird von [[Javakurs2006/Veranstalter | Freiwilligen Studenten und Wissenschaftlichen Mitarbeitern]] in Ihrer Freizeit angeboten - zeigt uns also wenn es euch gefällt. :)

Der Kurs beginnt am 3.4.2006 und geht bis zum 7.4.2006.

Wir haben die [http://docs.freitagsrunde.org/javakurs/Raeume_Teilnehmer_sort.pdf Zuordnung der Teilnehmer auf die Räume] zentral vorgenommen - und [http://docs.freitagsrunde.org/javakurs/Raeume_Teilnehmer_sort.pdf hier abgelegt].

Wir versuchen außerdem, häufige Fehler auf folgender Seite zusammenzufassen: [[Javakurs2006/Probleme]] und bieten für die einzelnen Themen [[Javakurs2006/Uebungsaufgaben| Wiederholungsaufgaben]] an.

Ausserdem haben wir für euch eine [[Javakurs2006/Java_Kurzreferenz| Java-Kurzreferenz]] zusammengestellt.

Bücher die sich lohnen: [http://www.galileocomputing.de/openbook/javainsel5/ Java ist auch eine Insel] [http://www.codeguru.com/java/tij/tij_c.shtml Thinking in Java] ([http://mindview.net/Books/DownloadSites/ als zip])

== Tagesplan ==
Wir beginnen immer Morgens um 9:00 s.t. im MA043 - kommt also bitte morgens immer Pünktlich. Die Tutorien danach finden im Franklin-Gebäude im 5. und 6. Stock statt. In welchem Raum ihr eingeteilt seid, hängt im Vorlesungssaal aus.

{| border="0" cellpadding="4" cellspacing="2"
|- bgcolor="#E0E0E0"
!von
!bis
!was?
|- bgcolor="#F0F0F0"
|9:00 s.t.
|9:45
|Vorlesung
|- bgcolor="#F8F8F8"
|10:00
|12:00
|Übung
|- bgcolor="#F0F0F0"
|12:00
|12:45
|Mittagspause
|- bgcolor="#F8F8F8"
|13:00 s.t.
|13:45
|Vorlesung
|- bgcolor="#F0F0F0"
|14:00
|16:00
|Übung
|}

Am letzten Tag (Donnerstag) wird es nachmittags keine Vorlesung geben, sonder das Projekt beginnt gleich.

== Einzelne Tage ==
{| border="0" cellpadding="4" cellspacing="2"
|- bgcolor="#E0E0E0"
!Tag Nr.
!Vormittag
!Nachmittag
|- bgcolor="#F0F0F0"
|[[{{PAGENAME}}/Tag 1|Tag 1]]
|Hello, World!
|Methoden und Schleifen
|- bgcolor="#F8F8F8"
|[[{{PAGENAME}}/Tag 2|Tag 2]]
|Modularisierung mit Klassen und Objekten
|OO-Vertiefung und Klassenbibliothek
|- bgcolor="#F0F0F0"
|[[{{PAGENAME}}/Tag 3|Tag 3]]
|Programmieren
|Programmieren
|- bgcolor="#F8F8F8"
|[[{{PAGENAME}}/Tag 4|Tag 4]]
|Programmieren
|Programmieren
|}

== Bei Problemen ==
Wenn Du:
* noch nicht bezahlt oder noch keine Bestätigung von uns erhalten (bitte Bankbeleg im Zweifelsfall nicht vergessen!)
* nicht weißt in welchem Raum dein Tutorium stattfindet / wo du hinmusst

Dann kann dir am ersten Tag (Montag) im FR5046 den ganzen Tag geholfen werden. Dorthin könnt ihr immer gehen bzw. anrufen unter der Nummer: 030-314-21386. An allen weiteren Tagen wird der Raum auf jeden Fall während der Mittagspause (12:00 - 12:45), besetzt sein - probieren kannst du es aber immer. Wir sind aber auch rund um die Uhr unter der email-Adresse javakurs06@freitagsrunde.org erreichbar.

Wenn du:
* Keinen Account hier auf den Rechnern hast
* Probleme mit dem Einloggen hast
Dann kann dir der IRB helfen. Dazu gehe zuerst ins Sekretariat (5091). Wenn dort niemand ist, dann findet ihr im 5093 Hilfe.

== Getränke ==
Von dem Geld das ihr uns Überwiesen habt haben wir Getränke besorgt. Damit kein Ärger entsteht (z.B. mit dem Rechnerbetrieb) haltet ihr euch bitte an diese Regeln:
* Getränkeausgabe ist jeden Tag während der Mittagspause im FR5046 und dem Nachbarraum
* Bitte keine Flaschen in die Rechnerräume mitnehmen. Wenn doch, dann bitte '''verschlossen''' auf den Boden stellen.
** Wenn jemand vom Rechnerbetrieb kommt und über irgend etwas meckert, dann habt ihr dem Folge zu leisten. (Nur zur erklärung: Wenn der Rechnerbetrieb sauer ist, können wir den Kurs nicht durchführen!)
* Gebt die Flaschen bitte abends ausgetrunken wieder bei uns ab. Wir geben die Flaschen ohne Pfand aus und wollen sie daher auch wieder haben!
* Nur eine Flasche pro Tag und pro Teilnehmer -> Wenn jemand anders sich schamlos bedient, dann weißt ihn doch bitte freundlich darauf hin das andere auch gerne etwas hätten.
* Gebt bitte auf die Flaschen, die Rechner und die Nerven eurer Mitstudenten acht - von allem ist nur sehr wenig da! :-)

Javakurs2006/Tag 3

2006-04-05T08:01:05Z

130.149.17.40:

[[Javakurs2006| <- Zurück zur Übersicht]]

Ab heute verändert sich der Tagesplan - wir veranstalten jetzt Vor- und Nachmittags Übungen.

* Heute morgen sind zuerst restlichen Aufgaben von [http://docs.freitagsrunde.org/javakurs/blatt03.pdf Blatt 3] dran.
* Eine Kurzreferenz für Java [[Benutzer:Grey/Javakurzreferenz| ist seit gestern Online]].
* Wir haben ein [[Javakurs2006/Uebungsaufgaben| größeres Angebot an Beispiel-Aufgaben]] um bestimmte Themengebiete zu wiederholen. Diese Aufgaben sind nicht dafür da das man sie von vorne nach hinten durcharbeitet, sondern damit ihr euch ein Gebiet heraussucht und
* [http://docs.freitagsrunde.org/javakurs/AufgabenTDDv2.pdf Fortgeschrittene Aufgaben] für leute die sich für Test-Driven-Development interessieren

[[Javakurs2006| <- Zurück zur Übersicht]]

Diskussion:Hauptseite

2006-04-05T06:36:21Z

130.149.17.40: s/Javakurs Website/Javakurs-Website/ bitte tun

<div style="margin:0; border:1px solid #dfdfdf; padding: 0em 1em 1em 1em; background-color:#efefef; align:left;">
=== Thementemplates ===
Zum ändern der einzelnen Themenboxen könnt ihr die Templates unter folgenden Links verwenden
*[[Vorlage:HauptseiteWillkommenBox | Willkommenbox]]
*[[Vorlage:HauptseiteHinweiseBox | Hinweisebox]]
*[[Vorlage:HauptseiteNewsBox | Newsbox]]
*[[Vorlage:HauptseiteWasWikiBietetBox | "Was euch dieses Wiki bietet"]]
</div>
kleiner test...

Wie läuft das hier eigentlich mit der Rechtschreibung? Also "alt" oder "neu" oder "jeder so, wie er gerne möchte"? Eigentlich ist mir das ziemlich egal, ich finds nur halt etwas unglücklich, wenn in einem Text "dass" erst mehrfach mit "ss" und zwischendurch immer wieder mit "ß" geschrieben wird... -- [[Benutzer:FelixBrossmann|FelixBrossmann]]

:Also ich schreibe so wie ich es in der Schule gelernt habe, so richtig schön nach der alten Rechtschreibung und "daß" natürlich ohne "ss". :-) Aber Du hast natürlich recht, sieht ein wenig komisch aus, wenn auf einer Seite alte und neue Rechtschreibung gemischt wird. Dies global im ganzen Wiki einheitlich zu gestalten dürfte recht schwer werden, aber innerhalb eines Artikels sollte es schon möglichst konsistent sein (also entweder alles nach der alten oder neuen Rechtschreibung).

:Letztlich bleibt es jedem selbst überlassen, irgendwelche Regeln werden wir nicht vorgeben. --[[Benutzer:Thomas|Thomas]] 22:12, 27. Okt 2004 (CEST)

:Meine Rechtschreibung ist nicht so toll - daher bin ich sehr dafür zu haben das jeder der einen findet den einfach behält und korrigiert. Einwände? -- [[Benutzer:Martin Häcker|Martin Häcker]] 15:47, 10. Dez 2004 (CET)

== Formatierungen ==

Der Source-Code der Seiten die ein Boxen-Layout verwenden ist grausig. Ich bin dafür das wir die verschiednen "box-formate" die wir im Wiki verwenden in eine CSS-Datei auslagern, da ich glaube das das echt helfen könnte. Ausserdem müssen wir die Boxen nicht ständig neu per css-gestalten und können die so im wiki einheitlich "einfärben".

Wenn keiner einwände hat würde ich das nach weihnachten mal angehen. -- [[Benutzer:Martin Häcker|Martin Häcker]] 06:25, 11. Dez 2004 (CET)

==Interwiki==
Wenn jemand folgende Datensätze in die MySQL-Tabelle interwiki einfügen würde, könnte man die Interwiki-Links nutzen. Das würde z.B. im Artikel [[Geschichte der Fakultät]] den ein oder anderen Link direkt anklickbar machen:
<pre>
INSERT INTO `interwiki` VALUES ('de', 'http://de.wikipedia.org/wiki/$1', 0);
INSERT INTO `interwiki` VALUES ('en', 'http://en.wikipedia.org/wiki/$1', 0);
INSERT INTO `interwiki` VALUES ('fr', 'http://fr.wikipedia.org/wiki/$1', 0);
</pre>
Eventuell heißt die Tabelle auch PRAEFIX_interwiki o.ae.
[[Benutzer:Calmoxis|Calmoxis]] 16:29, 12. Sep 2005 (CEST)

: Calmoxis: Bitte wende dich an Thomas, unseren Wiki-Sysop. Hilfreich wäre allerdings zu wissen, was das genau bringen würde. --[[Benutzer:Felix|Felix]] 21:55, 17. Sep 2005 (CEST)

== Bücherbörse ==

Hi leute

wollt ma fragen, ob jemand das buch "funktionale programmierung" gebraucht hat und verkaufen kann. die 30 € sind ehrlichgesagt teuer.

falls ihr nicht genau wisst welches buch ich meine [http://www.amazon.de/exec/obidos/ASIN/3540436219/qid=1130347473/sr=8-1/ref=sr_8_xs_ap_i1_xgl/028-2955434-3257348 dann hier klicken]

: jaaaaaa? Wer will das Buch denn kaufen? --[[Benutzer:Mutax|mutax]] 20:38, 3. Nov 2005 (CET)

:::Das Buch gibt es gebraucht ab 18 Euro bei [http://www.abebooks.de/servlet/SearchResults?y=0&tn=funktionale+Programmierung&x=0&sortby=3 Abebooks] oder [http://www.zvab.com/ ZVAB]. [[Benutzer:Calmoxis|Calmoxis]] 17:53, 8. Nov 2005 (CET)

==s/Javakurs Webseite/Javakurs-Webseite/==

Bitte! Danke! --Jérôme

Javakurs2006/Java Kurzreferenz

2006-04-05T06:30:16Z

130.149.17.40: /* while-Schleife */ Korrekturen

Hier befindet sich eine kleine '''Referenz für Java''' speziell für den Javakurs der Freitagsrunde.

== Kommentare ==
Ein '''Kommentar''' ist ein Abschnitt des Java-Codes, der vom Java-Compiler ignoriert wird. Man kann in ein Kommentar also schreiben was man will. Kommentare sind nützlich, um den Quellcode zu dokumentieren.

In Java gibt es zwei Arten von Kommentaren:

===Kommentare über eine Zeile===

// Diese ganze Zeile wird vom Compiler ignoriert.
int x= 5; // Dieser Kommentar beginnt mit »//«. Alles davor wird vom Compiler nicht ignoriert.

===Kommentare über mehrere Zeilen===

/* Dieser
Kommentar
erstreckt
sich
über
mehrere
Zeilen.
*/

Zum Vergleich: in Opal werden Kommentare mit -- eingeführt.

== Datentypen (Variablen) ==
{| border="2" cellspacing="0" cellpadding="4" width="80%" rules="all" style="margin:1em 1em 1em 0; border:solid 1px #AAAAAA; border-collapse:collapse; background-color:#F9F9F9; font-size:95%; empty-cells:show;"
! style="background-color:#ABCDEF;" | Typ
! style="background-color:#ABCDEF;" | Speicherbedarf
! style="background-color:#ABCDEF;" | Bereich
|-
|int
|4 Byte
| -2.147.483.648 bis 2.147.483.647
|-
|short
|2 Byte
| -32.768 bis 32.787
|-
|long
|8 Byte
| -9.223.372.036.854.775.808L bis 9.223.372.036.854.775.807L
|-
|byte
|1 Byte
| -128 bis 127
|-
|float
|4 Byte
| +/-3,40282347E+38F
|-
|double
|8 Byte
| +/-1,79769313486231570E+308
|}

== Boolsche Operatoren ==
{| border="2" cellspacing="0" cellpadding="4" width="80%" rules="all" style="margin:1em 1em 1em 0; border:solid 1px #AAAAAA; border-collapse:collapse; background-color:#F9F9F9; font-size:95%; empty-cells:show;"
! style="background-color:#ABCDEF;" | Operator
! style="background-color:#ABCDEF;" | Beispiel
! style="background-color:#ABCDEF;" | Ergebnis des Beispiels
|-
| ==
''(gleich)''
| 4 == 9
| false
|-
| !=
''(ungleich)''
| 4 != 8
| true
|-
| &&
''(logisches UND)''
| false && true
| false, es wird erst der linke Ausdruck ausgewertet. Wenn die Auswertung false ergibt, wird der rechte Ausdruck nicht mehr geprüft, da das Ergebnis nicht mehr true werden kann.
|-
| <nowiki>||</nowiki>
''(logisches ODER)''
| true <nowiki>||</nowiki> false
| true, es wird erst der linke Ausdruck ausgewertet. Wenn die Auswertung true ergibt, wird der rechte Ausdruck nicht mehr geprüft, da das Ergebnis nicht mehr false werden kann.
|-
| <, <=, >, >=, <>
| 1 < 3 ''(hier exempalrisch nur eins)''
| true
|}

== Bitoperatoren ==
{| border="2" cellspacing="0" cellpadding="4" width="80%" rules="all" style="margin:1em 1em 1em 0; border:solid 1px #AAAAAA; border-collapse:collapse; background-color:#F9F9F9; font-size:95%; empty-cells:show;"
! style="background-color:#ABCDEF;" | Operator
! style="background-color:#ABCDEF;" | Beschreibung
! style="background-color:#ABCDEF;" | Erklärung
|-
| &
| AND
| Wie das logische UND, jedoch werden auf jeden Fall beide Seiten ausgewertet.
|-
| <nowiki>|</nowiki>
| OR
| Wie das logische ODER, jedoch werden auf jeden Fall beide Seiten ausgewertet.
|-
| ^
| XOR
| XOR halt.
|-
| ~
| NOT
| Negation des Wertes.
|}

== Konstanten ==
* In Java werden Konstanten mit dem Schlüsselwort '''final''' bezeichnet. In Java gibt es die Konvention Konstanten komplett groß zu schreiben:

final double PI = 3.14;

== Zuweisungen und Initialisierungen ==
Wenn man eine Variable erstellt und sie mit Werten füllen will, wird man auf folgende Syntax stoßen:

''Datentyp'' Variablenname = ''Initialisierungswert'';

Es gibt zwei Möglichkeiten diese Aktion durchzuführen:
* lange Variante:
int zahl;
zahl = 23;

* kurze Variante:
int zahl = 23;

== if-Anweisung ==
* Die einfachste Variante:

if (condition) {
''Anweisungen;''
}

* Zusätlich hat diese Variante einen alternativen Anweisungsblock. Wenn ''condition'' nicht erfüllt gehe in den ''else''-Zweig und führe dort die Anweisungen aus.

if (condition) {
''Anweisungen;''
} else {
''Anweisungen;''
}

* Natürlich lassen sich beide Varianten schachteln. Man kann also auf zwei Bedingungen prüfen und bei nicht Eintreffen in den ''else''-Zweig gehen.

if (condition) {
''Anweisungen;''
} else if (condition) {
''Anweisungen;''
} else {
''Anweisungen;''
}

= for-Schleife =
* Um über Array's zu wandern bietet sich die for-Schleife an. Als erstes in der Klammer muß eine Laufvariable deklariert und mit einem Wert initialisiert werden (hier int i= 0). Danach muß eine Bedingung erfüllen, um festzulegen bis wann die Schleife ausgeführt wird (i < 10). Als letztes muß die Laufvariable verändert werden, so daß irgendwann der Abbruch eintritt (i++).

for (int i = 0; i < 10; i++) {

''Anweisungen;''

}

== while-Schleife ==
* Die while-Schleife wird meistens dafür benutzt, Anweisungen auszuführen bis irgendetwas eintrifft (z.B. EOF -End Of File). Für Arrays sollte man die for-Schleife nehmen. Die while-Schleife lässt sich auch als for-Schleife schreiben.

while (condition) {
''Anweisungen;''
}

== switch-case ==
* Wenn man verschiedene Werte abfangen möchte, wie zum Beispiel verschiedene Zahlen (bei einem Menü). Gehen wir mal davon aus, daß wir drei Menüeinträge haben:
# ''1''
# ''2''
# ''0''
''1'' gibt die Zahl '''1''', ''2'' gibt die Zahl '''2''' aus und ''0'' beendet das Programm, dann ist key zum Beispiel ein '''int''' und '''value''' würde den einzelnen Menüpunkten entsprechen. Das ''break'' bewirkt ein raussprigen aus dem switch-Konstrukt. Würde man das ''break'' weglassen, würden sämtliche Anweisungen die direkt darunter folgen, ausgeführt werden.

switch (key) {
case value: {
''Anweisungen;''
break;
}
default: {
''Anweisungen;''
break;
}
}

== Grundgerüst ==

Da der Programmierer vom Kopieren lebt, schreibt er einmal eine Schablone und benutzt sie immer wieder, frei nach dem Motto: Man muß das Rad nicht zweimal erfinden.

So sieht zum Beispiel ein simples Javaprogramm ohne Handlung aus:

public class Klassenname {

/**
* @param args
*/
public static void main(String[] args) {
// TODO Anweisungen

}
}

'''Erläuterungen:'''
@param ist für das Dokumentationssystem Javadoc, wird im Javakurs vielleicht angesprochen, sollte aber erstmal zweitrangig sein. Dennoch ist Dokumentation wichtiger als der eigentliche Code und deshalb hier erwähnt.

== Funktion (Methoden) ==
In Java programmiert man meistens Objektorientiert, es sei denn man belegt Info2. Funktionen heißen bei Java Methoden und Methoden sind Objekten zugeordnet, es sei denn man programmiert nicht Objektorientiert.
Eine Methode hat immer folgenden Aufbau:

Spezialoption ''Veröffentlichungsart'' '''Rückgabewert''' Funktionsname '''(''' Parametertyp ''Parametername'' ''')''' {

Methodenrumpf_mit_Anweisungen;

}

Spezialoption:
* static
* final

''Veröffentlichungsart'':
* public
* protected
* private

'''Rückgabewert''':
* sämtliche oben aufgeführte Datentypen
* eigene Datentypen

Funktionsname:
* einen für die Funktion bezeichnenden Namen aus Buchstaben, Zahlen und dem Underscore ( ''_'' )
* darf nicht mit eine Zahl beginnen

Parametertyp:
* wie '''Rückgabewert''', siehe oben

''Parametername'':
* wie Funtionsname, siehe oben

== Ausgabe ==
* Um Fehler finden zu können oder Ausgaben auf der Konsole zu machen, gibt es in Java ''print''-Funktionen:

System.out.print("Irgend ein String.");

Gibt ''Irgend ein String.'' auf der Konsole aus ohne einen Zeilenumbruch.

System.out.println("Noch ein String.");

Gibt ''Noch ein String.'' auf der Konsole aus allerdings diesmal mit einem Zeilenumbruch.

Javakurs2006/Java Kurzreferenz

2006-04-05T06:25:25Z

130.149.17.40: /* Kommentare */ Vereinfachung

Hier befindet sich eine kleine '''Referenz für Java''' speziell für den Javakurs der Freitagsrunde.

== Kommentare ==
Ein '''Kommentar''' ist ein Abschnitt des Java-Codes, der vom Java-Compiler ignoriert wird. Man kann in ein Kommentar also schreiben was man will. Kommentare sind nützlich, um den Quellcode zu dokumentieren.

In Java gibt es zwei Arten von Kommentaren:

===Kommentare über eine Zeile===

// Diese ganze Zeile wird vom Compiler ignoriert.
int x= 5; // Dieser Kommentar beginnt mit »//«. Alles davor wird vom Compiler nicht ignoriert.

===Kommentare über mehrere Zeilen===

/* Dieser
Kommentar
erstreckt
sich
über
mehrere
Zeilen.
*/

Zum Vergleich: in Opal werden Kommentare mit -- eingeführt.

== Datentypen (Variablen) ==
{| border="2" cellspacing="0" cellpadding="4" width="80%" rules="all" style="margin:1em 1em 1em 0; border:solid 1px #AAAAAA; border-collapse:collapse; background-color:#F9F9F9; font-size:95%; empty-cells:show;"
! style="background-color:#ABCDEF;" | Typ
! style="background-color:#ABCDEF;" | Speicherbedarf
! style="background-color:#ABCDEF;" | Bereich
|-
|int
|4 Byte
| -2.147.483.648 bis 2.147.483.647
|-
|short
|2 Byte
| -32.768 bis 32.787
|-
|long
|8 Byte
| -9.223.372.036.854.775.808L bis 9.223.372.036.854.775.807L
|-
|byte
|1 Byte
| -128 bis 127
|-
|float
|4 Byte
| +/-3,40282347E+38F
|-
|double
|8 Byte
| +/-1,79769313486231570E+308
|}

== Boolsche Operatoren ==
{| border="2" cellspacing="0" cellpadding="4" width="80%" rules="all" style="margin:1em 1em 1em 0; border:solid 1px #AAAAAA; border-collapse:collapse; background-color:#F9F9F9; font-size:95%; empty-cells:show;"
! style="background-color:#ABCDEF;" | Operator
! style="background-color:#ABCDEF;" | Beispiel
! style="background-color:#ABCDEF;" | Ergebnis des Beispiels
|-
| ==
''(gleich)''
| 4 == 9
| false
|-
| !=
''(ungleich)''
| 4 != 8
| true
|-
| &&
''(logisches UND)''
| false && true
| false, es wird erst der linke Ausdruck ausgewertet. Wenn die Auswertung false ergibt, wird der rechte Ausdruck nicht mehr geprüft, da das Ergebnis nicht mehr true werden kann.
|-
| <nowiki>||</nowiki>
''(logisches ODER)''
| true <nowiki>||</nowiki> false
| true, es wird erst der linke Ausdruck ausgewertet. Wenn die Auswertung true ergibt, wird der rechte Ausdruck nicht mehr geprüft, da das Ergebnis nicht mehr false werden kann.
|-
| <, <=, >, >=, <>
| 1 < 3 ''(hier exempalrisch nur eins)''
| true
|}

== Bitoperatoren ==
{| border="2" cellspacing="0" cellpadding="4" width="80%" rules="all" style="margin:1em 1em 1em 0; border:solid 1px #AAAAAA; border-collapse:collapse; background-color:#F9F9F9; font-size:95%; empty-cells:show;"
! style="background-color:#ABCDEF;" | Operator
! style="background-color:#ABCDEF;" | Beschreibung
! style="background-color:#ABCDEF;" | Erklärung
|-
| &
| AND
| Wie das logische UND, jedoch werden auf jeden Fall beide Seiten ausgewertet.
|-
| <nowiki>|</nowiki>
| OR
| Wie das logische ODER, jedoch werden auf jeden Fall beide Seiten ausgewertet.
|-
| ^
| XOR
| XOR halt.
|-
| ~
| NOT
| Negation des Wertes.
|}

== Konstanten ==
* In Java werden Konstanten mit dem Schlüsselwort '''final''' bezeichnet. In Java gibt es die Konvention Konstanten komplett groß zu schreiben:

final double PI = 3.14;

== Zuweisungen und Initialisierungen ==
Wenn man eine Variable erstellt und sie mit Werten füllen will, wird man auf folgende Syntax stoßen:

''Datentyp'' Variablenname = ''Initialisierungswert'';

Es gibt zwei Möglichkeiten diese Aktion durchzuführen:
* lange Variante:
int zahl;
zahl = 23;

* kurze Variante:
int zahl = 23;

== if-Anweisung ==
* Die einfachste Variante:

if (condition) {
''Anweisungen;''
}

* Zusätlich hat diese Variante einen alternativen Anweisungsblock. Wenn ''condition'' nicht erfüllt gehe in den ''else''-Zweig und führe dort die Anweisungen aus.

if (condition) {
''Anweisungen;''
} else {
''Anweisungen;''
}

* Natürlich lassen sich beide Varianten schachteln. Man kann also auf zwei Bedingungen prüfen und bei nicht Eintreffen in den ''else''-Zweig gehen.

if (condition) {
''Anweisungen;''
} else if (condition) {
''Anweisungen;''
} else {
''Anweisungen;''
}

= for-Schleife =
* Um über Array's zu wandern bietet sich die for-Schleife an. Als erstes in der Klammer muß eine Laufvariable deklariert und mit einem Wert initialisiert werden (hier int i= 0). Danach muß eine Bedingung erfüllen, um festzulegen bis wann die Schleife ausgeführt wird (i < 10). Als letztes muß die Laufvariable verändert werden, so daß irgendwann der Abbruch eintritt (i++).

for (int i = 0; i < 10; i++) {

''Anweisungen;''

}

== while-Schleife ==
* Die while-Schleife wird meistens dafür benutzt, Anweisungen auszuführen bis irgendetwas eintrifft (EOF -End Of File). Für Array's sollte man die for-Schleife nehmen. Die while-Schleife läßt isch auch als for-Schleife schreiben.

while (condition) {
''Anweisungen;''
}

== switch-case ==
* Wenn man verschiedene Werte abfangen möchte, wie zum Beispiel verschiedene Zahlen (bei einem Menü). Gehen wir mal davon aus, daß wir drei Menüeinträge haben:
# ''1''
# ''2''
# ''0''
''1'' gibt die Zahl '''1''', ''2'' gibt die Zahl '''2''' aus und ''0'' beendet das Programm, dann ist key zum Beispiel ein '''int''' und '''value''' würde den einzelnen Menüpunkten entsprechen. Das ''break'' bewirkt ein raussprigen aus dem switch-Konstrukt. Würde man das ''break'' weglassen, würden sämtliche Anweisungen die direkt darunter folgen, ausgeführt werden.

switch (key) {
case value: {
''Anweisungen;''
break;
}
default: {
''Anweisungen;''
break;
}
}

== Grundgerüst ==

Da der Programmierer vom Kopieren lebt, schreibt er einmal eine Schablone und benutzt sie immer wieder, frei nach dem Motto: Man muß das Rad nicht zweimal erfinden.

So sieht zum Beispiel ein simples Javaprogramm ohne Handlung aus:

public class Klassenname {

/**
* @param args
*/
public static void main(String[] args) {
// TODO Anweisungen

}
}

'''Erläuterungen:'''
@param ist für das Dokumentationssystem Javadoc, wird im Javakurs vielleicht angesprochen, sollte aber erstmal zweitrangig sein. Dennoch ist Dokumentation wichtiger als der eigentliche Code und deshalb hier erwähnt.

== Funktion (Methoden) ==
In Java programmiert man meistens Objektorientiert, es sei denn man belegt Info2. Funktionen heißen bei Java Methoden und Methoden sind Objekten zugeordnet, es sei denn man programmiert nicht Objektorientiert.
Eine Methode hat immer folgenden Aufbau:

Spezialoption ''Veröffentlichungsart'' '''Rückgabewert''' Funktionsname '''(''' Parametertyp ''Parametername'' ''')''' {

Methodenrumpf_mit_Anweisungen;

}

Spezialoption:
* static
* final

''Veröffentlichungsart'':
* public
* protected
* private

'''Rückgabewert''':
* sämtliche oben aufgeführte Datentypen
* eigene Datentypen

Funktionsname:
* einen für die Funktion bezeichnenden Namen aus Buchstaben, Zahlen und dem Underscore ( ''_'' )
* darf nicht mit eine Zahl beginnen

Parametertyp:
* wie '''Rückgabewert''', siehe oben

''Parametername'':
* wie Funtionsname, siehe oben

== Ausgabe ==
* Um Fehler finden zu können oder Ausgaben auf der Konsole zu machen, gibt es in Java ''print''-Funktionen:

System.out.print("Irgend ein String.");

Gibt ''Irgend ein String.'' auf der Konsole aus ohne einen Zeilenumbruch.

System.out.println("Noch ein String.");

Gibt ''Noch ein String.'' auf der Konsole aus allerdings diesmal mit einem Zeilenumbruch.

Javakurs2006/Java Kurzreferenz

2006-04-05T06:17:14Z

130.149.17.40: wikifikation

Hier befindet sich eine kleine '''Referenz für Java''' speziell für den Javakurs der Freitagsrunde.

== Kommentare ==
Ein wichtiges Instrumentarium in Java (natürlich auch in anderen Sprachen, wie z.B. OPAL [''-- Kommantar'']) sind Kommentare. In Java gibt es zwei Arten von Kommentaren:
* Kommentare über eine Zeile

//dies ist ein Kommentar

* Kommentare über mehrere Zeilen

/* dies
sind
mehrere
Kommentare
über
mehrere
Zeilen
*/

== Datentypen (Variablen) ==
{| border="2" cellspacing="0" cellpadding="4" width="80%" rules="all" style="margin:1em 1em 1em 0; border:solid 1px #AAAAAA; border-collapse:collapse; background-color:#F9F9F9; font-size:95%; empty-cells:show;"
! style="background-color:#ABCDEF;" | Typ
! style="background-color:#ABCDEF;" | Speicherbedarf
! style="background-color:#ABCDEF;" | Bereich
|-
|int
|4 Byte
| -2.147.483.648 bis 2.147.483.647
|-
|short
|2 Byte
| -32.768 bis 32.787
|-
|long
|8 Byte
| -9.223.372.036.854.775.808L bis 9.223.372.036.854.775.807L
|-
|byte
|1 Byte
| -128 bis 127
|-
|float
|4 Byte
| +/-3,40282347E+38F
|-
|double
|8 Byte
| +/-1,79769313486231570E+308
|}

== Boolsche Operatoren ==
{| border="2" cellspacing="0" cellpadding="4" width="80%" rules="all" style="margin:1em 1em 1em 0; border:solid 1px #AAAAAA; border-collapse:collapse; background-color:#F9F9F9; font-size:95%; empty-cells:show;"
! style="background-color:#ABCDEF;" | Operator
! style="background-color:#ABCDEF;" | Beispiel
! style="background-color:#ABCDEF;" | Ergebnis des Beispiels
|-
| ==
''(gleich)''
| 4 == 9
| false
|-
| !=
''(ungleich)''
| 4 != 8
| true
|-
| &&
''(logisches UND)''
| false && true
| false, es wird erst der linke Ausdruck ausgewertet. Wenn die Auswertung false ergibt, wird der rechte Ausdruck nicht mehr geprüft, da das Ergebnis nicht mehr true werden kann.
|-
| <nowiki>||</nowiki>
''(logisches ODER)''
| true <nowiki>||</nowiki> false
| true, es wird erst der linke Ausdruck ausgewertet. Wenn die Auswertung true ergibt, wird der rechte Ausdruck nicht mehr geprüft, da das Ergebnis nicht mehr false werden kann.
|-
| <, <=, >, >=, <>
| 1 < 3 ''(hier exempalrisch nur eins)''
| true
|}

== Bitoperatoren ==
{| border="2" cellspacing="0" cellpadding="4" width="80%" rules="all" style="margin:1em 1em 1em 0; border:solid 1px #AAAAAA; border-collapse:collapse; background-color:#F9F9F9; font-size:95%; empty-cells:show;"
! style="background-color:#ABCDEF;" | Operator
! style="background-color:#ABCDEF;" | Beschreibung
! style="background-color:#ABCDEF;" | Erklärung
|-
| &
| AND
| Wie das logische UND, jedoch werden auf jeden Fall beide Seiten ausgewertet.
|-
| <nowiki>|</nowiki>
| OR
| Wie das logische ODER, jedoch werden auf jeden Fall beide Seiten ausgewertet.
|-
| ^
| XOR
| XOR halt.
|-
| ~
| NOT
| Negation des Wertes.
|}

== Konstanten ==
* In Java werden Konstanten mit dem Schlüsselwort '''final''' bezeichnet. In Java gibt es die Konvention Konstanten komplett groß zu schreiben:

final double PI = 3.14;

== Zuweisungen und Initialisierungen ==
Wenn man eine Variable erstellt und sie mit Werten füllen will, wird man auf folgende Syntax stoßen:

''Datentyp'' Variablenname = ''Initialisierungswert'';

Es gibt zwei Möglichkeiten diese Aktion durchzuführen:
* lange Variante:
int zahl;
zahl = 23;

* kurze Variante:
int zahl = 23;

== if-Anweisung ==
* Die einfachste Variante:

if (condition) {
''Anweisungen;''
}

* Zusätlich hat diese Variante einen alternativen Anweisungsblock. Wenn ''condition'' nicht erfüllt gehe in den ''else''-Zweig und führe dort die Anweisungen aus.

if (condition) {
''Anweisungen;''
} else {
''Anweisungen;''
}

* Natürlich lassen sich beide Varianten schachteln. Man kann also auf zwei Bedingungen prüfen und bei nicht Eintreffen in den ''else''-Zweig gehen.

if (condition) {
''Anweisungen;''
} else if (condition) {
''Anweisungen;''
} else {
''Anweisungen;''
}

= for-Schleife =
* Um über Array's zu wandern bietet sich die for-Schleife an. Als erstes in der Klammer muß eine Laufvariable deklariert und mit einem Wert initialisiert werden (hier int i= 0). Danach muß eine Bedingung erfüllen, um festzulegen bis wann die Schleife ausgeführt wird (i < 10). Als letztes muß die Laufvariable verändert werden, so daß irgendwann der Abbruch eintritt (i++).

for (int i = 0; i < 10; i++) {

''Anweisungen;''

}

== while-Schleife ==
* Die while-Schleife wird meistens dafür benutzt, Anweisungen auszuführen bis irgendetwas eintrifft (EOF -End Of File). Für Array's sollte man die for-Schleife nehmen. Die while-Schleife läßt isch auch als for-Schleife schreiben.

while (condition) {
''Anweisungen;''
}

== switch-case ==
* Wenn man verschiedene Werte abfangen möchte, wie zum Beispiel verschiedene Zahlen (bei einem Menü). Gehen wir mal davon aus, daß wir drei Menüeinträge haben:
# ''1''
# ''2''
# ''0''
''1'' gibt die Zahl '''1''', ''2'' gibt die Zahl '''2''' aus und ''0'' beendet das Programm, dann ist key zum Beispiel ein '''int''' und '''value''' würde den einzelnen Menüpunkten entsprechen. Das ''break'' bewirkt ein raussprigen aus dem switch-Konstrukt. Würde man das ''break'' weglassen, würden sämtliche Anweisungen die direkt darunter folgen, ausgeführt werden.

switch (key) {
case value: {
''Anweisungen;''
break;
}
default: {
''Anweisungen;''
break;
}
}

== Grundgerüst ==

Da der Programmierer vom Kopieren lebt, schreibt er einmal eine Schablone und benutzt sie immer wieder, frei nach dem Motto: Man muß das Rad nicht zweimal erfinden.

So sieht zum Beispiel ein simples Javaprogramm ohne Handlung aus:

public class Klassenname {

/**
* @param args
*/
public static void main(String[] args) {
// TODO Anweisungen

}
}

'''Erläuterungen:'''
@param ist für das Dokumentationssystem Javadoc, wird im Javakurs vielleicht angesprochen, sollte aber erstmal zweitrangig sein. Dennoch ist Dokumentation wichtiger als der eigentliche Code und deshalb hier erwähnt.

== Funktion (Methoden) ==
In Java programmiert man meistens Objektorientiert, es sei denn man belegt Info2. Funktionen heißen bei Java Methoden und Methoden sind Objekten zugeordnet, es sei denn man programmiert nicht Objektorientiert.
Eine Methode hat immer folgenden Aufbau:

Spezialoption ''Veröffentlichungsart'' '''Rückgabewert''' Funktionsname '''(''' Parametertyp ''Parametername'' ''')''' {

Methodenrumpf_mit_Anweisungen;

}

Spezialoption:
* static
* final

''Veröffentlichungsart'':
* public
* protected
* private

'''Rückgabewert''':
* sämtliche oben aufgeführte Datentypen
* eigene Datentypen

Funktionsname:
* einen für die Funktion bezeichnenden Namen aus Buchstaben, Zahlen und dem Underscore ( ''_'' )
* darf nicht mit eine Zahl beginnen

Parametertyp:
* wie '''Rückgabewert''', siehe oben

''Parametername'':
* wie Funtionsname, siehe oben

== Ausgabe ==
* Um Fehler finden zu können oder Ausgaben auf der Konsole zu machen, gibt es in Java ''print''-Funktionen:

System.out.print("Irgend ein String.");

Gibt ''Irgend ein String.'' auf der Konsole aus ohne einen Zeilenumbruch.

System.out.println("Noch ein String.");

Gibt ''Noch ein String.'' auf der Konsole aus allerdings diesmal mit einem Zeilenumbruch.

Javakurs2006/Tag 2/Vorlesung 2

2006-04-04T11:54:47Z

130.149.17.40: /* Die Methode equals(Object o) */

==Kleine Wiederholung==

Klassen beinhalten zusammengehörige Daten und Methoden. Mit new erzeugt man Instanzen dieser Klassen. Jede Instanz kann eigene Werte der zugehörigen Daten enthalten. Ein Teil der im Quellcode dieses Textes enthaltenen Kommentare erklären Syntax und hätten in einem "echten" Programm nichts zu suchen.

//file: Apfel.java
class Apfel {
String farbe;
int gewicht; //in Gramm

Apfel (String farb, int gew) { //Konstuktor
farbe = farb; //eigentlich this.farbe =farb, ist aber unnötig
gewicht = gew;
}

void essen() { //eine Methode
gewicht = 0;
}
}

//file: Beispiel.java
public Beispiel {
public static void main( String args[] ) {
Apfel boskop1 = new Apfel("rot", 175);
Apfel boskop2 = new Apfel("grün", 180);

System.out.println("boskop1 (" +
boskop1.farbe + "): " + boskop1.gewicht + " gramm");
System.out.println("boskop2 (" +
boskop2.farbe + "): " + boskop2.gewicht + "gramm");
}
}

==Vererbung==

In objektorientierten Programmiersprachen gibt es ein Konzept, dass sich Vererbung nennt. Eine Klasse erbt dann das Verhalten (also die Methoden) und auch die Daten von einer anderen Klasse. In Java benutzt man zum Vererben das Schlüsselwort extends.

//File: Obst.java
class Obst {
String farbe;
int gewicht; //in Gramm

void essen() {
gewicht = 0;
}
}

//File: Apfel.java
class Apfel extends Obst {
String geerntetIn;

void schaelen() {
gewicht = gewicht - 10;
}
}

Die Klasse Apfel im Beispiel hat alle Methoden und Daten von der Klasse Obst geerbt. Das heißt Instanzen dieser Klasse besitzen eine Farbe, ein Gewicht und man kann sie essen.

Wer mehr über Objektorientierung und Vererbung erfahren möchte, kann entweder eins der unzähligen verfügbaren Bücher zu dem Thema zur Hand nehmen. Alternativ könnte man auch diesen link (http://java.sun.com/docs/books/tutorial/java/concepts/index.html) verfolgen.

==Die Klasse Object==

In Java gibt es eine Klasse Object, von der jede andere Klasse abgeleitet ist. Wenn man kein extends hinschreibt, wird vom Compiler sozusagen das "extends Object" ergänzt. Dies geschieht intern, also ohne Veränderung in eurem Quellcode.

Einige Methoden von Object sind für uns sehr nützlich, weshalb sie hier kurz vorgestellt werden sollen. Doch eins noch zum Wort Objekt: Die Bezeichnung Objekt wird oftmals sowohl für Klassen als auch für Instanzen von Klassen benutzt, deshalb immer schauen welche Bedeutung wohl gerade gemeint ist.

Im folgenden wird hier Objekt in der Bedeutung von Instanz benutzt und Object, wenn die besondere Klasse Object gemeint ist.

===Die Methode toString()===

Nun aber zu den genannten nützlichen Mehtoden: Die Methode toString() liefert einen String, der die Instanz beschreibt. Doch woher soll die Methode (die ja in Object angelegt wurde) wissen, wie man unsere spezielle Instanz treffend in einem String beschreibt?

Dazu kann man die Methode überschreiben. Man macht das, indem man sie einfach in der eigenen Klasse noch einmal definiert.

//File: Apfel.java
class Apfel extends Obst {
String geerntetIn;

void schaelen() {
gewicht = gewicht - 10;
}

String toString() {
String description = "Ein Apfel, geerntet in " + geerntetIn;
return description;
}
}

Ruft man nun auf einer Instanz von Apfel toString auf, so wird die in Apfel definierte Version benutzt. Die Methode toString() ist unter anderem deshalb so wichtig, weil sie von System.out.println() benutzt wird, um Instanzen beliebiger Nachfahren von Object auf der Konsole auszugeben. Die Methode printMe() aus der vorhergehenden Übung hatte die gleiche Funktion. Nur arbeitet println() mit toString(), weshalb es sinnvoll wäre printMe() in toString() umzubenennen.

===Die Methode equals(Object o)===

Eine weitere wichtige Methode von Object ist equals(Object o). Hiermit kann, wie der Name schon sagt die Gleichheit zweier Objekte festgestellt werden. Nun wird sich vielleicht der ein oder andere fragen, warum man nicht den Vergleichsoperator == benutzt, sondern eine eigene Methode dafür schreibt. Warum das so ist, soll an einem Codebeispiel verdeutlicht werden.

public static void main(String []args) {
Apfel apfel1 = new Apfel();
apfel1.farbe = "grün";
apfel1.geerntetIn = "Berlin";
apfel1.gewicht = 215;

Apfel apfel2 = new Apfel();
apfel2.farbe = "grün";
apfel2.geerntetIn = "Brandenburg";
apfel2.gewicht = 215;

Apfel apfel3 = apfel2;
}

Der Operator == gibt genau dann true zurück, wenn die Werte der beiden verglichenen Dinge identisch sind. Bei eingebauten Datentypen (int, double) verhält er sich wie erwartet. Der Wert eines Objektes hingegen ist die Identität des Objektes, und nicht sein Inhalt. Deshalb würde apfel1 == apfel2 false zurückgeben, weil es sich um zwei verschiedene Objekte handelt. Wir hätten aber gern eine Methode, die uns sagt, dass diese Äpfel insofern gleich sind, dass sie die gleichen Eigenschaften besitzen. Dabei ist zu beachten, dass wir für die Gleichheit zweier Äpfel hier nur das Gewicht und die Farbe heranziehen.Genau dies sollte equals realisieren.

class Apfel extends Obst {
String geerntetIn;

void schaelen() {
gewicht = gewicht - 10;
}

String toString() {
String description = "Ein Apfel, geerntet in " + geerntetIn;
return description;
}

boolean equals(Object o) {
Apfel andererApfel = (Apfel)o;
return farbe.equals(andererApfel.farbe) &&
gewicht == andererApfel.gewicht;
}
}

Im Beispiel für equals gibt es gleich zwei Dinge, die einer weiteren Erklärung bedürfen: In der ersten Zeile machen wir aus der Intanz von Object, mit dem wir vergleichen einen Apfel. Diesen Vorgang nennt man casten. Das Programm wird an dieser Stelle mit einer entsprechenden Fehlermeldung beendet, wenn der Parameter o kein Apfel ist. Das ist zwar nicht schön, macht aber trotzdem Sinn, da eine Gleichheit zwischen Äpfeln und beliebigen Objekten nicht zwangsläufig definiert ist. Dies ist zugegebenermaßen noch nicht ganz zufriedenstellend, da das Programm einfach beendet würde, wenn Apfel mit Autos zu vergleichen, obwohl man sicher sagen könnte, dass die beiden unterschiedlich sind. Wer hierzu noch etwas mehr lesen möchte, kann sich hier (http://www.galileocomputing.de/openbook/javainsel3/javainsel_030003.htm#Rxxjavainsel_030003281GleichheitvonObjektenunddieMethodeequals) vertiefen.

Die zweite Sache, die auffällt: das Gewicht wird mit == verglichen, warum nicht auch mit equals? Die Antwort darauf ist eigentlich recht einfach: gewicht ist vom Typ int, der ein primitiver Datentyp ist. Damit erbt er nicht von Object, und bietet demnach auch keine Methode equals an. Wie oben schon erwähnt liefert == bei primitiven Datentypen ja auch das gewünschte Ergebnis.

Eine Anmerkung hierzu ist noch wichtig: Die oben vorgestellte Implementierung von equals funktioniert für unsere Zwecke. Dennoch ist sie unsauber und erfüllt nicht die Anforderungen, die sun in seiner Klassenbibliothek an equals stellt. Dies genauer zu erläutern würde den Rahmen unseres Kurses sprengen, näheres dazu findet man unter anderem im Link zwei Absätze höher. Die genauen Anforderungen an die Implementierung der Methode equals sind zu finden in der Java API Referenz (http://java.sun.com/j2se/1.4.2/docs/api/java/lang/Object.html).

==Comparable==

Manchmal reicht es nicht aus, zu wissen zwei Objekte gleich sind. Oft wollen wir Objekte ordnen, wozu wir eine Funktion brauchen die uns mitteilt welches von zwei Objekten "größer" ist. Eine solche Funktion ist compareTo(Object o). Im Gegensatz zu equals und toString ist sie allerdings keine Methode von Object, da es Klassen gibt, deren Objekte man nicht ordnen kann. Ein Beispiel hierfür wären Farbtöne, für die es schwer fällt eine natürliche Ordnung zu finden. Nun könnten wir für unsere eigenen Klassen, wo das Ordnen Sinn macht einfach ein compareTo implementieren. Würden wir dies einfach so tun könnten wir allerdings nicht einen Algorithmus benutzen, den jemand anderes zum Ordnen seiner eigenen Klasse, die compareTo implementiert geschrieben hat:

//File: MyClass.java
class MyClass {
...
compareTo(MyClass o) {
...
}
...
}

//File: SomeonesClass.java
class SomeonesClass {
...
compareTo(SomeonesClass o) {
...
}
...
}

//File Utility.java
class Utility {
static sort(SomeonesClass daten[]) {
//sortiere daten mittels compareTo
}
}

Hier kann man kein array vom Typ MyClass[] als parameter von sort übergeben, da es sich um zwei verschiedene Typen handelt. Um dieses Manko zu umgehen gibt es in Java Interfaces. Sie stellen eine Vereinbarung darüber dar, welche Methoden eine Klasse anbietet. Im Gegensatz zur Vererbung gibt es aber hier beim Interface noch keine Vorgabe, wie diese Methoden funktionieren. Das Interface schreibt nur die Namen, Art der Parameter und des Rückgabewertes von Methoden vor. Comparable ist ein solches Interface, dass schon in der Java API vorgegeben ist. Es schreibt vor, dass Klassen die dieses Interface implementieren die Methode int compareTo(Object o) anbieten müssen.

Modifizieren wir also unser Beispiel so, dass wir das Interface Comparable nutzen.

//File: MyClass.java
class MyClass implements Comparable{
...
compareTo(Object o) {
MyClass parameter = (MyClass)o;
...
}
...
}

//File: SomeonesClass.java
class SomeonesClass implements Comparable{
...
compareTo(Object o) {
SomeonesClass parameter = (SomeonesClass)o;
...
}
...
}

//File Utility.java
class Utility {
static sort(Comparable daten[]) {
//sortiere daten mittels compareTo
}
}

Nun kann die Methode sort beliebige arrays übergeben bekommen, deren Inhalt das Interface Comparable implementiert. Darüber wird dieser Mehtode zugesichert, dass jedes Element dieses arrays über die Methode compareTo verfügt und somit sich mit anderen Elementen des arrays vergleichen lässt.

Noch ein paar Worte zum compareTo selbst: Diese Methode liefert uns als Rückgabewert eine ganze Zahl. Ist diese Zahl kleiner als 0, so ist die Instanz, auf der sie aufgerufen wurde kleiner als der übergebene Parameter (this < o). Ist der Rückgabewert genau 0, so ist this gleich o. Letzlich ist this größer als o, wenn der Rückgabewert von compareTo größer als 0 ist. Auch an die Methode compareTo gibt es in der API Referenz definierte Andorderungen (http://java.sun.com/j2se/1.4.2/docs/api/java/lang/Comparable.html) , die wir im Rahmen unserer Veranstaltung aber außen vor lassen wollen.

==Java API - Javas Klassenbibliothek==

Ein großer Vorteil von Java gegenüber anderen Programmiersprachen besteht darin, dass es eine Vielzahl vereinheitlichter und schon mitgelieferter Klassen und Interfaces gibt. Die Sammlung dieser Klassen und Interfaces nennt man Java API. Es gibt auf der Website von Sun(java.sun.com) eine sehr umfassende Dokumentation dieser API(http://java.sun.com/j2se/1.4.2/docs/api/), die allerdings nicht immer einfach zu bedienen ist. Wenn man weiß, nach welcher Klasse man sucht findet man meist recht schnell die gewünschten Informationen. Hat man aber nur eine vage Idee, was die Klasse tun soll muss man meist noch andere Quellen nutzen, um an den Namen der gesuchten Klasse heranzukommen. Hierzu bieten sich natürlich Suchmaschinen wie google an.

Im Folgenden wollen wir einige besonders Häufig verwendete Module und Konzepte der Java API vorstellen. Wie man ein solches Modul in eigenen Programmen verwendet, werden wir im ersten vorgestellten Modul etwas näher beleuchten.

===Math===

Das Modul Math bietet, wenig überraschend, alle möglichen Methoden und Konstanten die man für mathematische Berechnungen brauchen könnte. Einige Konstanten sind zum Beispiel

public static final double E;
public static final double PI;

Diese beiden Konstanten sind jeweils mit drei zusätzlichen Schlüsselwörtern gekennzeichnet, die hier zumindest grob erklärt werden sollen.

public bedeutet, dass die entsprechende Variable oder Methode auch außerhalb der definierenden Klasse und außerhalb von Math benutzt werden kann.

Von Daten, die satic definiert sind hat nicht jede Instanz eine eigene Ausprägung, sondern alle Instanzen der Klasse teilen sich diese Variable.
Mehtoden die static definiert sind, brauchen keine Instanz der Klasse um aufgerufen zu werden. Demnach kennen sie allerdings auch this nicht und können daher nicht auf Daten einer Instanz der Klasse arbeiten.

Das Schlüsselwort final an einer Variable macht diese zur Konstante. Das heißt sie wird einmal bei der Deklaration festgelegt und kann dann nicht mehr verändert werden.

Die einzelnen Methoden, die Math bietet sollen hier nicht im Detail besprochen werden, da sie recht einfach in der API-Dokumentation von Java zu finden sind. Dennoch soll anhand des Sinus ein Aufruf einer Methode aus Math hier gezeigt werden, um die nötige Syntax zu zeigen.

public static void main(String args[]) {
System.out.print( Math.sin(Math.PI / 2) );
}

Ausgabe: 0

Eine sehr nützliche Methode aus Math soll hier noch kurz vorgestellt werden, da man sie nicht unbedingt hier vermuten würde: Die Methode random liefert ohne Parameter zu erwarten eine Zufallszahl zwischen 0 und 1. Mit Hilfe dieser Methode kann man gleichverteilte und beliebige Zufallszahlen in den Bereichen von float und int erzeugen.

public static void main(String args[]) {
double random1 = Math.random(); //erzeugt eine Zahl im Bereich [0;1)
double random2 = Math.random() * 30 + 5; //erzeugt eine Zahl im Bereich [5;34)
int random3 = (int) (Math.random() * 13); //erzeugt eine natürliche Zahl im Bereich [0;12]
}

===Streams===

Ein weiteres nützliches Konzept, dass die Java API uns bietet sind Streams. Streams (zu deutsch: Datenströme) beschreiben Datenquellen oder Ziele, an die man Daten schicken kann. Dabei wird von der tatsächlichen Datenquelle oder vom tatsächlichen Ziel abstrahiert, um für alle "Sender" oder "Empfänger" von Daten die gleichen Mehtoden nutzen zu können. So können sich hinter einem Datenstrom beispielsweise eine Datei, die von der Tastatur kommenden Zeichen oder aber eine Netzwerkverbindung verbergen. Der Programmierer muss sich aber um diese Details, wenn er erstmal ein entsprechendes Datenstrom-Objekt erstellt hat keine Gedanken mehr machen, weil er ebend auf einem Datenstrom arbeitet und nicht auf einer bestimmten Datenquelle. Hier ein paar Beispiele, wie man verschiedene Datenströme erstellt. Dabei ist generell zwischen InputStream und OutputStream zu unterscheiden, wobei der erstere Daten von außen an unser Programm heranträgt und der zweite Daten von unserem Programm an einen Empfänger übermittelt

import java.io.*

//prints the ascii code for a specified number of keys pressed on the keyboard to the console
static void printAsciiCodes(int keysToPrint) {
InputStream keyboard = System.in; //get standard input stream (the keyboard)
for (int i = 0; i < keysToPrint; i++) {
int asciiCode = keyboard.read(); //wait for a key to be pressed
System.out.print(asciiCode + " "); //print it's ascii code
}
}

//prints the content of a file given by Name to the console bytewise
static void printFile(String fileName) {
InputStream file = new FileInputStream(fileName); //open a stream representing the file
int byteRead = file.read(); //read first byte from the file
while (byteRead != -1) { //while there is something to read
System.out.print(byteRead + " "); //print the byte we read at last
byteRead = file.read(); //read a new byte
}
}

Im Beispiel kann man schön sein, dass der Mechanismus zum lesen eines bytes bei beiden Datenströmen der gleiche ist. Lediglich in der Erstellung des Datenstromes gibt es je nach Quelle Unterschiede. Die Funktionsweise ist für Ausgabeströme recht ähnlich. Nähere Informationen dazu findet man in der API-Reference, wenn man nach den Klassen OutputStream und FileOutputStream sucht.

===BufferedReader===

Im letzten Abschnitt haben wir gesehen, wie leicht es ist mit Hilfe von Streams Bytes aus verschiedenen Quellen zu lesen. Oftmals wollen wir aber keine einzelnen Bytes lesen, sondern wissen dass unsere Datenquelle uns einen Text liefert. Da Text meist in Zeilen strukturiert ist, wäre es schön eine Funktion zu haben die Zeilenweise Strings aus unserem Stream liest. Auch hierfür bietet uns die Java Klassenbibiliothek bereits eine Lösung: den BufferedReader. Seine readLine Methode liest eine Zeile aus. Das Problem an dem BufferedReader ist, dass wir zu seiner Instantiierung einen Reader benötigen. Schauen wir in der API Dokumentation nach, welche Arten von Readern es gibt, so fällt der InputStreamReader auf. Schaut man sich diesen genauer an, so enthält er auch einen Konstruktor, der einen InputStream als Parameter akzeptiert.

Nun bleibt es unsere Aufgabe zuerst einen Datenstrom aus unserer Datenquelle zu erzeugen, dann darauf einen Reader zu konstruieren um am Schluß darauf einen BufferedReader zu setzen. Dieses Vorgehen wirkt zwar etwas klobig, doch es gibt in der Klassenbibliothek bisher (bis Java 1.4.2) keine bessere Lösung dafür. Es folgt ein kleines Beispiel, dass den Inhalt einer Textdatei zeilenweise auf der Konsole ausgibt.

import java.io.*;

static void printTextFile(String fileName) {
InputStream fileStream = new FileInputStream(fileName);
Reader reader = new InputStreamReader(fileStream); //wrap a Reader around the InputStream
BufferedReader lineReader = new BufferedReader(reader); //wrap a BufferedReader around the Reader
String line = lineReader.readLine();
while (line != null) { //if readLine returns null, file end is reached
System.out.println(line);
line = lineReader.readLine();
}
}

==Exceptions==

Versucht man die Programme aus den letzten beiden Abschnitten zu compilieren, so wird man feststellen dass sie nicht lauffähig sind. Mit der Tatsache, dass Streams so universell sind, handelt man sich natürlich auch alle möglichen Probleme der verschiedenen Medien, die ein Stream verstecken kann, ein. Um die Behandlung dessen zu vereinfachen und dem Programmierer die Chance zu geben an der richtigen Stelle auf Fehler zu reagieren gibt es Exceptions. An dieser Stelle soll es genügen zu erkennen, wann man von einer Methode erwarten muss, dass sie eine Exception auslöst und wie man damit umgeht.

Methoden, die eine Exception auslösen können müssen dies ihrer Umgebung mitteilen. Dies geschieht, mit dem Schlüsselwort throws gefolgt von einer kommaseparierten Liste aller Exceptions, die sie auslösen können.

public class InputStream {
...
public int read() throws IOException {
...
}
...
}

Bei den Klassen aus der Java Klassenbibliothek kann man der API-Reference entnehmen, welche Exceptions sie auslösen können. Jede mögliche Exception muss behandelt werden, dazu gibt es zwei Wege.Der erste funktioniert folgendermaßen: Man fasst den Teil einer Mehtode, der eine Exception auslösen kann in ein try-catch-Konstrukt ein. Wie dies aussieht soll gleich am Beispiel der Methode printTextFile gezeigt werden.

import java.io.*;

static void printTextFile(String fileName) {
InputStream fileStream = null;
try {
fileStream = new FileInputStream(fileName);
} catch (FileNotFoundException) {
System.out.println("The file " + fileName + " could not be found.");
return; //stop execution of method... cannot print from non existing file
}
Reader reader = new InputStreamReader(fileStream); //wrap a Reader around the InputStream
BufferedReader lineReader = new BufferedReader(reader); //wrap a BufferedReader around the Reader
try {
String line = lineReader.readLine();
while (line != null) { //if readLine returns null, file end is reached
System.out.println(line);
line = lineReader.readLine();
}
} catch (IOException e) {
System.out.println("An unknown IOException occured while reading the file.");
} catch (EOFException e) {
System.out.println("Unexpected end of File found.");
}
}

Jetzt würde der Javacompiler die Methode compilieren. Sollte eine Exception auftreten, so wird dies dem Benutzer auf der Konsole mitgeteilt und die Ausführung der Methode abgebrochen. Der try-catch-Mechanismus funktioniert folgendermaßen: Wenn in dem Block zwischen try und catch eine Exception auftritt, wird die Ausführung des Blocks abgebrochen und es geht im passenden catch-Block weiter. Dabei ist passend derjenige Block, dessen gefangene Klasse derjenige Vorfahre der tatsächlich ausgelösten Exceptionklasse ist, der in der Vererbungshierarchie am nächsten daran ist.
Man sollte die Blöcke zwischen try und catch so klein wie sinnvoll möglich halten. Insbesondere sollte man sich davor hüten, ganze Methoden in ein großes try-catch einzubauen, weil dann die Fehlerbehandlung ungenau und die Fehlersuche schwieriger wird. Eine gute Möglichkeit zum Fehler finden ist es, im catch Block die Methode printStackTrace der Exception aufzurufen. Andererseits sollte in einem fertigen Programm das try-catch Konzept nur dann genutzt werden, wenn man auch tatsächlich den Fehler behandeln kann.

Aus dieser Anforderung ergibt sich Notwendigkeit, die zweite Möglichkeit Exceptions zu behandeln zu benutzen. Hier werden auftretende Exceptions nicht per try-catch gefangen, weil man ebend keine sinnvolle Fehlerbehandlung im catch-Block anbieten kann. Dem Nutzer unserer Funktion muss man dies mitteilen, indem man dies hinter der Parameterliste per throws ankündigt. Wird dann in unserer Methode eine entsprechende Exception ausgelöst und nicht behandelt, so wird sie einfach an die aufrufende Methode "weitergeworfen".

Weiter Informationen für Interessierte gibt es hier (http://java.sun.com/docs/books/tutorial/essential/exceptions/index.html).

Das wars zu diesem Thema. Falls jemand so weit durchgehalten hat, danken wir für die Aufmerksamkeit :)
Wir hoffen, dass ihr jetzt ein klein wenig mehr mit den Mechanismen die Java anbietet vertraut seid und regen Gebrauch von der großen Klassenbibliothek machen werdet.

==TODOs==

eventuell Konstruktor für Apfel und Obst überall einbauen und nutzen

Link für Streams und "Aufsätze"

Javakurs2006/Tag 2/Vorlesung 2

2006-04-04T11:53:44Z

130.149.17.40: /* Die Methode equals(Objoct o) */

==Kleine Wiederholung==

Klassen beinhalten zusammengehörige Daten und Methoden. Mit new erzeugt man Instanzen dieser Klassen. Jede Instanz kann eigene Werte der zugehörigen Daten enthalten. Ein Teil der im Quellcode dieses Textes enthaltenen Kommentare erklären Syntax und hätten in einem "echten" Programm nichts zu suchen.

//file: Apfel.java
class Apfel {
String farbe;
int gewicht; //in Gramm

Apfel (String farb, int gew) { //Konstuktor
farbe = farb; //eigentlich this.farbe =farb, ist aber unnötig
gewicht = gew;
}

void essen() { //eine Methode
gewicht = 0;
}
}

//file: Beispiel.java
public Beispiel {
public static void main( String args[] ) {
Apfel boskop1 = new Apfel("rot", 175);
Apfel boskop2 = new Apfel("grün", 180);

System.out.println("boskop1 (" +
boskop1.farbe + "): " + boskop1.gewicht + " gramm");
System.out.println("boskop2 (" +
boskop2.farbe + "): " + boskop2.gewicht + "gramm");
}
}

==Vererbung==

In objektorientierten Programmiersprachen gibt es ein Konzept, dass sich Vererbung nennt. Eine Klasse erbt dann das Verhalten (also die Methoden) und auch die Daten von einer anderen Klasse. In Java benutzt man zum Vererben das Schlüsselwort extends.

//File: Obst.java
class Obst {
String farbe;
int gewicht; //in Gramm

void essen() {
gewicht = 0;
}
}

//File: Apfel.java
class Apfel extends Obst {
String geerntetIn;

void schaelen() {
gewicht = gewicht - 10;
}
}

Die Klasse Apfel im Beispiel hat alle Methoden und Daten von der Klasse Obst geerbt. Das heißt Instanzen dieser Klasse besitzen eine Farbe, ein Gewicht und man kann sie essen.

Wer mehr über Objektorientierung und Vererbung erfahren möchte, kann entweder eins der unzähligen verfügbaren Bücher zu dem Thema zur Hand nehmen. Alternativ könnte man auch diesen link (http://java.sun.com/docs/books/tutorial/java/concepts/index.html) verfolgen.

==Die Klasse Object==

In Java gibt es eine Klasse Object, von der jede andere Klasse abgeleitet ist. Wenn man kein extends hinschreibt, wird vom Compiler sozusagen das "extends Object" ergänzt. Dies geschieht intern, also ohne Veränderung in eurem Quellcode.

Einige Methoden von Object sind für uns sehr nützlich, weshalb sie hier kurz vorgestellt werden sollen. Doch eins noch zum Wort Objekt: Die Bezeichnung Objekt wird oftmals sowohl für Klassen als auch für Instanzen von Klassen benutzt, deshalb immer schauen welche Bedeutung wohl gerade gemeint ist.

Im folgenden wird hier Objekt in der Bedeutung von Instanz benutzt und Object, wenn die besondere Klasse Object gemeint ist.

===Die Methode toString()===

Nun aber zu den genannten nützlichen Mehtoden: Die Methode toString() liefert einen String, der die Instanz beschreibt. Doch woher soll die Methode (die ja in Object angelegt wurde) wissen, wie man unsere spezielle Instanz treffend in einem String beschreibt?

Dazu kann man die Methode überschreiben. Man macht das, indem man sie einfach in der eigenen Klasse noch einmal definiert.

//File: Apfel.java
class Apfel extends Obst {
String geerntetIn;

void schaelen() {
gewicht = gewicht - 10;
}

String toString() {
String description = "Ein Apfel, geerntet in " + geerntetIn;
return description;
}
}

Ruft man nun auf einer Instanz von Apfel toString auf, so wird die in Apfel definierte Version benutzt. Die Methode toString() ist unter anderem deshalb so wichtig, weil sie von System.out.println() benutzt wird, um Instanzen beliebiger Nachfahren von Object auf der Konsole auszugeben. Die Methode printMe() aus der vorhergehenden Übung hatte die gleiche Funktion. Nur arbeitet println() mit toString(), weshalb es sinnvoll wäre printMe() in toString() umzubenennen.

===Die Methode equals(Object o)===

Eine weitere wichtige Methode von Object ist equals(Object o). Hiermit kann, wie der Name schon sagt die Gleichheit zweier Objekte festgestellt werden. Nun wird sich vielleicht der ein oder andere fragen, warum man nicht den Vergleichsoperator == benutzt, sondern eine eigene Methode dafür schreibt. Warum das so ist, soll an einem Codebeispiel verdeutlicht werden.

public static void main(String []args) {
Apfel apfel1 = new Apfel();
apfel1.farbe = "grün";
apfel1.geerntetIn = "Berlin";
apfel1.gewicht = 215;

Apfel apfel2 = new Apfel();
apfel2.farbe = "grün";
apfel2.geerntetIn = "Brandenburg";
apfel2.gewicht = 215;

Apfel apfel3 = apfel2;
}

Der Operator == gibt genau dann true zurück, wenn die Werte der beiden verglichenen Dinge identisch sind. Bei eingebauten Datentypen (int, double) verhält er sich wie erwartet. Der Wert eines Objektes hingegen ist die Identität des Objektes, und nicht sein Inhalt. Deshalb würde apfel1 == apfel2 false zurückgeben, weil es sich um zwei verschiedene Objekte handelt. Wir hätten aber gern eine Methode, die uns sagt, dass diese Äpfel insofern gleich sind, dass sie die gleichen Eigenschaften besitzen. Dabei ist zu beachten, dass wir für die Gleichheit zweier Äpfel hier nur das Gewicht und die Farbe heranziehen.Genau dies sollte equals realisieren.

class Apfel extends Obst {
String geerntetIn;

void schaelen() {
gewicht = gewicht - 10;
}

String toString() {
String description = "Ein Apfel, geerntet in " + geerntetIn;
}

boolean equals(Object o) {
Apfel andererApfel = (Apfel)o;
return farbe.equals(andererApfel.farbe) &&
gewicht == andererApfel.gewicht;
}
}

Im Beispiel für equals gibt es gleich zwei Dinge, die einer weiteren Erklärung bedürfen: In der ersten Zeile machen wir aus der Intanz von Object, mit dem wir vergleichen einen Apfel. Diesen Vorgang nennt man casten. Das Programm wird an dieser Stelle mit einer entsprechenden Fehlermeldung beendet, wenn der Parameter o kein Apfel ist. Das ist zwar nicht schön, macht aber trotzdem Sinn, da eine Gleichheit zwischen Äpfeln und beliebigen Objekten nicht zwangsläufig definiert ist. Dies ist zugegebenermaßen noch nicht ganz zufriedenstellend, da das Programm einfach beendet würde, wenn Apfel mit Autos zu vergleichen, obwohl man sicher sagen könnte, dass die beiden unterschiedlich sind. Wer hierzu noch etwas mehr lesen möchte, kann sich hier (http://www.galileocomputing.de/openbook/javainsel3/javainsel_030003.htm#Rxxjavainsel_030003281GleichheitvonObjektenunddieMethodeequals) vertiefen.

Die zweite Sache, die auffällt: das Gewicht wird mit == verglichen, warum nicht auch mit equals? Die Antwort darauf ist eigentlich recht einfach: gewicht ist vom Typ int, der ein primitiver Datentyp ist. Damit erbt er nicht von Object, und bietet demnach auch keine Methode equals an. Wie oben schon erwähnt liefert == bei primitiven Datentypen ja auch das gewünschte Ergebnis.

Eine Anmerkung hierzu ist noch wichtig: Die oben vorgestellte Implementierung von equals funktioniert für unsere Zwecke. Dennoch ist sie unsauber und erfüllt nicht die Anforderungen, die sun in seiner Klassenbibliothek an equals stellt. Dies genauer zu erläutern würde den Rahmen unseres Kurses sprengen, näheres dazu findet man unter anderem im Link zwei Absätze höher. Die genauen Anforderungen an die Implementierung der Methode equals sind zu finden in der Java API Referenz (http://java.sun.com/j2se/1.4.2/docs/api/java/lang/Object.html).

==Comparable==

Manchmal reicht es nicht aus, zu wissen zwei Objekte gleich sind. Oft wollen wir Objekte ordnen, wozu wir eine Funktion brauchen die uns mitteilt welches von zwei Objekten "größer" ist. Eine solche Funktion ist compareTo(Object o). Im Gegensatz zu equals und toString ist sie allerdings keine Methode von Object, da es Klassen gibt, deren Objekte man nicht ordnen kann. Ein Beispiel hierfür wären Farbtöne, für die es schwer fällt eine natürliche Ordnung zu finden. Nun könnten wir für unsere eigenen Klassen, wo das Ordnen Sinn macht einfach ein compareTo implementieren. Würden wir dies einfach so tun könnten wir allerdings nicht einen Algorithmus benutzen, den jemand anderes zum Ordnen seiner eigenen Klasse, die compareTo implementiert geschrieben hat:

//File: MyClass.java
class MyClass {
...
compareTo(MyClass o) {
...
}
...
}

//File: SomeonesClass.java
class SomeonesClass {
...
compareTo(SomeonesClass o) {
...
}
...
}

//File Utility.java
class Utility {
static sort(SomeonesClass daten[]) {
//sortiere daten mittels compareTo
}
}

Hier kann man kein array vom Typ MyClass[] als parameter von sort übergeben, da es sich um zwei verschiedene Typen handelt. Um dieses Manko zu umgehen gibt es in Java Interfaces. Sie stellen eine Vereinbarung darüber dar, welche Methoden eine Klasse anbietet. Im Gegensatz zur Vererbung gibt es aber hier beim Interface noch keine Vorgabe, wie diese Methoden funktionieren. Das Interface schreibt nur die Namen, Art der Parameter und des Rückgabewertes von Methoden vor. Comparable ist ein solches Interface, dass schon in der Java API vorgegeben ist. Es schreibt vor, dass Klassen die dieses Interface implementieren die Methode int compareTo(Object o) anbieten müssen.

Modifizieren wir also unser Beispiel so, dass wir das Interface Comparable nutzen.

//File: MyClass.java
class MyClass implements Comparable{
...
compareTo(Object o) {
MyClass parameter = (MyClass)o;
...
}
...
}

//File: SomeonesClass.java
class SomeonesClass implements Comparable{
...
compareTo(Object o) {
SomeonesClass parameter = (SomeonesClass)o;
...
}
...
}

//File Utility.java
class Utility {
static sort(Comparable daten[]) {
//sortiere daten mittels compareTo
}
}

Nun kann die Methode sort beliebige arrays übergeben bekommen, deren Inhalt das Interface Comparable implementiert. Darüber wird dieser Mehtode zugesichert, dass jedes Element dieses arrays über die Methode compareTo verfügt und somit sich mit anderen Elementen des arrays vergleichen lässt.

Noch ein paar Worte zum compareTo selbst: Diese Methode liefert uns als Rückgabewert eine ganze Zahl. Ist diese Zahl kleiner als 0, so ist die Instanz, auf der sie aufgerufen wurde kleiner als der übergebene Parameter (this < o). Ist der Rückgabewert genau 0, so ist this gleich o. Letzlich ist this größer als o, wenn der Rückgabewert von compareTo größer als 0 ist. Auch an die Methode compareTo gibt es in der API Referenz definierte Andorderungen (http://java.sun.com/j2se/1.4.2/docs/api/java/lang/Comparable.html) , die wir im Rahmen unserer Veranstaltung aber außen vor lassen wollen.

==Java API - Javas Klassenbibliothek==

Ein großer Vorteil von Java gegenüber anderen Programmiersprachen besteht darin, dass es eine Vielzahl vereinheitlichter und schon mitgelieferter Klassen und Interfaces gibt. Die Sammlung dieser Klassen und Interfaces nennt man Java API. Es gibt auf der Website von Sun(java.sun.com) eine sehr umfassende Dokumentation dieser API(http://java.sun.com/j2se/1.4.2/docs/api/), die allerdings nicht immer einfach zu bedienen ist. Wenn man weiß, nach welcher Klasse man sucht findet man meist recht schnell die gewünschten Informationen. Hat man aber nur eine vage Idee, was die Klasse tun soll muss man meist noch andere Quellen nutzen, um an den Namen der gesuchten Klasse heranzukommen. Hierzu bieten sich natürlich Suchmaschinen wie google an.

Im Folgenden wollen wir einige besonders Häufig verwendete Module und Konzepte der Java API vorstellen. Wie man ein solches Modul in eigenen Programmen verwendet, werden wir im ersten vorgestellten Modul etwas näher beleuchten.

===Math===

Das Modul Math bietet, wenig überraschend, alle möglichen Methoden und Konstanten die man für mathematische Berechnungen brauchen könnte. Einige Konstanten sind zum Beispiel

public static final double E;
public static final double PI;

Diese beiden Konstanten sind jeweils mit drei zusätzlichen Schlüsselwörtern gekennzeichnet, die hier zumindest grob erklärt werden sollen.

public bedeutet, dass die entsprechende Variable oder Methode auch außerhalb der definierenden Klasse und außerhalb von Math benutzt werden kann.

Von Daten, die satic definiert sind hat nicht jede Instanz eine eigene Ausprägung, sondern alle Instanzen der Klasse teilen sich diese Variable.
Mehtoden die static definiert sind, brauchen keine Instanz der Klasse um aufgerufen zu werden. Demnach kennen sie allerdings auch this nicht und können daher nicht auf Daten einer Instanz der Klasse arbeiten.

Das Schlüsselwort final an einer Variable macht diese zur Konstante. Das heißt sie wird einmal bei der Deklaration festgelegt und kann dann nicht mehr verändert werden.

Die einzelnen Methoden, die Math bietet sollen hier nicht im Detail besprochen werden, da sie recht einfach in der API-Dokumentation von Java zu finden sind. Dennoch soll anhand des Sinus ein Aufruf einer Methode aus Math hier gezeigt werden, um die nötige Syntax zu zeigen.

public static void main(String args[]) {
System.out.print( Math.sin(Math.PI / 2) );
}

Ausgabe: 0

Eine sehr nützliche Methode aus Math soll hier noch kurz vorgestellt werden, da man sie nicht unbedingt hier vermuten würde: Die Methode random liefert ohne Parameter zu erwarten eine Zufallszahl zwischen 0 und 1. Mit Hilfe dieser Methode kann man gleichverteilte und beliebige Zufallszahlen in den Bereichen von float und int erzeugen.

public static void main(String args[]) {
double random1 = Math.random(); //erzeugt eine Zahl im Bereich [0;1)
double random2 = Math.random() * 30 + 5; //erzeugt eine Zahl im Bereich [5;34)
int random3 = (int) (Math.random() * 13); //erzeugt eine natürliche Zahl im Bereich [0;12]
}

===Streams===

Ein weiteres nützliches Konzept, dass die Java API uns bietet sind Streams. Streams (zu deutsch: Datenströme) beschreiben Datenquellen oder Ziele, an die man Daten schicken kann. Dabei wird von der tatsächlichen Datenquelle oder vom tatsächlichen Ziel abstrahiert, um für alle "Sender" oder "Empfänger" von Daten die gleichen Mehtoden nutzen zu können. So können sich hinter einem Datenstrom beispielsweise eine Datei, die von der Tastatur kommenden Zeichen oder aber eine Netzwerkverbindung verbergen. Der Programmierer muss sich aber um diese Details, wenn er erstmal ein entsprechendes Datenstrom-Objekt erstellt hat keine Gedanken mehr machen, weil er ebend auf einem Datenstrom arbeitet und nicht auf einer bestimmten Datenquelle. Hier ein paar Beispiele, wie man verschiedene Datenströme erstellt. Dabei ist generell zwischen InputStream und OutputStream zu unterscheiden, wobei der erstere Daten von außen an unser Programm heranträgt und der zweite Daten von unserem Programm an einen Empfänger übermittelt

import java.io.*

//prints the ascii code for a specified number of keys pressed on the keyboard to the console
static void printAsciiCodes(int keysToPrint) {
InputStream keyboard = System.in; //get standard input stream (the keyboard)
for (int i = 0; i < keysToPrint; i++) {
int asciiCode = keyboard.read(); //wait for a key to be pressed
System.out.print(asciiCode + " "); //print it's ascii code
}
}

//prints the content of a file given by Name to the console bytewise
static void printFile(String fileName) {
InputStream file = new FileInputStream(fileName); //open a stream representing the file
int byteRead = file.read(); //read first byte from the file
while (byteRead != -1) { //while there is something to read
System.out.print(byteRead + " "); //print the byte we read at last
byteRead = file.read(); //read a new byte
}
}

Im Beispiel kann man schön sein, dass der Mechanismus zum lesen eines bytes bei beiden Datenströmen der gleiche ist. Lediglich in der Erstellung des Datenstromes gibt es je nach Quelle Unterschiede. Die Funktionsweise ist für Ausgabeströme recht ähnlich. Nähere Informationen dazu findet man in der API-Reference, wenn man nach den Klassen OutputStream und FileOutputStream sucht.

===BufferedReader===

Im letzten Abschnitt haben wir gesehen, wie leicht es ist mit Hilfe von Streams Bytes aus verschiedenen Quellen zu lesen. Oftmals wollen wir aber keine einzelnen Bytes lesen, sondern wissen dass unsere Datenquelle uns einen Text liefert. Da Text meist in Zeilen strukturiert ist, wäre es schön eine Funktion zu haben die Zeilenweise Strings aus unserem Stream liest. Auch hierfür bietet uns die Java Klassenbibiliothek bereits eine Lösung: den BufferedReader. Seine readLine Methode liest eine Zeile aus. Das Problem an dem BufferedReader ist, dass wir zu seiner Instantiierung einen Reader benötigen. Schauen wir in der API Dokumentation nach, welche Arten von Readern es gibt, so fällt der InputStreamReader auf. Schaut man sich diesen genauer an, so enthält er auch einen Konstruktor, der einen InputStream als Parameter akzeptiert.

Nun bleibt es unsere Aufgabe zuerst einen Datenstrom aus unserer Datenquelle zu erzeugen, dann darauf einen Reader zu konstruieren um am Schluß darauf einen BufferedReader zu setzen. Dieses Vorgehen wirkt zwar etwas klobig, doch es gibt in der Klassenbibliothek bisher (bis Java 1.4.2) keine bessere Lösung dafür. Es folgt ein kleines Beispiel, dass den Inhalt einer Textdatei zeilenweise auf der Konsole ausgibt.

import java.io.*;

static void printTextFile(String fileName) {
InputStream fileStream = new FileInputStream(fileName);
Reader reader = new InputStreamReader(fileStream); //wrap a Reader around the InputStream
BufferedReader lineReader = new BufferedReader(reader); //wrap a BufferedReader around the Reader
String line = lineReader.readLine();
while (line != null) { //if readLine returns null, file end is reached
System.out.println(line);
line = lineReader.readLine();
}
}

==Exceptions==

Versucht man die Programme aus den letzten beiden Abschnitten zu compilieren, so wird man feststellen dass sie nicht lauffähig sind. Mit der Tatsache, dass Streams so universell sind, handelt man sich natürlich auch alle möglichen Probleme der verschiedenen Medien, die ein Stream verstecken kann, ein. Um die Behandlung dessen zu vereinfachen und dem Programmierer die Chance zu geben an der richtigen Stelle auf Fehler zu reagieren gibt es Exceptions. An dieser Stelle soll es genügen zu erkennen, wann man von einer Methode erwarten muss, dass sie eine Exception auslöst und wie man damit umgeht.

Methoden, die eine Exception auslösen können müssen dies ihrer Umgebung mitteilen. Dies geschieht, mit dem Schlüsselwort throws gefolgt von einer kommaseparierten Liste aller Exceptions, die sie auslösen können.

public class InputStream {
...
public int read() throws IOException {
...
}
...
}

Bei den Klassen aus der Java Klassenbibliothek kann man der API-Reference entnehmen, welche Exceptions sie auslösen können. Jede mögliche Exception muss behandelt werden, dazu gibt es zwei Wege.Der erste funktioniert folgendermaßen: Man fasst den Teil einer Mehtode, der eine Exception auslösen kann in ein try-catch-Konstrukt ein. Wie dies aussieht soll gleich am Beispiel der Methode printTextFile gezeigt werden.

import java.io.*;

static void printTextFile(String fileName) {
InputStream fileStream = null;
try {
fileStream = new FileInputStream(fileName);
} catch (FileNotFoundException) {
System.out.println("The file " + fileName + " could not be found.");
return; //stop execution of method... cannot print from non existing file
}
Reader reader = new InputStreamReader(fileStream); //wrap a Reader around the InputStream
BufferedReader lineReader = new BufferedReader(reader); //wrap a BufferedReader around the Reader
try {
String line = lineReader.readLine();
while (line != null) { //if readLine returns null, file end is reached
System.out.println(line);
line = lineReader.readLine();
}
} catch (IOException e) {
System.out.println("An unknown IOException occured while reading the file.");
} catch (EOFException e) {
System.out.println("Unexpected end of File found.");
}
}

Jetzt würde der Javacompiler die Methode compilieren. Sollte eine Exception auftreten, so wird dies dem Benutzer auf der Konsole mitgeteilt und die Ausführung der Methode abgebrochen. Der try-catch-Mechanismus funktioniert folgendermaßen: Wenn in dem Block zwischen try und catch eine Exception auftritt, wird die Ausführung des Blocks abgebrochen und es geht im passenden catch-Block weiter. Dabei ist passend derjenige Block, dessen gefangene Klasse derjenige Vorfahre der tatsächlich ausgelösten Exceptionklasse ist, der in der Vererbungshierarchie am nächsten daran ist.
Man sollte die Blöcke zwischen try und catch so klein wie sinnvoll möglich halten. Insbesondere sollte man sich davor hüten, ganze Methoden in ein großes try-catch einzubauen, weil dann die Fehlerbehandlung ungenau und die Fehlersuche schwieriger wird. Eine gute Möglichkeit zum Fehler finden ist es, im catch Block die Methode printStackTrace der Exception aufzurufen. Andererseits sollte in einem fertigen Programm das try-catch Konzept nur dann genutzt werden, wenn man auch tatsächlich den Fehler behandeln kann.

Aus dieser Anforderung ergibt sich Notwendigkeit, die zweite Möglichkeit Exceptions zu behandeln zu benutzen. Hier werden auftretende Exceptions nicht per try-catch gefangen, weil man ebend keine sinnvolle Fehlerbehandlung im catch-Block anbieten kann. Dem Nutzer unserer Funktion muss man dies mitteilen, indem man dies hinter der Parameterliste per throws ankündigt. Wird dann in unserer Methode eine entsprechende Exception ausgelöst und nicht behandelt, so wird sie einfach an die aufrufende Methode "weitergeworfen".

Weiter Informationen für Interessierte gibt es hier (http://java.sun.com/docs/books/tutorial/essential/exceptions/index.html).

Das wars zu diesem Thema. Falls jemand so weit durchgehalten hat, danken wir für die Aufmerksamkeit :)
Wir hoffen, dass ihr jetzt ein klein wenig mehr mit den Mechanismen die Java anbietet vertraut seid und regen Gebrauch von der großen Klassenbibliothek machen werdet.

==TODOs==

eventuell Konstruktor für Apfel und Obst überall einbauen und nutzen

Link für Streams und "Aufsätze"

Javakurs2006/Tag 2/Vorlesung 2

2006-04-04T11:53:20Z

130.149.17.40: /* Die Methode toString() muss etwas zurückgeben! return eingefuegt (Sven) */

==Kleine Wiederholung==

Klassen beinhalten zusammengehörige Daten und Methoden. Mit new erzeugt man Instanzen dieser Klassen. Jede Instanz kann eigene Werte der zugehörigen Daten enthalten. Ein Teil der im Quellcode dieses Textes enthaltenen Kommentare erklären Syntax und hätten in einem "echten" Programm nichts zu suchen.

//file: Apfel.java
class Apfel {
String farbe;
int gewicht; //in Gramm

Apfel (String farb, int gew) { //Konstuktor
farbe = farb; //eigentlich this.farbe =farb, ist aber unnötig
gewicht = gew;
}

void essen() { //eine Methode
gewicht = 0;
}
}

//file: Beispiel.java
public Beispiel {
public static void main( String args[] ) {
Apfel boskop1 = new Apfel("rot", 175);
Apfel boskop2 = new Apfel("grün", 180);

System.out.println("boskop1 (" +
boskop1.farbe + "): " + boskop1.gewicht + " gramm");
System.out.println("boskop2 (" +
boskop2.farbe + "): " + boskop2.gewicht + "gramm");
}
}

==Vererbung==

In objektorientierten Programmiersprachen gibt es ein Konzept, dass sich Vererbung nennt. Eine Klasse erbt dann das Verhalten (also die Methoden) und auch die Daten von einer anderen Klasse. In Java benutzt man zum Vererben das Schlüsselwort extends.

//File: Obst.java
class Obst {
String farbe;
int gewicht; //in Gramm

void essen() {
gewicht = 0;
}
}

//File: Apfel.java
class Apfel extends Obst {
String geerntetIn;

void schaelen() {
gewicht = gewicht - 10;
}
}

Die Klasse Apfel im Beispiel hat alle Methoden und Daten von der Klasse Obst geerbt. Das heißt Instanzen dieser Klasse besitzen eine Farbe, ein Gewicht und man kann sie essen.

Wer mehr über Objektorientierung und Vererbung erfahren möchte, kann entweder eins der unzähligen verfügbaren Bücher zu dem Thema zur Hand nehmen. Alternativ könnte man auch diesen link (http://java.sun.com/docs/books/tutorial/java/concepts/index.html) verfolgen.

==Die Klasse Object==

In Java gibt es eine Klasse Object, von der jede andere Klasse abgeleitet ist. Wenn man kein extends hinschreibt, wird vom Compiler sozusagen das "extends Object" ergänzt. Dies geschieht intern, also ohne Veränderung in eurem Quellcode.

Einige Methoden von Object sind für uns sehr nützlich, weshalb sie hier kurz vorgestellt werden sollen. Doch eins noch zum Wort Objekt: Die Bezeichnung Objekt wird oftmals sowohl für Klassen als auch für Instanzen von Klassen benutzt, deshalb immer schauen welche Bedeutung wohl gerade gemeint ist.

Im folgenden wird hier Objekt in der Bedeutung von Instanz benutzt und Object, wenn die besondere Klasse Object gemeint ist.

===Die Methode toString()===

Nun aber zu den genannten nützlichen Mehtoden: Die Methode toString() liefert einen String, der die Instanz beschreibt. Doch woher soll die Methode (die ja in Object angelegt wurde) wissen, wie man unsere spezielle Instanz treffend in einem String beschreibt?

Dazu kann man die Methode überschreiben. Man macht das, indem man sie einfach in der eigenen Klasse noch einmal definiert.

//File: Apfel.java
class Apfel extends Obst {
String geerntetIn;

void schaelen() {
gewicht = gewicht - 10;
}

String toString() {
String description = "Ein Apfel, geerntet in " + geerntetIn;
return description;
}
}

Ruft man nun auf einer Instanz von Apfel toString auf, so wird die in Apfel definierte Version benutzt. Die Methode toString() ist unter anderem deshalb so wichtig, weil sie von System.out.println() benutzt wird, um Instanzen beliebiger Nachfahren von Object auf der Konsole auszugeben. Die Methode printMe() aus der vorhergehenden Übung hatte die gleiche Funktion. Nur arbeitet println() mit toString(), weshalb es sinnvoll wäre printMe() in toString() umzubenennen.

===Die Methode equals(Objoct o)===

Eine weitere wichtige Methode von Object ist equals(Object o). Hiermit kann, wie der Name schon sagt die Gleichheit zweier Objekte festgestellt werden. Nun wird sich vielleicht der ein oder andere fragen, warum man nicht den Vergleichsoperator == benutzt, sondern eine eigene Methode dafür schreibt. Warum das so ist, soll an einem Codebeispiel verdeutlicht werden.

public static void main(String []args) {
Apfel apfel1 = new Apfel();
apfel1.farbe = "grün";
apfel1.geerntetIn = "Berlin";
apfel1.gewicht = 215;

Apfel apfel2 = new Apfel();
apfel2.farbe = "grün";
apfel2.geerntetIn = "Brandenburg";
apfel2.gewicht = 215;

Apfel apfel3 = apfel2;
}

Der Operator == gibt genau dann true zurück, wenn die Werte der beiden verglichenen Dinge identisch sind. Bei eingebauten Datentypen (int, double) verhält er sich wie erwartet. Der Wert eines Objektes hingegen ist die Identität des Objektes, und nicht sein Inhalt. Deshalb würde apfel1 == apfel2 false zurückgeben, weil es sich um zwei verschiedene Objekte handelt. Wir hätten aber gern eine Methode, die uns sagt, dass diese Äpfel insofern gleich sind, dass sie die gleichen Eigenschaften besitzen. Dabei ist zu beachten, dass wir für die Gleichheit zweier Äpfel hier nur das Gewicht und die Farbe heranziehen.Genau dies sollte equals realisieren.

class Apfel extends Obst {
String geerntetIn;

void schaelen() {
gewicht = gewicht - 10;
}

String toString() {
String description = "Ein Apfel, geerntet in " + geerntetIn;
}

boolean equals(Object o) {
Apfel andererApfel = (Apfel)o;
return farbe.equals(andererApfel.farbe) &&
gewicht == andererApfel.gewicht;
}
}

Im Beispiel für equals gibt es gleich zwei Dinge, die einer weiteren Erklärung bedürfen: In der ersten Zeile machen wir aus der Intanz von Object, mit dem wir vergleichen einen Apfel. Diesen Vorgang nennt man casten. Das Programm wird an dieser Stelle mit einer entsprechenden Fehlermeldung beendet, wenn der Parameter o kein Apfel ist. Das ist zwar nicht schön, macht aber trotzdem Sinn, da eine Gleichheit zwischen Äpfeln und beliebigen Objekten nicht zwangsläufig definiert ist. Dies ist zugegebenermaßen noch nicht ganz zufriedenstellend, da das Programm einfach beendet würde, wenn Apfel mit Autos zu vergleichen, obwohl man sicher sagen könnte, dass die beiden unterschiedlich sind. Wer hierzu noch etwas mehr lesen möchte, kann sich hier (http://www.galileocomputing.de/openbook/javainsel3/javainsel_030003.htm#Rxxjavainsel_030003281GleichheitvonObjektenunddieMethodeequals) vertiefen.

Die zweite Sache, die auffällt: das Gewicht wird mit == verglichen, warum nicht auch mit equals? Die Antwort darauf ist eigentlich recht einfach: gewicht ist vom Typ int, der ein primitiver Datentyp ist. Damit erbt er nicht von Object, und bietet demnach auch keine Methode equals an. Wie oben schon erwähnt liefert == bei primitiven Datentypen ja auch das gewünschte Ergebnis.

Eine Anmerkung hierzu ist noch wichtig: Die oben vorgestellte Implementierung von equals funktioniert für unsere Zwecke. Dennoch ist sie unsauber und erfüllt nicht die Anforderungen, die sun in seiner Klassenbibliothek an equals stellt. Dies genauer zu erläutern würde den Rahmen unseres Kurses sprengen, näheres dazu findet man unter anderem im Link zwei Absätze höher. Die genauen Anforderungen an die Implementierung der Methode equals sind zu finden in der Java API Referenz (http://java.sun.com/j2se/1.4.2/docs/api/java/lang/Object.html).

==Comparable==

Manchmal reicht es nicht aus, zu wissen zwei Objekte gleich sind. Oft wollen wir Objekte ordnen, wozu wir eine Funktion brauchen die uns mitteilt welches von zwei Objekten "größer" ist. Eine solche Funktion ist compareTo(Object o). Im Gegensatz zu equals und toString ist sie allerdings keine Methode von Object, da es Klassen gibt, deren Objekte man nicht ordnen kann. Ein Beispiel hierfür wären Farbtöne, für die es schwer fällt eine natürliche Ordnung zu finden. Nun könnten wir für unsere eigenen Klassen, wo das Ordnen Sinn macht einfach ein compareTo implementieren. Würden wir dies einfach so tun könnten wir allerdings nicht einen Algorithmus benutzen, den jemand anderes zum Ordnen seiner eigenen Klasse, die compareTo implementiert geschrieben hat:

//File: MyClass.java
class MyClass {
...
compareTo(MyClass o) {
...
}
...
}

//File: SomeonesClass.java
class SomeonesClass {
...
compareTo(SomeonesClass o) {
...
}
...
}

//File Utility.java
class Utility {
static sort(SomeonesClass daten[]) {
//sortiere daten mittels compareTo
}
}

Hier kann man kein array vom Typ MyClass[] als parameter von sort übergeben, da es sich um zwei verschiedene Typen handelt. Um dieses Manko zu umgehen gibt es in Java Interfaces. Sie stellen eine Vereinbarung darüber dar, welche Methoden eine Klasse anbietet. Im Gegensatz zur Vererbung gibt es aber hier beim Interface noch keine Vorgabe, wie diese Methoden funktionieren. Das Interface schreibt nur die Namen, Art der Parameter und des Rückgabewertes von Methoden vor. Comparable ist ein solches Interface, dass schon in der Java API vorgegeben ist. Es schreibt vor, dass Klassen die dieses Interface implementieren die Methode int compareTo(Object o) anbieten müssen.

Modifizieren wir also unser Beispiel so, dass wir das Interface Comparable nutzen.

//File: MyClass.java
class MyClass implements Comparable{
...
compareTo(Object o) {
MyClass parameter = (MyClass)o;
...
}
...
}

//File: SomeonesClass.java
class SomeonesClass implements Comparable{
...
compareTo(Object o) {
SomeonesClass parameter = (SomeonesClass)o;
...
}
...
}

//File Utility.java
class Utility {
static sort(Comparable daten[]) {
//sortiere daten mittels compareTo
}
}

Nun kann die Methode sort beliebige arrays übergeben bekommen, deren Inhalt das Interface Comparable implementiert. Darüber wird dieser Mehtode zugesichert, dass jedes Element dieses arrays über die Methode compareTo verfügt und somit sich mit anderen Elementen des arrays vergleichen lässt.

Noch ein paar Worte zum compareTo selbst: Diese Methode liefert uns als Rückgabewert eine ganze Zahl. Ist diese Zahl kleiner als 0, so ist die Instanz, auf der sie aufgerufen wurde kleiner als der übergebene Parameter (this < o). Ist der Rückgabewert genau 0, so ist this gleich o. Letzlich ist this größer als o, wenn der Rückgabewert von compareTo größer als 0 ist. Auch an die Methode compareTo gibt es in der API Referenz definierte Andorderungen (http://java.sun.com/j2se/1.4.2/docs/api/java/lang/Comparable.html) , die wir im Rahmen unserer Veranstaltung aber außen vor lassen wollen.

==Java API - Javas Klassenbibliothek==

Ein großer Vorteil von Java gegenüber anderen Programmiersprachen besteht darin, dass es eine Vielzahl vereinheitlichter und schon mitgelieferter Klassen und Interfaces gibt. Die Sammlung dieser Klassen und Interfaces nennt man Java API. Es gibt auf der Website von Sun(java.sun.com) eine sehr umfassende Dokumentation dieser API(http://java.sun.com/j2se/1.4.2/docs/api/), die allerdings nicht immer einfach zu bedienen ist. Wenn man weiß, nach welcher Klasse man sucht findet man meist recht schnell die gewünschten Informationen. Hat man aber nur eine vage Idee, was die Klasse tun soll muss man meist noch andere Quellen nutzen, um an den Namen der gesuchten Klasse heranzukommen. Hierzu bieten sich natürlich Suchmaschinen wie google an.

Im Folgenden wollen wir einige besonders Häufig verwendete Module und Konzepte der Java API vorstellen. Wie man ein solches Modul in eigenen Programmen verwendet, werden wir im ersten vorgestellten Modul etwas näher beleuchten.

===Math===

Das Modul Math bietet, wenig überraschend, alle möglichen Methoden und Konstanten die man für mathematische Berechnungen brauchen könnte. Einige Konstanten sind zum Beispiel

public static final double E;
public static final double PI;

Diese beiden Konstanten sind jeweils mit drei zusätzlichen Schlüsselwörtern gekennzeichnet, die hier zumindest grob erklärt werden sollen.

public bedeutet, dass die entsprechende Variable oder Methode auch außerhalb der definierenden Klasse und außerhalb von Math benutzt werden kann.

Von Daten, die satic definiert sind hat nicht jede Instanz eine eigene Ausprägung, sondern alle Instanzen der Klasse teilen sich diese Variable.
Mehtoden die static definiert sind, brauchen keine Instanz der Klasse um aufgerufen zu werden. Demnach kennen sie allerdings auch this nicht und können daher nicht auf Daten einer Instanz der Klasse arbeiten.

Das Schlüsselwort final an einer Variable macht diese zur Konstante. Das heißt sie wird einmal bei der Deklaration festgelegt und kann dann nicht mehr verändert werden.

Die einzelnen Methoden, die Math bietet sollen hier nicht im Detail besprochen werden, da sie recht einfach in der API-Dokumentation von Java zu finden sind. Dennoch soll anhand des Sinus ein Aufruf einer Methode aus Math hier gezeigt werden, um die nötige Syntax zu zeigen.

public static void main(String args[]) {
System.out.print( Math.sin(Math.PI / 2) );
}

Ausgabe: 0

Eine sehr nützliche Methode aus Math soll hier noch kurz vorgestellt werden, da man sie nicht unbedingt hier vermuten würde: Die Methode random liefert ohne Parameter zu erwarten eine Zufallszahl zwischen 0 und 1. Mit Hilfe dieser Methode kann man gleichverteilte und beliebige Zufallszahlen in den Bereichen von float und int erzeugen.

public static void main(String args[]) {
double random1 = Math.random(); //erzeugt eine Zahl im Bereich [0;1)
double random2 = Math.random() * 30 + 5; //erzeugt eine Zahl im Bereich [5;34)
int random3 = (int) (Math.random() * 13); //erzeugt eine natürliche Zahl im Bereich [0;12]
}

===Streams===

Ein weiteres nützliches Konzept, dass die Java API uns bietet sind Streams. Streams (zu deutsch: Datenströme) beschreiben Datenquellen oder Ziele, an die man Daten schicken kann. Dabei wird von der tatsächlichen Datenquelle oder vom tatsächlichen Ziel abstrahiert, um für alle "Sender" oder "Empfänger" von Daten die gleichen Mehtoden nutzen zu können. So können sich hinter einem Datenstrom beispielsweise eine Datei, die von der Tastatur kommenden Zeichen oder aber eine Netzwerkverbindung verbergen. Der Programmierer muss sich aber um diese Details, wenn er erstmal ein entsprechendes Datenstrom-Objekt erstellt hat keine Gedanken mehr machen, weil er ebend auf einem Datenstrom arbeitet und nicht auf einer bestimmten Datenquelle. Hier ein paar Beispiele, wie man verschiedene Datenströme erstellt. Dabei ist generell zwischen InputStream und OutputStream zu unterscheiden, wobei der erstere Daten von außen an unser Programm heranträgt und der zweite Daten von unserem Programm an einen Empfänger übermittelt

import java.io.*

//prints the ascii code for a specified number of keys pressed on the keyboard to the console
static void printAsciiCodes(int keysToPrint) {
InputStream keyboard = System.in; //get standard input stream (the keyboard)
for (int i = 0; i < keysToPrint; i++) {
int asciiCode = keyboard.read(); //wait for a key to be pressed
System.out.print(asciiCode + " "); //print it's ascii code
}
}

//prints the content of a file given by Name to the console bytewise
static void printFile(String fileName) {
InputStream file = new FileInputStream(fileName); //open a stream representing the file
int byteRead = file.read(); //read first byte from the file
while (byteRead != -1) { //while there is something to read
System.out.print(byteRead + " "); //print the byte we read at last
byteRead = file.read(); //read a new byte
}
}

Im Beispiel kann man schön sein, dass der Mechanismus zum lesen eines bytes bei beiden Datenströmen der gleiche ist. Lediglich in der Erstellung des Datenstromes gibt es je nach Quelle Unterschiede. Die Funktionsweise ist für Ausgabeströme recht ähnlich. Nähere Informationen dazu findet man in der API-Reference, wenn man nach den Klassen OutputStream und FileOutputStream sucht.

===BufferedReader===

Im letzten Abschnitt haben wir gesehen, wie leicht es ist mit Hilfe von Streams Bytes aus verschiedenen Quellen zu lesen. Oftmals wollen wir aber keine einzelnen Bytes lesen, sondern wissen dass unsere Datenquelle uns einen Text liefert. Da Text meist in Zeilen strukturiert ist, wäre es schön eine Funktion zu haben die Zeilenweise Strings aus unserem Stream liest. Auch hierfür bietet uns die Java Klassenbibiliothek bereits eine Lösung: den BufferedReader. Seine readLine Methode liest eine Zeile aus. Das Problem an dem BufferedReader ist, dass wir zu seiner Instantiierung einen Reader benötigen. Schauen wir in der API Dokumentation nach, welche Arten von Readern es gibt, so fällt der InputStreamReader auf. Schaut man sich diesen genauer an, so enthält er auch einen Konstruktor, der einen InputStream als Parameter akzeptiert.

Nun bleibt es unsere Aufgabe zuerst einen Datenstrom aus unserer Datenquelle zu erzeugen, dann darauf einen Reader zu konstruieren um am Schluß darauf einen BufferedReader zu setzen. Dieses Vorgehen wirkt zwar etwas klobig, doch es gibt in der Klassenbibliothek bisher (bis Java 1.4.2) keine bessere Lösung dafür. Es folgt ein kleines Beispiel, dass den Inhalt einer Textdatei zeilenweise auf der Konsole ausgibt.

import java.io.*;

static void printTextFile(String fileName) {
InputStream fileStream = new FileInputStream(fileName);
Reader reader = new InputStreamReader(fileStream); //wrap a Reader around the InputStream
BufferedReader lineReader = new BufferedReader(reader); //wrap a BufferedReader around the Reader
String line = lineReader.readLine();
while (line != null) { //if readLine returns null, file end is reached
System.out.println(line);
line = lineReader.readLine();
}
}

==Exceptions==

Versucht man die Programme aus den letzten beiden Abschnitten zu compilieren, so wird man feststellen dass sie nicht lauffähig sind. Mit der Tatsache, dass Streams so universell sind, handelt man sich natürlich auch alle möglichen Probleme der verschiedenen Medien, die ein Stream verstecken kann, ein. Um die Behandlung dessen zu vereinfachen und dem Programmierer die Chance zu geben an der richtigen Stelle auf Fehler zu reagieren gibt es Exceptions. An dieser Stelle soll es genügen zu erkennen, wann man von einer Methode erwarten muss, dass sie eine Exception auslöst und wie man damit umgeht.

Methoden, die eine Exception auslösen können müssen dies ihrer Umgebung mitteilen. Dies geschieht, mit dem Schlüsselwort throws gefolgt von einer kommaseparierten Liste aller Exceptions, die sie auslösen können.

public class InputStream {
...
public int read() throws IOException {
...
}
...
}

Bei den Klassen aus der Java Klassenbibliothek kann man der API-Reference entnehmen, welche Exceptions sie auslösen können. Jede mögliche Exception muss behandelt werden, dazu gibt es zwei Wege.Der erste funktioniert folgendermaßen: Man fasst den Teil einer Mehtode, der eine Exception auslösen kann in ein try-catch-Konstrukt ein. Wie dies aussieht soll gleich am Beispiel der Methode printTextFile gezeigt werden.

import java.io.*;

static void printTextFile(String fileName) {
InputStream fileStream = null;
try {
fileStream = new FileInputStream(fileName);
} catch (FileNotFoundException) {
System.out.println("The file " + fileName + " could not be found.");
return; //stop execution of method... cannot print from non existing file
}
Reader reader = new InputStreamReader(fileStream); //wrap a Reader around the InputStream
BufferedReader lineReader = new BufferedReader(reader); //wrap a BufferedReader around the Reader
try {
String line = lineReader.readLine();
while (line != null) { //if readLine returns null, file end is reached
System.out.println(line);
line = lineReader.readLine();
}
} catch (IOException e) {
System.out.println("An unknown IOException occured while reading the file.");
} catch (EOFException e) {
System.out.println("Unexpected end of File found.");
}
}

Jetzt würde der Javacompiler die Methode compilieren. Sollte eine Exception auftreten, so wird dies dem Benutzer auf der Konsole mitgeteilt und die Ausführung der Methode abgebrochen. Der try-catch-Mechanismus funktioniert folgendermaßen: Wenn in dem Block zwischen try und catch eine Exception auftritt, wird die Ausführung des Blocks abgebrochen und es geht im passenden catch-Block weiter. Dabei ist passend derjenige Block, dessen gefangene Klasse derjenige Vorfahre der tatsächlich ausgelösten Exceptionklasse ist, der in der Vererbungshierarchie am nächsten daran ist.
Man sollte die Blöcke zwischen try und catch so klein wie sinnvoll möglich halten. Insbesondere sollte man sich davor hüten, ganze Methoden in ein großes try-catch einzubauen, weil dann die Fehlerbehandlung ungenau und die Fehlersuche schwieriger wird. Eine gute Möglichkeit zum Fehler finden ist es, im catch Block die Methode printStackTrace der Exception aufzurufen. Andererseits sollte in einem fertigen Programm das try-catch Konzept nur dann genutzt werden, wenn man auch tatsächlich den Fehler behandeln kann.

Aus dieser Anforderung ergibt sich Notwendigkeit, die zweite Möglichkeit Exceptions zu behandeln zu benutzen. Hier werden auftretende Exceptions nicht per try-catch gefangen, weil man ebend keine sinnvolle Fehlerbehandlung im catch-Block anbieten kann. Dem Nutzer unserer Funktion muss man dies mitteilen, indem man dies hinter der Parameterliste per throws ankündigt. Wird dann in unserer Methode eine entsprechende Exception ausgelöst und nicht behandelt, so wird sie einfach an die aufrufende Methode "weitergeworfen".

Weiter Informationen für Interessierte gibt es hier (http://java.sun.com/docs/books/tutorial/essential/exceptions/index.html).

Das wars zu diesem Thema. Falls jemand so weit durchgehalten hat, danken wir für die Aufmerksamkeit :)
Wir hoffen, dass ihr jetzt ein klein wenig mehr mit den Mechanismen die Java anbietet vertraut seid und regen Gebrauch von der großen Klassenbibliothek machen werdet.

==TODOs==

eventuell Konstruktor für Apfel und Obst überall einbauen und nutzen

Link für Streams und "Aufsätze"

Javakurs2006/Tag 1/Vorlesung 2

2006-04-04T09:27:46Z

130.149.17.40: /* Schleifen */

= Methoden =
static int countOfCharactersInMyName(String name) {
return name.length();
}

Man schreibt:
# zuerst ''static'' - aus Gründen, die wir morgen erklären werden.
# dann den Rückgabetyp: ''int'', ''double'', ''boolean'', ''String'' oder ''void'' (für nichts).
# danach den Methodennamen. Dabei schreibt man mehrereWorteSoZusammen, so dass dasErsteWortKlein ist und alle darauffolgendenGroß! (auch CamelCase genannt)
# danach die Argumente der Methode in Klammern ''(String erstesArgument, int zweitesArgument)'' und so weiter. Auch hier gilt die Namenskonvention wie bei den Methoden.
# Dann in geschweiften Klammern '''{}''' der eigentliche Programmcode der Methode, den man mit ''return wert;'' oder nur ''return;'' (für void Methoden) beendet.

= Arrays =
<nowiki>
int [] vieleInteger = new int [1000];
double [] wenigGleitkommazahlen;
wenigGleitkommazahlen = new double[10];
int anzahl = 42;
String [] antwort = new String[anzahl];

antwort[3] = "Arthur Dent";
String name = antwort[3];
</nowiki>

Arrays sind eine Möglichkeit, viele Werte vom gleichen Typ zu haben. Man schreibt:
* zuerst den Typ der einzelnen Werte: ''int'', ''double'', ''boolean'' oder ''String''
* dann ein paar eckige Klammern ''[]''
* dann den Namen des Arrays, wobei wieder die normale Namenskonvention, CamelCase mit erstem Buchstaben klein, gilt.

Initialisieren kann man diese Variablen entweder gleich oder später - je nachdem was besser passt. Dazu
* weist man mit ''='' den Wert zu, den man von ''new'' zurückbekommt.
* ''new'' verwendet man so, dass man immer dahinter den Typ der Variablen wiederholt, allerdings schreibt man jetzt in die eckigen Klammern hinein, wie viel Elemente man benötigt - das kann aber auch eine Variable vom Typ ''int'' sein.

Zugreifen kann man auf die Elemente eines Arrays mit der ''[]'' Syntax mit ''einArray[nummer]'' kann man auf die einzelnen Werte sowohl zugreifen als auch ihnen Werte zuweisen.

= Schleifen =
<nowiki>
while(bedingungDieTrueErgibt()) {
tuEtwas();
}
int [] zahlen = new int[100]; // Indizes des Arrays sind 0 bis 99 !
for(int i = 0; i < zahlen.length; i = i + 1) {
zahlen[i] = i;
}
</nowiki>

Es gibt zwei Arten von Schleifen, die while-Schleife, die hervorragend geeignet ist, wenn man etwas so lange wiederholen möchte bis eine Bedingung zutrifft, und die for-Schleife, mit der man hervorragend alle Werte in einem Array durchgehen kann.

while-Schleifen schreibt man so:
* zuerst ''while'' und in runden Klammern dahinter die Bedingung. Das kann ein Ausdruck wie ''i < 10'' sein, oder eine Methode wie ''problemGelösst()'' oder ''nochAnDerArbeit()''
* Danach in geschweiften Klammern der Inhalt (Body) der Schleife.

for-Schleifen schreibt man so:
* zuerst ''for'', dann in runden Klammern drei Anweisungen, jeweils mit Semikolon getrennt: Variablen-Initialisierung, Schleifenbedingung und Weitersetzung der Schleifenvariablen. Sehr oft sieht das sehr ähnlich zu dem Beispiel oben aus.
* danach auch wieder in geschweiften Klammern die Anweisungen, die wiederholt werden sollen.

= Fehler finden / Debugging =
Eine einfache Technik, den Fehler in einem Programm zu finden ist es, an verschiedenen Stellen auszugeben, welchen Wert eine Variable hat. Das geht so:
<nowiki>
System.out.println("Die Variable a hat den Wert: " + a);
// oder kürzer
System.out.println("a: " + a);
</nowiki>

Auch sehr gut ist, ein Problem in einer Methode zusammenzufassen und diese dann zu testen, indem man die Methode mit bestimmten Parametern aufruft und das Ergebnis wieder mit ''System.out.println()'' ausgibt. Etwa so:
<nowiki>
System.out.println("parameter: 3: " methodeDieIchTeste(3));
System.out.println("parameter: 4: " methodeDieIchTeste(4));
System.out.println("parameter: 23: " methodeDieIchTeste(23));
System.out.println("parameter: 42: " methodeDieIchTeste(42));
</nowiki>

Damit kann man an den Ausgaben sehr gut sehen, was man verbockt hat.

Javakurs2006/Probleme

2006-04-04T09:24:09Z

130.149.17.40: intiale kurze Version aus Tag1 extrahiert

== Zwei häufige Probleme mit java ==
Exception in thread "main" java.lang.NoClassDefFoundError:KlassennameDenIhrGeradeKompiliertHabt
:Mann kann das Problem auf zwei Arten lösen:
:* man schreibt ''"java -cp . Klasse"'' anstatt nur ''"java Klasse"'' um sie Auszuführen
:* verwendet man die bash: schreibt man ''export CLASSPATH=$CLASSPATH:.'' entweder in jeder shell einmal oder in die ''.bashrc'' eintragen und die shell mit ''exec bash'' neu starten.
:* verwendet man die tcsh: schreibt man ''setenv CLASSPATH ".:$CLASSPATH"'' entweder in jeder shell oder einmal in der ''.cshrc'' eintragen und die shell mit ''tcsh'' neu starten.

:Der Fehler bedeutet, dass die Shell-Variable CLASSPATH gesetzt ist. Das hat zur Folge das Java den Standardwert "." (das Verzeichnis in dem man gerade ist) nicht mehr in den CLASSPATH aufnimmt und diese Fehlermeldung auflöst.

Exception in thread "main" java.lang.NoClassDefFoundError:KlassennameDenIhrGeradeKompiliertHabt/class
:dann habt ihr das Programm mit "java KlassennameDenIhrGeradeKompiliertHabt.class" aufgerufen, was falsch ist. Man darf hier das "class" nicht an den Befehl anhängen.

Note: Test.java uses unchecked or unsafe operations.
Note: Recompile with -Xlint:unchecked for details.
:Dann könnt ihr die entweder Ignorieren, oder aber ihr loggt euch nicht auf Solaris 9 anstatt Solaris 10 ein. Wie das geht steht auf dem Anmeldebildschirm!

[[Javakurs2006| <- zurück zur Startseite]]

Javakurs2006/Tag 2

2006-04-04T09:21:03Z

130.149.17.40: CLASSPATH Problem erstmal hier aufgenommen...

[[Javakurs2006| <- Zurück zur Übersicht]]

= Vormittags =
* [[Robert_Lubkoll/Java_Kurs/Tag_2/Wiederholungsaufgabe | Wiederholungsaufgabe zu Schleifen und Arrays]]
* [http://docs.freitagsrunde.org/javakurs/blatt03.pdf Aufgabenblatt 3]
* [[Martin_Häcker/Java_Kurs/Tag_2/Handout| Vorlesung 3 zum Nachschlagen]]
* [http://docs.freitagsrunde.org/javakurs/Modularisierung%20und%20Objekte.pdf Folien zum Vortrag]

Es ist ein kleines Problem aufgetaucht: der CLASSPATH ist nicht immer korrekt gesetzt: Es fehlt das aktuelle Verzeichnis.
Das Ergebnis ist, dass der Java-Compiler (javac) nicht immer alle Klassen finden kann, obwohl die .class Dateien korrekt liegen.
Die Lösung ist folgendes Kommando, dass in dem Terminal in dem der javac aufgerufen wird einmal eingegeben werden muss:

export CLASSPATH=".:$CLASSPATH"

Dadurch sucht der Java-Compiler automatisch auch im aktuellen Verzeichnis "."

= Nachmittags =
== Übungsaufgaben ==
'''Ziel:''' Ein IOUtility-Objekt schreiben, das Eingabe und Ausgabe in Java einfach macht.

'''Idee:''' Verwendung der Java-API lernen.

'''Empfehlung zum Vorgehen:'''
Ihr solltet für jede Methode, die ihr schrebt, zunächst einen Test in der Main-Methode anlegen.
Mit Test ist hier z.B. ein Aufruf der Methode und die Ausgabe ihres Rückgabewertes auf der Konsole gemeint.

=== Zufallszahlen ===
:*Schlage die Methode [http://java.sun.com/j2se/1.4.2/docs/api/java/lang/Math.html#random() Math.random()] in der Java-API nach.
:*Verwende die Methode, um eine Methode ''void setRandomGrades()'' zu schreiben, die jedem Studenten eine zufällige Hauptdiplomsnote zuweist.

=== Umwandeln in eine Zeichenkette ===
:*Implementiere die Methode [http://java.sun.com/j2se/1.4.2/docs/api/java/lang/Object.html#toString() toString()] für die Student-Klasse.
:*Verändere printMe() so, dass sie diese neue Methode verwenden.
:Hinweis: Die Daten eines Studenten sollen dabei in folgendem Format ausgegeben werden:
Matrikelnummer Name
:Beispiel:
123456 Lieschen Müller
:*Implementiere die Methode [http://java.sun.com/j2se/1.4.2/docs/api/java/lang/Object.html#toString() toString()] für die StudentDatabase-Klasse, die sämtliche Studenten und anschließend die Anzahl der Studenten in der Datenbank zurückgibt. Jeder Student soll in einer eigenen Zeile stehen und die Zeile mit der Anzahl der Studenten soll mit einem Lehrzeichen oder Tab beginnen.
:Beispiel:
123456 Lieschen Müller
123457 Franz Schmidt
_2
:*(Wenn Du in der Übung am Vormittag schon eine Methode geschrieben hast, die eine Durchschnittsnote der Studenten berechnet, dann gib diese hier ebenfalls aus).

=== Arraylists ===
:*Lese den Javadoc zu [http://java.sun.com/j2se/1.4.2/docs/api/java/util/ArrayList.html ArrayList] und ersetze in der Studentendatenbank die Datenstruktur Array durch die ArrayList.
:*Wie verändern sich die Methoden ''addStudent()'', ''deleteStudent()'' und ''search()'' (sofern du sie implementiert hast)?
:* Gibt es Instanz-Variablen die jetzt nicht mehr gebraucht werden?

=== Gleichheit ===
:*Implementiere eine [http://java.sun.com/j2se/1.4.2/docs/api/java/lang/Object.html#equals(java.lang.Object) equals()]-Methode für Student. Diese soll zwei Studenten als gleich betrachten, wenn diese die gleiche Matrikelnummer haben.

==== Gleichheit verwenden ====
:Nutze equals(), um eine Methode ''containsStudent(Student aStudent)'' zu schreiben, die beim Einfügen eines neuen Studenten in die Datenbank nachprüft, ob dieser bereits in ihr enthalten ist.

=== IOUtility ===
:*Es soll eine Klasse "IOUtility" geschrieben werden, welche eine Methode ''void writeStringToFile(String content, String filename)'' enthält.
:*Diese soll einen String in eine Datei schreiben. Schaue dir dafür die Java-Klassen [http://java.sun.com/j2se/1.4.2/docs/api/java/io/FileOutputStream.html FileOutputStream] (vor allem die Konstruktoren) und [http://docjar.com/docs/api/java/io/OutputStreamWriter.html OutputStreamWriter] (für die geerbte Methode [http://java.sun.com/j2se/1.3/docs/api/java/io/Writer.html#write(java.lang.String) write(String)]) an.
:*Benutze deine eben geschriebende Methode, um die Studentendatenbank in eine Datei auszugeben.

Hinweis:
:*Verwende auch hier die toString()-Methode.
:*Von den von euch verwendeten API-Methoden können hier verschiedene Exceptions ausgelöst werden, um welche wir uns kümmern müssen.
:*Da wir in unserer Methode selbst keine Möglichkeit haben, diese sinvoll zu behandeln, sollen die Exeptions mit "throws" weitergereicht werden.

=== ''Weiterführende Aufgaben'' ===
:*Erweitere das IOUtility-Objekt so, dass ihm bereits im Konstruktoraufruf der Name einer Datei übergeben wird, auf welcher es arbeiten soll.
:*Mit dem Aufruf der Methode ''startReading()'' soll das Objekt die Datei zum Lesen öffnen, sodass mit der Methode ''readLine()'' nacheinander ihre Zeilen ausgelesen werden können. Die Methode ''readLine()'' soll dabei ''null'' zurückgeben, wenn beim Lesen das Ende der Datei erreicht wurde.
Für den unwahrscheinlichen Fall, dass noch immer Langeweile herrscht, beginne mit den Aufgaben für den [[Javakurs2006/Tag_3|dritten Tag]].

== An die Tutoren ==
:Eingabe und Ausgabe unter Java ist nicht besonders elegant - vor allem, wenn man bei einer Aufgabe die Vorteile des Stream-Konzepts überhaupt nicht nutzen kann. Die Studenten sollen daher ein Objekt schreiben, das ihnen diese Aufgaben erleichtert. Ein entferntes Vorbild ist uns dabei eine [http://www.cs.princeton.edu/introcs/22inout/In.java.html Input-Klasse, die wir an der Princeton-Universität gefunden haben].

[[Javakurs2006| <- Zurück zur Übersicht]]

Diskussion:Opal FAQ

2005-12-06T12:18:02Z

130.149.17.40: Befehl oasys läuft nicht mehr

Ich habe bei mir das Problem, dass sich vor wenigen Wochen Opal noch in jedem Ordner aufrufen lies.
Meines erachtens ging dies immer mit dem Befehl oasys oder Oasys. Beides habe ich ausprobiert und es hat nicht funktioniert.
Also entweder hat sich bei mir Opal nach einem Jahr abgeschalted (was sehr ärgerlich wäre, da ich die Info A Klausur wiederholen muss)
oder ich hab mir den falschen Befehl gemerkt oder da ist irgendetwas schiefgelaufen.

Hier eine Vermutung, die ich für unwahrscheinlich halte: Ist Opal (bzw.oasys) Oberflächenabhängig? D.h. läuft es vielleicht nicht im KDE z.b. obwohls im FVWM2 (wo es eingerichted wurde) läuft?

Eclipsekurs 2005

2005-04-27T12:40:21Z

130.149.17.40: /* Anmeldung für den 2. Kurs */

=== Kurzbeschreibung ===

[[IBM Eclipse | Eclipse]] ist eine [[Java IDE Einleitung| IDE]], mit der sich insbesondere Java-Programme schneller und bequemer erstellen lassen. Allerdings ist Eclipse sehr komplex und insbesondere der Start könnte vielleicht dem einen oder anderen etwas schwer fallen.

Wir veranstalten daher wie jedes Jahr einen 2-stündigen Einführungskurs, in dem die basics gezeigt werden. Es geht also um Starthilfe, nicht um die neuesten Eclipse-Tricks oder die besten Plugins. Zielgruppe sind insbesondere Hörer von [[Informatik 2]], aber auch alle anderen Interessenten sind willkommen.

=== Zeit und Ort ===

==== 2. Kurs (28. April) ====
Datum: '''Donnerstag, 28. April 2005''' 
Zeit: 16:15-18:00 
Dauer: 90 Minuten (einmalig) 
SWS: keine (studentische Veranstaltung) 
Ort: FR5046

==== 1. Kurs (21. April) ====
Datum: '''Donnerstag, 21. April 2005''' 
Zeit: ab 16:15 
Dauer: 90 Minuten (einmalig) 
SWS: keine (studentische Veranstaltung) 
Ort: FR 5516

=== Themen ===
* Projekte anlegen
* Java-Programme schreiben & ausführen
* Debugging

=== Anmerkungen ===
* 3plus4software.de ist aus irgendwelchen Gruenden nicht mehr aufrufbar. Immerhin gibt es eine englische Kopie der Tutorials unter http://www.eg.bucknell.edu/~cs479/Fall2004SoftwareDesign/eclipse-tutorial/ . Archive.org hat auch die deutsche Version, leider aber unvollständig: http://web.archive.org/web/20041009232736/www.3plus4software.de/eclipse/index.html

=== 1. Kurs ===
Teilnehmerliste:
# Florian Zeidler (fzeidler)
# Thilo Schmidt (dude)
# Alexander Oppermann (opix)
# Nicolas Poczka (npoczka)
# Daniel Giancaterino (italia)
# Ani Hayka (almhay)
# Zhuo-Fei Hui (zfhui@...)
# Simon Kwoczek (simonk)
# E. L. M. (easy)
# Stephan Spiegel (spiegels)
# Nina Penova (nina)
# Sven Pritzlaff (snakebln)
# Jens Meier (jmeier)
# Moslem Azizi (azizi)
# Seyed Sadra Amirkhalili (sidnorme)
# Mohammad Mohebbi (sidnor_me@...)
# Meyssam Alihosseini (meyssam20001@...)
# Pawel Wojciechowski (giugiaro)
# Andreas Gobbin (andigob)
# Anton Gräber (sunlicht)
# Melanie Ozanik (qertyxy) --ich kann heute doch nicht :o(
# Ulrike Koelle (koelleu)
# Goßmann Matthias (matthias)
# Konstantin Domoratskyy (kostyan)
# Christian Retzlaff (retzlaff)
# Christoph Lorenz (yasokuhl)
# Deniz Ceren Eser (amphitridenis@...)
# Andreas Stöckle (andreasstoeckle@...)
# Sebastian Ahrndt (baschi)
# Yibo Zhao (boge1981@...)
# Eik Tauber (eikohol)
# Sven Wasmer (svenfqab)
# Susi Kellberger (tarasue@...)
Bitte nicht mehr anmelden, der Kurs ist voll. Bitte in den zweiten Kurs (s. unten) eintragen.

=== Anmeldung für den 2. Kurs ===

Glücklicherweise sind wir inzwischen fünf Vortragende, d.h. heißt, wir können bequem zwei Kurse veranstalten. Der zweite Kurs wird am 28.4. stattfinden.

Habt bitte Verständnis, dass wir schon auf Grund der Raumsituation eine Teilnehmerbeschränkung (35 Personen) einführen müssen. Bisher konnte aber immer jeder Interessent am Kurs teilnehmen!

Um euch für den Kurs anzumelden, tragt euch bitte unten in der Liste ein. Für Leute, die noch nie ein Wiki benutzt haben: Auf 'bearbeiten' klicken (neben der Anmelden-Überschrift), dann im Textfeld die gewünschte Änderung durchführen und anschließend 'Artikel speichern'.

Voranmeldungen hier, wir melden uns bei euch:

MUSTER: "# Name (cs-userid)" ohne die ""

# Jens Marohn (pica) Bitte um 14:00 Uhr Danke
# Dominique Charpentier (djcinc) 14.00 Uhr klingt gut!
# Marcus Daute (marcusd) Donnerstag Lieber 16 Uhr!
# Thomas Krauß (tkra) Donnerstag
# Stefan Schaffer (schaffer)
# Nadezhda Levitan (nlevitan) Donnerstag
# Johannes Teske (joeheynz) Donnerstag 1600, wie bereits gewünscht ;-)
# Martin Möller (martino) Freitag 10-12 finde ich klasse
# Alexander Wachtberger (Pacheco) Donnerstag 1600, bis dann.
# Neli Gospodinova (nelig)
# Jens Grohmann (sirsilva) Donnerstag 1600 wäre perfekt >;-)
# Andreas Hergert (handreas) Donnerstag 16:00 wäre gut
# Fabian Löser (shorty) Donnerstag 16 Uhr würde passen
# Krishan Paramasivam (krishi) Donnerstag um 16 Uhr ist OK
# Jan-Christoph Lange (crusrhai) Donnerstag um 16 Uhr
# Sascha Friesike (friesike) Donnerstag um 16 Uhr
# Sebastian Meyer (sebinator2003) Donnerstag um 16 Uhr
# Karolina Cyganek (kcyganek) Do 16 Uhr
# Andreas Häusler (ahaeusl)
# Sebastian Gutsche (sebagut)
# Marius Walther (mariusw) Do 16 Uhr
# Arnold Knaub (ares) Do 16 Uhr
# Diego Iles (diegoile) donnerstag 16 Uhr
# Stefan Schmidt (rendhark) Do 16 Uhr

Anmerkung: Der zweite Kurs findet jetzt definitiv Donnerstag 16:00 statt.

=== Feedback der Teilnehmer vom 21.4.2005 ===
(Vorgabe war, dass jeweils zwei positive und negative Dinge genannt werden mussten)

+ Vielen Dank für die informative Einführung in Eclipse 
+ Der Debugger scheint wirklich nützlich zu sein, wahrscheinlich sogar besser wie C++ 
- Warum gab es nichts Ähnliches für Opal, das hätte ein paar graue Haare gespart. 
''Anmerkung: Dass es für Opal keine vernünftigen Tools gibt, ist auch einer unserer größten Kritikpunkte an Opal.'' 
- Ohne Nürnberger Trichter wird ma das alles erst mal selber am Rechner verdauen müssen. 

+ gemeinsame Moderation 
+ Aufbau 
+ Themen 
- Frisur der Moderatoren 
''Anmerkung: Schon mal was von Artenschutz gehört?''

+ informativ 
+ anfängertauglich 
+ gut strukturiert 
- zu kleiner Raum 
- erzwungenes Feedback 
''Anmerkung: Wir sind halt fiese, böse Informatiker. *g*''

+ Handzettel 
+ man merkt, ihr kennt euch damit aus 
- vielleicht für die etwas schwierig, die noch nie programmiert haben (Vermutung)

+ Grober Überblick 
+ Viele Beispiele 
- Die Publikation kann noch verbessert werden.

+ Der Vortrag war gut und strukturiert. 
- Es fehlt noch sowas wie ein Java-Programmierkurs. 
''Anmerkung: Stimmt. Haben wir im letzten Sommersemester gemacht.''

+ Eure gemeinsame Moderation. 

+ Ansonsten sehr gut 
- Keine Liste mit Tastenkürzeln.

+ gute Information, gut nachvollziehbar 
+ humorvoll 
- ihr seid euch gegenseitig ins Wort gefallen

+ spannend 
+ schnell gelaufen 
+ gut gemacht Jungs :-) 
- bin nicht so weit und brauche noch eine Weile, alles nachzuvollziehen. 
- kein Vergleich zu anderen IDEs 
''Anmerkung: Wieso? Wir haben doch gesagt, dass es die beste ist. ;-)''

+ Multimediale Nutzung/Präsentation 
+ Viele Erläuterungen, Tipps 
- hätten mehr Beispiele sein können

+ gute Einführung, so dass man ohne viele Vorkenntnise verstehen konnte 
+ lockere Atmosphäre 
- nichts Negatives

Mensa

2004-10-26T12:46:53Z

130.149.17.40: Umbauprobleme ergaenzt

In der '''Mensa''' gibt's günstiges und manchmal sogar schmackhaftes [[Essen]]. Bezahlt wird nicht mit Bargeld sondern mit der Girovendkarte (die allerdings im Foyer der Mensa mit Bargeld an Automaten aufgeladen werden kann).

Diese Karte bekommt man an einer der Kassen, die als 'Barkasse' gekennzeichnet ist gegen einen Pfand ausgehändigt.
Normalerweise soll man immer seinen Studentenausweis vorlegen, um in den Genuß der günstigeren Preise zu kommen.

Die Mensa befindet sich in der Hardenbergstr. 34, zwischen Phsik-Neubau und Ernst-Reuter Platz bzw. über den Campus hinter dem Hauptgebäude.

Momentan befindet sich die Mensa allerdings im Umbau, weswegen es nicht nur zu einigen Platzproblemen kommt, sondern auch zu einem kleinen Irrweg, bis man den momentanen Eingang erstmal gefunden hat (ist aber auch recht gut ausgeschldert).

Öffnungszeiten: Mo-Fr: 11:30-14:00 (nach Abschluss der Umbauarbeiten: Mo-Fr: 11:00-14:45 Uhr)

== Weblinks ==
[http://www.studentenwerk-berlin.de/mensen/02/03/ TU Mensa]

[[Kategorie: Gebäude]]
[[Kategorie: Wichtige Orte]]