FreitagsrundenWiki - Benutzerbeiträge [de]

C-Kurs/DTMF-Encoder

2010-09-16T14:03:25Z

130.149.17.41: /* Sinuswellen generieren */

In dieser Aufgabe soll ein Generator für DTMF-Töne erstellt werden. DTMF steht für Dual-tone multi-frequency und ist auch als [http://de.wikipedia.org/wiki/Mehrfrequenzwahlverfahren Mehrfrequenzwahlverfahren] bekannt.

Wenn du diese Aufgabe in den Rechnerräumen bearbeitest, benutze bei dem Abspielen der Töne bitte Kopfhörer, um andere nicht zu stören.

=== Was ist DTMF? ===
Kurz gesagt: ein DTMF-Ton besteht aus zwei überlagerten Sinuswellen. Für jede Taste auf dem Telefon ist eine bestimmte Frequenzkombination dieser beiden Wellen festgelegt. Genaueres sowie die Frequenzen für die Tasten finden sich [http://de.wikipedia.org/wiki/Mehrfrequenzwahlverfahren hier].

=== Wie werden Töne im Rechner dargestellt? ===
Töne lassen sich als [http://de.wikipedia.org/wiki/Puls-Code-Modulation PCM]-Daten speichnern. Unser Programm soll solche PCM-Daten generieren. Ausreichend sind hier 8 Bit pro Sample, sodass sich die Tondaten in einem Array aus <tt>unsigned char</tt> ablegen lassen. Die Samples sind dann vorzeichenlos, was bedeutet, dass bei 127 der Mittelwert ist. Als Samplerate reichen für uns auch recht niedrige 8 kHz, das heißt für jede Sekunde Ton werden 8000 Samples benötigt.

== Aufgabenstellung ==
Jetzt soll Schritt für Schritt der Tongenerator implementiert werden.

=== Sinuswellen generieren ===
Schreibe eine Funktion, die Sinuswellen als Mono-8Bit-8kHz-PCM-Daten erzeugt. Der Funktion soll die gewünschte Länge des Tons, die Frequenz des Tons, und die Amplitude, sowie einen Pointer auf ein int, in dem die Anzahl der generierten Samples abgelegt werden kann. Die Funktion soll dann ausreichend Speicher für die Daten allokieren und jedes Sample mit den passenden Sinuswerten befüllen und sie am Ende zurückgeben. Der Prototyp der Funktion sollte also etwa so aussehen:
<pre>unsigned char* generateSine(int ms, int freq, float amplitude, int *numSamples)</pre>

Rufe nun in der main-Funktion die Generierungsfunktion auf und speichere die Daten mit <tt>fwrite</tt> in eine Datei. Die Datei kann jetzt auf einem Linux-System auf einfache Weise abgespielt mit dem Kommando <tt>cat audiofile > /dev/dsp</tt> werden. Sie kann aber auch z.B. mit mplayer abgespielt werden:
<tt>mplayer -rawaudio samplesize=1:channels=1:rate=8000 -demuxer audiofile</tt>.

==== Hinweis zum Debuggen ====
Um sich die Audiodaten anzusehen, kann das Programm [http://audacity.sourceforge.net/?lang=de Audacity] verwendet werden. Öffnen lassen sie sich dort über Datei -> Importieren -> Rohdaten, dann die Datei auswählen, dann bei Codec Unsigned 8 bit PCM, bei Kanäle 1, bei Samplefrequenz 8000 Hz auswählen. Nun kann man in die Samples reinzoomen (Button mit Lupe und Plus) und sehen, ob der Sinuswellen ordentlich sind. Mit Analyse -> Frequenzanalyse kann überprüft werden, ob die Sinuswelle die richtige Frequenz hat.

=== Sinuswellen überlagern ===
Schreibe jetzt eine Funktion, die zwei Sinuswellen gleicher Länge überlagern kann. Die von ihr erstellte Samples sollen durch Addition der beiden Samples der Sinusdaten gebildet werden. Doch Vorsicht: da die Daten vorzeichenlos sind, müssen sie temporär vorzeichenbehaftet werden, so dass der Mittelwert 0 wird, dann können sie addiert werden und dann wieder vorzeichenlos abgespeichert werden (mit dem Mittelwert 127). Der Prototyp der Funktion sollte etwa so aussehen:
<pre>unsigned char* mixPcm(unsigned char *a, unsigned char *b, int numSamples)</pre>

Test nun die Funktion wieder, indem du zwei Sinuswellen unterschiedlicher Frequenz erzeugst und sie mit der neuen Funktion überlagerst. Als Amplitude sollte jeweils etwas weniger als die Hälfte gewählt werden, um bei der Addition [http://de.wikipedia.org/wiki/Clipping_%28Signalverarbeitung%29 Clipping] zu vermeiden. Untersuche das Ergebnis wieder, wie in der ersten Teilaufgabe.

=== DTMF-Töne ===
Schreibe eine Funktion, die für eine Ziffer zwischen 0 und 9 den passenden DTMF-Ton mithilfe der beiden vorigen Funktionen generieren kann. Ihr Prototyp kann etwa so aussehen:
<pre>unsigned char* generateDtmfTone(int number, int ms, int *numSamples)</pre>

Teste wieder. Zum Vergleich der Töne kannst du jetzt ein Telefon benutzen.

=== Nummernsequenzen generieren ===
Benutze jetzt die Generierungsfunktion, um eine Folge von Ziffern in eine Datei zu schreiben. Die Töne sollten durch Stille getrennt sein. Du brauchst also noch eine Funktion, die Samples generiert, die alle den Wert 127 haben. Die Nummer soll als Kommandozeilenparameter oder Benutzereingabe eingegeben werden.

Wenn du jetzt ein analoges Telefon zur Hand hast, kannst du die Töne ins Mikrofon des Hörers anspeilen und damit Nummern wählen.

== 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 ;)



[[Kategorie:CKurs]]
[[Kategorie:CKurs_Aufgaben]]

Javakurs/Übungsaufgaben/Rennschnecke

2010-03-24T15:51:37Z

130.149.17.41: /* Rennschnecke */

== 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. Soll heißen: Sie kriecht eine zufällige Strecke größer null und kleiner ihrer Maximalgeschwindigkeit. Nimm als Zeiteinheit 1 an.
#* 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 [[Javakurs2007/ArrayList|ArrayList]])
#*die Länge der zu kriechenden Strecke
#:
#Überlege dir, welche dieser Werte bereits im Konstruktor 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 angenommenen 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 "rennenDurchfuehren()" 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.



== 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 ;)



==== Felix S. ====
"abhängig von ihrer Maximalgeschwindigkeit" verwirrte mehrmals Teilnehmer. Mathematischen Bezug/Verfahren hinschreiben bzw. erst mal auf das Kriechen konzentrieren.

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

Maschinenprogramm

2008-07-28T11:55:54Z

130.149.17.41: Die Seite wurde neu angelegt: Ein Maschinenprogramm ist eine Programm in binärer schreibweise und direkt durch die Hardware interpretierbar.

Ein Maschinenprogramm ist eine Programm in binärer schreibweise und direkt durch die Hardware interpretierbar.

TechGI 2 für TI (Bachelor)

2008-05-27T09:51:06Z

130.149.17.41: GHDL und VHDL Simili geadded

==TechGI 2 - Praktikum==
'''Technische Grundlagen der Informatik 2 - Praktikum''' ist ein begleitendes Modul zum [[TechGI_2_(Bachelor)]] für Technische Informatiker (im Bechalor System).
===Organisatorisches===
Die Lehrveranstaltung wird vom [http://manga.rt.cs.tu-berlin.de/ Fachgebiet Rechnertechnologie] angeboten. Es besteht ausschließlich aus Übungen im kleingruppen in dem VHDL vorgestellt wird und Schaltungen entworfen werden. Dabei ist das Schwehrpunkt die Sprache [[WikiPedia:VHDL|VHDL]], beim Schaltungen wird auf dem wissen aus [[TechGI_1_(Bachelor)]] basiert.
In diesem Veranstaltung ist ein unbenoteter Schein zu erwerben anhand der in Kleingruppen erbrahten Leistungen mit mündlichen Rucksprache beim Übungsleiter. Zu den Leistungen gehört das Entwurf von Schaltungen im VHDL sowie das erarbeiten von verschiedenen Theorieaufgaben.
===Entwurf elektronischer Schaltungen===
Zeil des Veranstaltungs ist es ein Überblick beim Studiereneden zu schaffen über dem Entwurf von Hardware mit Unterschtützung von Profesionellen Simulationssoftware. Dazu gehört auch das Simulieren und Testen von dem entworfenen Bausteinen.
===VHDL===
Zum entwurd von Hardware wird die gängige Hardwarebeschreibungssprache [[WikiPedia:VHDL|VHDL]] genutzt. Es ist ein internationaler Standart und somit ist die Sprache auch sehr gut an mehreren Stellen dokumentiert. Zum Lehrveranstaltung wird ein begleitendes Buch im elektronischer Form zur verfügung gestellt. Es gibt noch weitere empfehlenswerte Positionen im Universitätsbibliothek.
==Arbeitsumgebung==
===ModelSim===
Als Arbeitsumgebung wird [http://www.model.com/ ModelSim] genutzt. Es ist eine Professionelle Arbeitsumgebung mit hohen Leistusngsfächigkeit. Es gibt versionen für meiste gängige Betriebssysteme.
Es ist im ZRZ-Netz auf Sun-Rechner verfügbar. Dazu bietet das Unternehmen noch Studentenversionen mit Lizensen für 180 Tage (die man aber ohne weiteres verlängern kann falls nötig). Leider ist diese Version nur für Windowsumgebung verfügbar. Man muss dabei beachten beim Downloaden nicht die Evaluationsversion zu unterladen und dazu unabhängig die Studentenlizenz, sondern das ganze Program sich gleich über den [http://www.model.com/resources/student_edition/download.asp Studentenprogram] zu besorgen.
Wie man mit dem Program arbeitet wird im Übung vorgestellt.
===Laufanweisungen für Linux===
Es gibt mehrere Möglichkeiten die Studentenversion vom ModelSim unter Linux zu laufen.
====Wine====
TODO: Es ist mir gelungen ModelSim unter Wine zum laufen zu kriegen. Irgendwie nutzte ich diese Option aber nicht mehr. Also was musste schiefgelaufen haben, bzw. ich habe einfach damals noch die falsche Version untergeladet und daswegen aufgegeben. Also mutig probieren und hier anweisungen einfügen.
====Virtual Machine====
Eine Möglichkeit ist es, eine Windows Virtual-Machine zu einrichten und dadraf ModelSim zu laufen. Es geht auf modernen Rechnern recht schnell. Windows kann man sich frei über [[MSDNAA]] besorgen, also es sollte auch nicht das Problem sein. Freies Desktopvirtualisationsoftware gibt es für Linux auch genüg, z.B. KVM (bzw. QEMU), VMWare Server und VirtualBox.
====X-Weiterleitung vom CS-Netz====
Man kann auch versuchen sich zum CS-Netz mit SSH zu verbinden und die X-Session weiterzuleiten. Die genauen Anweisugen stehen in dem Artikel über [[SSH]] zur verfügung. Es wird aber eine (sehr) schnelle und stabile Internetverbindung benötigt. Die Nachteile sind natürlich vor allem dass man dem zugriff auf Dateien nicht offline hat.
====Alternative: GHDL/GTKWave====
Eine Alternative für ModelSim ist der freie gcc-basierende VHDL-Simulator [http://ghdl.free.fr/ GHDL].
Er ist in den Paketquellen aller größeren Distributionen (Ubuntu, Gentoo :) ) und unterstützt VHDL87 und VHDL93 nahezu perfekt. Dazu erzeugt er Binaries der VHDL-Quellcodes, mit denen Waveform-Files (.vcd) erstellt werden können, die ihrerseits z.B. in [http://home.nc.rr.com/gtkwave/ GTKWave] begutachtet werden können. Editiert können die VHDL Files z.B. mit Kate (über settings ist ein VHDL-Syntax Highlighting aktivierbar).
Beispiele wie GHDL/GTKWave verwendet werden findet man z.B. [http://fpgalibre.sourceforge.net/ingles.html#tp18 hier], auf Anfrage kann ich auch ein kleines Tutorial zusammenbauen.
Das Vorführen mit GTKWave/GHDL wurde (zumindest bei mir) problemlos akzeptiert.
====Alternative 2: VHDL Simili====
[http://www.symphonyeda.com/products.htm VHDL-Simili] ist ein kommerzieller VHDL-Simulator inkl. Waveform-Interface, der ModelSim _sehr_ ähnlich sieht. Die GUI basiert auch auf dem hässlichen TKL/TK, hat einen eigenen Quelltext-Editor mit Syntax Highlighting. Er ist in einer Speziellen Free-Version für Windows und Linux ohne Anmeldung kostenlos herunterladbar. Allerdings ist die Free-Version von der Leistung und Funktionsumfang eingeschränkt (Sollte für TechGI 2 Praktikum aber ausreichen) und die mitgelieferte Lizenz nur bis Oktober 2008 gültig (Stand Mai 08). Jedoch ist es gut Möglich, dass eine kostenlose Lizenzverlängerung der Free-Version bis dahin zur Verfügung gestellt wird.
[[Kategorie: Lehrveranstaltungen]]

Javakurs/Übungsaufgaben/Cäsar-Chiffre

2008-04-10T10:41:54Z

130.149.17.41:

Im Folgenden soll ein Programm weitgehend selbstständig entwickelt werden. Lies dir das nötige Wissen zur [[wikipedia:Verschiebechiffre|Cäsar-Chiffre]] in der Wikipedia an und überlege dir selbst eine Struktur für dein Programm.

Mache dir auch Gedanken darüber, wie du die einzelnen Teile deines Programms frühzeitig, am besten gleich beim Entwickeln, auch testen kannst.

== Aufgaben ==

=== Verschlüsseln ===

Erstelle ein Programm, das eine Variable mit Text enthält. Dein Programm soll diesen Text mit einem Passwort durch eine Cäsar-Chiffre verschlüsseln, und dann auf der Konsole ausgeben.

Das geht auch komfortabler, ist aber dann mit ein wenig mehr Aufwand verbunden (Tipps siehe unten):
* Der Text soll aus einer Datei eingelesen werden.
* Der chiffrierte Text soll in einer neuen Datei gespeichert werden.

=== Entschlüsseln ===

Erweitere dein Programm so, dass es einen mit verschlüsselten Text bei gegebendem Passwort entschlüsseln kann. Speichere den entschlüsselten Text in einer seperaten Datei.

=== Schlüssel knacken ===
Erweitere dein Programm so, dass es in der Lage ist, einen beliebigen mit einer Cäsar-Chiffre verschlüsselten Text zu entschlüsseln. Hierfür soll [[wikipedia:Häufigkeitsanalyse|Häufigkeitsanalyse]] benutzt werden, das heißt das Passwort ist nicht bekannt. Gib auch das gefundene Passwort an.

'''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.

=== Weiterführendes ===

Wenn du willst, kannst du deinen Chiffrieralgorythmus auch verändern oder einen anderen implementieren, mache das im Link zu deinen damit verschlüsselten Texten aber auch kenntlich. Denke daran, dass du selbst in der Lage sein solltest, deine Texte bei gegebendem Passwort zu entschlüsseln ;)

=== Tipps ===

Das Einlesen von Dateien gestaltet sich in Java etwas komplizierter. Wir haben euch aus diesem Grunde hier, ähnlich wie bei der Terminaleingabe, eine Bibliotheksklasse gebaut, die euch ein wenig Arbeit abnimmt.

[http://docs.freitagsrunde.org/Veranstaltungen/javakurs_2007/vorgaben/EasyFileAccess.java http://docs.freitagsrunde.org/Veranstaltungen/javakurs_2007/vorgaben/EasyFileAccess.java]

Mit Hilfe der Funktion <code>EasyFileAccess.getFileContent("Dateipfad")</code> könnt ihr so den Inhalt einer kompletten Datei zeilenweise in ein String-Array lesen.

Mit Hilfe der Funktion <code>EasyFileAccess.writeArrayToFile("Dateipfad", daten)</code> könnt ihr den Inhalt eines String-Arrays in eine Datei schreiben.

== Javakurs Gemeinschafts-Hacking ==
Trage einen von dir verschlüsselten Text mit mindestens 50 Zeichen hier im Wiki ein, und nenne dazu deinen Namen (Link: "bearbeiten"). Entschlüssele die Texte anderer Teilnehmer, die hier verlinkt sind.



==== Robert B. (rbu) ====
"EBG Guvegrra" vfg rvar qre rvasnpufgra Irefpuvrorpuvssera (Pnrfnepuvssera). Uvre jveq nyf Cnffjbeg qvr Mnuy Qervmrua trjnruyg, qnqhepu vfg qre Cebtenzzpbqr mhz Ragfpuyhrffrya tyrvpu qrz mhz Irefpuyhrffrya.

==== Jacob S. ====
"Qyhh xo xcwb ohx xyh Zychx eyhhmn, vluowbmn xo xyh Uomauha pih bohxyln Mwbfuwbnyh hcwbn to zoylwbnyh. Qyhh xo xcwb myfvmn eyhhmn, xiwb hcwbn xyh Zychx, qclmn xo zoyl dyxyh Mcya, xyh xo yllchamn, ychy Hcyxylfuay ylfycxyh. Qyhh xo qyxyl xyh Zychx hiwb xcwb myfvmn eyhhmn, qclmn xo ch dyxyl Mwbfuwbn ohnylfcyayh." - Mohtc (Xcy Eohmn xym Elcyaym)

=== Eric N. ===
"ylclunl pz h kpzo ilza zlyclk jvsk." -mhtvbz rspunvu wyvclyi

=== Thomas.T ===
"Zkork jkot Coyykt. Jgy oyz kot Ckm, Atyzkxhroinqkoz fa kxrgtmkt."-- Jgrgo Rgsg

== 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/MathematischeMethoden

2008-04-09T15:51:35Z

130.149.17.41: /* Kommentare */

Im Folgenden wollen wir einige (mathematische)-Methoden programmieren.

* Lege eine neue Klasse "MatheAufgabe" an.
* Füge eine <code>public static void main(String[] arguments)</code> Methode hinzu.
* Deklariere innerhalb der <code>main</code>-Methode eine <code>double</code>-Variable.
* Belege diese Variable dem Wert <code>5.0/3.0</code> und gib den Inhalt der Variable auf dem Bildschirm aus.
* Schreibe nun eine Methode <code>public static double add(double x, double y)</code>, die die Summe der beiden übergebenen Zahlen <code>x</code> und <code>y</code> zurückgibt.
** Teste deine Methode mit verschiedenen Eingaben wie z.B.
<nowiki>
System.out.println( " 1.0 + 2.0 = " + add ( 1.0 , 2.0 ) );
double x = 5.0;
System.out.println( " " + x + " + 2.0 = " + add ( x , 2.0 ) );
System.out.println( " 2.0 + " + x + " = " + add ( 2.0 , x ) );
x = add ( x , 2.0 );
System.out.println( x );
</nowiki>
* Schreibe nun eine Methode <code>sub</code>, welche die Differenz zweier übergebener Werte zurückgibt.
** Teste deine Methode wie eben!
** Überprüfe, ob x == ( x - y ) + y gilt! (natürlich mit deinen <code>sub</code> und <code>add</code>-Modthoden)
* Schreibe nun eine <code>mul</code>-Methode für <code>int</code>.
** Benutze dazu nicht den operator *, sondern die Addition (+).
** Teste deine Methode wie eben!
* Schreibe nun eine <code>public static double pow ( double basis, int exponent )</code>, die <code>basis</code> hoch <code>exponent</code> zurückgibt. <code>pow( 2,3 )</code> wurde z.B. 2^3=8 zurückgeben.
** Benutze auch hier weder *, noch Math.pow(). Nutze stattdessen deine gerade geschriebene mul-Methode.
** Teste deine Methode wie gehabt!
**: Was liefert deine Methode wenn der Exponent 0 ist?
**: Was liefert deine Methode wenn der Exponent negativ ist?

== 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 ;)



"Füge eine public static void main(Strings[] arguments) Methode hinzu." <-- Das muss
"Füge eine public static void main(String[] arguments) Methode hinzu." heißen!

: Änder es ruhig. Nun hab ich's aber schon gemacht. -- [[Benutzer:Buchholz|Robert Buchholz]]

Meine geschriebene mul-Methode kann ich nicht zum Schreiben dieser pow-Methode -->

: public static double pow ( double basis, int exponent) {
:: double powProduct = 1.0;
:: for (int i=0; i<exponent; i=i+1) {
::: powProduct = mul(powProduct,basis);
:: }
:: return powProduct;
: }

benutzt werden, da die mul-Methode als Eingabeparameter int erwartet.
Wie soll diese Aufgabe gelöst werden?

Javakurs/Übungsaufgaben/MathematischeMethoden

2008-04-09T15:49:02Z

130.149.17.41: /* Kommentare */

Im Folgenden wollen wir einige (mathematische)-Methoden programmieren.

* Lege eine neue Klasse "MatheAufgabe" an.
* Füge eine <code>public static void main(String[] arguments)</code> Methode hinzu.
* Deklariere innerhalb der <code>main</code>-Methode eine <code>double</code>-Variable.
* Belege diese Variable dem Wert <code>5.0/3.0</code> und gib den Inhalt der Variable auf dem Bildschirm aus.
* Schreibe nun eine Methode <code>public static double add(double x, double y)</code>, die die Summe der beiden übergebenen Zahlen <code>x</code> und <code>y</code> zurückgibt.
** Teste deine Methode mit verschiedenen Eingaben wie z.B.
<nowiki>
System.out.println( " 1.0 + 2.0 = " + add ( 1.0 , 2.0 ) );
double x = 5.0;
System.out.println( " " + x + " + 2.0 = " + add ( x , 2.0 ) );
System.out.println( " 2.0 + " + x + " = " + add ( 2.0 , x ) );
x = add ( x , 2.0 );
System.out.println( x );
</nowiki>
* Schreibe nun eine Methode <code>sub</code>, welche die Differenz zweier übergebener Werte zurückgibt.
** Teste deine Methode wie eben!
** Überprüfe, ob x == ( x - y ) + y gilt! (natürlich mit deinen <code>sub</code> und <code>add</code>-Modthoden)
* Schreibe nun eine <code>mul</code>-Methode für <code>int</code>.
** Benutze dazu nicht den operator *, sondern die Addition (+).
** Teste deine Methode wie eben!
* Schreibe nun eine <code>public static double pow ( double basis, int exponent )</code>, die <code>basis</code> hoch <code>exponent</code> zurückgibt. <code>pow( 2,3 )</code> wurde z.B. 2^3=8 zurückgeben.
** Benutze auch hier weder *, noch Math.pow(). Nutze stattdessen deine gerade geschriebene mul-Methode.
** Teste deine Methode wie gehabt!
**: Was liefert deine Methode wenn der Exponent 0 ist?
**: Was liefert deine Methode wenn der Exponent negativ ist?

== 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 ;)



"Füge eine public static void main(Strings[] arguments) Methode hinzu." <-- Das muss
"Füge eine public static void main(String[] arguments) Methode hinzu." heißen!

: Änder es ruhig. Nun hab ich's aber schon gemacht. -- [[Benutzer:Buchholz|Robert Buchholz]]

Meine geschriebene mul-Methode kann ich nicht zum Schreiben dieser pow-Methode -->

: public static double pow ( double basis, int exponent) {
:: double powProduct = 1.0;
:: for (int i=0; i<exponent; i=i+1) {
::: powProduct = mul(powProduct,basis);
:: }
:: return powProduct;
: }

benutzt werrden, da die mul-Methode als Eingabeparameter int erwartet.
Wie soll diese Aufgabe gelöst werden?

Javakurs2008/Tutorenportal

2008-04-08T12:35:08Z

130.149.17.41: /* Raumauslastung + Tutorenverteilung */

== Links ==

* [[Javakurs2008]]
* [[Javakurs2008/Orga]]
* [[Javakurs2008/Gliederung_Javakurs_2008]]
* [[Javakurs2008/%C3%9Cbungspool]]

== Raumauslastung + Tutorenverteilung ==
Die Auslastung der Räume mit Tutanden wird dynamisch von den jeweiligen Tutoren eingetragen, um ein "load balancing" von Tutanden zu ermöglichen.

Eine Hilfe zum Eintragen der Raumauslastung steht im Quelltext der Tabelle.

'''Rote Zeilen bedeuten dass hier die eine Umverteilung statt finden sollte ....'''

'''Montag, Dienstag, Mittwoch:'''
{| border="0" cellpadding="4" cellspacing="2"
|- bgcolor="#D8D8D8"
! Raum
! Tutoren
! Tut#
! Plätze
! Motto
! Tutanden anwesend

|- bgcolor="#F5F5F5"
| MA241
| Sebastian D, Alex, Milan
| 3
| ~40
| '''UNIX POOL'''
| Mo (16/11) 

|- bgcolor="#E8E8E8"
| FR2516
| Reiner, Björn B.
| 2
| ~25
| '''Notebookraum A'''
| Mo (21/13), Di (17/--) 

|- bgcolor="#F5F5F5"
| FR2517
| Björn L., Michael
| 2
| 12
| 34d45f313e4edafb599a62ff4d30ca88
| Mo (11/9), Di (6/-) 

|- bgcolor="#E8E8E8"
| FR5083
| Florian
| 1
| 6
| yvahk ebk!
| Mo (6/1) 

|- bgcolor="#F5F5F5"
| FR5087
| Martin Z., Gert
| 2
| ~15
| Notebookraum B '''- closed'''
| Mo (15/3) 

|- bgcolor="#E8E8E8"
| FR5535
| Felix, Dan
| 2
| 14
| Sprache: Englisch, Deutsch; '''Zentrale für eventuelle Probleme und Kommunikation'''
| Mo (11/9) 

|- bgcolor="#F5F5F5"
| FR5538
| Daniel, Katrin
| 2
| 12
| Eisentölpel
| Mo (12/5) 

|- bgcolor="#E8E8E8"
| FR5539
| Kai, Nadim
| 2
| 12
| (C)Ulli
| Mo (8/8), Di (10/10) 10

|- bgcolor="#F5F5F5"
| FR6514
| Mario, Rbubert
| 2
| 13
| ... INSERT WITTY COMMENT HERE ...
| Mo (7/4) Di(5/-) 
|}

'''Tabellen für jeden Tag duplizieren.'''

'''Orga-Raum:''' FR5535

== Abwesenheiten ==
* Zeiträume in denen Tutoren aus diversen Gründen vorraussichtlich nicht anwesend sein können werden hier aufgelistet (Es geht um mehrstündige Abwesenheit, nicht um früher gehen oder Mittagspäuschen ;) )

Mo. 10-12 Uhr (Nadim FR5539)

== Kommunikation ==

Zur Kommunikation während der Tutorien stehen uns mehrere Medien zur Verfügung (siehe unten). Diese wird nötig sein, um z.B. auf (gefixte) Bugs in Aufgabenstellungen aufmerksam zu machen. (!)
Solche "Broadcast"-Nachrichten sollten über die Mailingliste ( siehe unten) gehen. Andere Kommunikation, wie z.B. wenn man Mal auf eine Frage keine Antwort weiss und einen anderen Tutor fragen will, könnte übers IRC gehen.
Auch der Weg zu Fuß in einen anderen Raum um dort zu fragen, sollte natürlich nicht ausgeschlossen werden ;-)

=== Mailingliste ===
* javakurs-vl at lists.freitagsrunde.org
* javakurs-tut at lists.freitagsrunde.org

=== IRC ===
* Server: irc.freenode.net [http://freenode.net/irc_servers.shtml mehr Server...]
* Channel: #freitagsrunde

== Misc ==
* Nachbesprechung täglich 16.15 im Freitagsrundenraum ([[FR 5046]]).
* [http://docs.freitagsrunde.org/Veranstaltungen/javakurs_2007/orga/Bsp_Stunden.JPG Beispiel-Abrechnung] für Kursveranstalter/Tutoren

== Statistik ==
Zuhörer Tag 1, VL1: ca. 95-100

== Review von Aufgaben ==

# [[Javakurs2007/Von der Console zum HelloWorld | Vom Arbeiten mit der Konsole bis "Hallo Welt"]] (Felix)
# [[Javakurs2007/Variablen_und_Zuweisungen | Variablen und Zuweisungen]] (Felix)
# [[Javakurs2007/Cowsay | Cowsay oder "Wie macht die Kuh?"]] (Gert)
# [[Javakurs2007/Kassenbon | Erstellen eines Kassenbons]] (Daniel K)
# [[Javakurs2007/Javamenue | Ein eigenes Menü]] (Daniel K)
# [[Javakurs2007/Glücksspiel | Glücksspiel]] (Daniel K)
# [[Javakurs2007/Arrays | Quickies Arrays]] (Daniel K)
# [[Javakurs2007/Verschachtelte_Schleifen | Verschachtelte Schleifen]] (Gert)
# [[Javakurs2007/Primzahlenaufgabe | Primzahlen]] (Björn L.)
# [[Javakurs2007/Wetterstation | Wetterstation]] (Daniel K)
# [[Javakurs2007/Geometrie | Geometrie]] (Michael)
# [[Javakurs2007/Zweierpotenzen | Zweierpotenzen]] (Michael)
# [[Javakurs2007/Schleifen_und_Modulo | Schleifen und Modulo]] (Björn L.)
# [[Javakurs2007/Methoden | Quickies zu Methoden]] (Björn B.)
# [[Javakurs2007/MathematischeMethoden | Eigene Methoden]] (Björn B.)
# [[Javakurs2007/Schaltjahr | Schaltjahr]] Nadim
# [[Javakurs2007/Crack_the_Password | Crack the Password]] (Daniel K)
# [[Javakurs2007/Rekursion_vs._Iteration | Rekursion vs. Iteration]] (Martin Z.)
# [[Javakurs2007/Lineare_Funktionen | Lineare Funktionen]] (Gert)
# [[Javakurs2007/Fibonacci | Fibonaccizahlen]] Alex
# [[Javakurs2007/Brainfuck | Brainfuck vs Turingmaschine]] (Daniel K)
# [[Javakurs2007/Gau%C3%9F-Algorithmus | Gauß-Algorithmus]] Alex
# [[Javakurs2007/Zahlenumrechner | Zahlenumrechner]] (Michael)
# [[Javakurs 2007/Democracy | Der Fehler im System]] (Björn L.)
# [[Javakurs2007/Quersumme | Spaß mit Quersummen]] Nadim
# [[Javakurs2007/Appleman | Appleman und Fraktale]] Kai
# [[Javakurs2007/DiffusionLimitedAggregation | Diffusion Limited Aggregation]] Kai
# [[Javakurs2007/Palindrome | Palindrome]] Nadim
# [[Javakurs2007/Hangman | Hangman]] Alex
# [[Javakurs2007/SelectionSort | Selection Sort]] (Martin Z.)
# [[Javakurs2007/Cäsar-Chiffre | Chiffrierung/Dechiffrierung (Cäsar)]] (Cäsar, ähh.. Rbu)
# [[Javakurs2007/Abzaehlspiel | Abzählspiel]] (Björn B.)
# [[Javakurs2006/Rennschnecke | Schneckenrennen]] (Daniel K)
# [[Javakurs2007/Studentendatenbank_LE5 | Studentendatenbank]] (Dan)
# [[Javakurs2007/Multiarray| Mehrdimensionale Arrays]] (Dan)
# [[Javakurs2007/Canvas | Virtuelles Canvas mit 3D-Objekten]] Kai
# [[Javakurs2007/Doom | ASCII DOOM ]] (Dan)
# [[Javakurs2007/Textwordcount | Texte lesen und analysieren]] (Daniel K)

Javakurs/Übungsaufgaben/Methoden

2008-04-08T09:28:50Z

130.149.17.41: /* Fehler? */

'''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 i, String string ) {
System.out.println( i + ": " + string );
}
}
</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/Methoden

2008-04-08T09:27:43Z

130.149.17.41: /* Robert */

'''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 i, String string ) {
System.out.println( i + ": " + string );
}
}
</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?====
Beispiel.java werden die Methoden mit falscher Reihenfolge der Parameter aufgerufen:

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

ausgabe("Robert", 4); -> fehler

Javakurs2008/Tutorenportal

2008-04-08T08:55:05Z

130.149.17.41: /* Raumauslastung + Tutorenverteilung */

== Links ==

* [[Javakurs2008]]
* [[Javakurs2008/Orga]]
* [[Javakurs2008/Gliederung_Javakurs_2008]]
* [[Javakurs2008/%C3%9Cbungspool]]

== Raumauslastung + Tutorenverteilung ==
Die Auslastung der Räume mit Tutanden wird dynamisch von den jeweiligen Tutoren eingetragen, um ein "load balancing" von Tutanden zu ermöglichen.

Eine Hilfe zum Eintragen der Raumauslastung steht im Quelltext der Tabelle.

'''Rote Zeilen bedeuten dass hier die eine Umverteilung statt finden sollte ....'''

'''Montag, Dienstag, Mittwoch:'''
{| border="0" cellpadding="4" cellspacing="2"
|- bgcolor="#D8D8D8"
! Raum
! Tutoren
! Tut#
! Plätze
! Motto
! Tutanden anwesend

|- bgcolor="#F5F5F5"
| MA241
| Sebastian D, Alex, Milan
| 3
| ~40
| '''UNIX POOL'''
| Mo (16/11) 

|- bgcolor="#E8E8E8"
| FR2516
| Reiner, Björn B.
| 2
| ~25
| '''Notebookraum A'''
| Mo (21/13) 

|- bgcolor="#F5F5F5"
| FR2517
| Björn L., Michael
| 2
| 12
| 34d45f313e4edafb599a62ff4d30ca88
| Mo (11/9) 

|- bgcolor="#E8E8E8"
| FR5083
| Florian
| 1
| 6
| yvahk ebk!
| Mo (6/1) 

|- bgcolor="#F5F5F5"
| FR5087
| Martin Z., Gert
| 2
| ~15
| '''Notebookraum B'''
| Mo (15/3) 

|- bgcolor="#E8E8E8"
| FR5535
| Felix, Dan
| 2
| 14
| Sprache: Englisch, Deutsch; '''Zentrale für eventuelle Probleme und Kommunikation'''
| Mo (11/9) 

|- bgcolor="#F5F5F5"
| FR5538
| Daniel, Katrin
| 2
| 12
| Eisentölpel
| Mo (12/5) 

|- bgcolor="#E8E8E8"
| FR5539
| Kai, Nadim
| 2
| 12
| (C)Ulli
| Mo (8/8), Di (10/-) 

|- bgcolor="#F5F5F5"
| FR6514
| Mario, Rbubert
| 2
| 13
| Emerge The Gimp. But the Gimp's Masked! Well, ACCEPT_KEYWORD....
| Mo (7/4) 
|}

'''Tabellen für jeden Tag duplizieren.'''

'''Orga-Raum:''' FR5535

== Abwesenheiten ==
* Zeiträume in denen Tutoren aus diversen Gründen vorraussichtlich nicht anwesend sein können werden hier aufgelistet (Es geht um mehrstündige Abwesenheit, nicht um früher gehen oder Mittagspäuschen ;) )

Mo. 10-12 Uhr (Nadim FR5539)

== Kommunikation ==

Zur Kommunikation während der Tutorien stehen uns mehrere Medien zur Verfügung (siehe unten). Diese wird nötig sein, um z.B. auf (gefixte) Bugs in Aufgabenstellungen aufmerksam zu machen. (!)
Solche "Broadcast"-Nachrichten sollten über die Mailingliste ( siehe unten) gehen. Andere Kommunikation, wie z.B. wenn man Mal auf eine Frage keine Antwort weiss und einen anderen Tutor fragen will, könnte übers IRC gehen.
Auch der Weg zu Fuß in einen anderen Raum um dort zu fragen, sollte natürlich nicht ausgeschlossen werden ;-)

=== Mailingliste ===
* javakurs-vl at lists.freitagsrunde.org
* javakurs-tut at lists.freitagsrunde.org

=== IRC ===
* Server: irc.freenode.net [http://freenode.net/irc_servers.shtml mehr Server...]
* Channel: #freitagsrunde

== Misc ==
* Nachbesprechung täglich 16.15 im Freitagsrundenraum ([[FR 5046]]).
* [http://docs.freitagsrunde.org/Veranstaltungen/javakurs_2007/orga/Bsp_Stunden.JPG Beispiel-Abrechnung] für Kursveranstalter/Tutoren

== Statistik ==
Zuhörer Tag 1, VL1: ca. 95-100

== Review von Aufgaben ==

# [[Javakurs2007/Von der Console zum HelloWorld | Vom Arbeiten mit der Konsole bis "Hallo Welt"]] (Felix)
# [[Javakurs2007/Variablen_und_Zuweisungen | Variablen und Zuweisungen]] (Felix)
# [[Javakurs2007/Cowsay | Cowsay oder "Wie macht die Kuh?"]] (Gert)
# [[Javakurs2007/Kassenbon | Erstellen eines Kassenbons]] (Daniel K)
# [[Javakurs2007/Javamenue | Ein eigenes Menü]] (Daniel K)
# [[Javakurs2007/Glücksspiel | Glücksspiel]] (Daniel K)
# [[Javakurs2007/Arrays | Quickies Arrays]] (Daniel K)
# [[Javakurs2007/Verschachtelte_Schleifen | Verschachtelte Schleifen]] (Gert)
# [[Javakurs2007/Primzahlenaufgabe | Primzahlen]] (Björn L.)
# [[Javakurs2007/Wetterstation | Wetterstation]] (Daniel K)
# [[Javakurs2007/Geometrie | Geometrie]] (Michael)
# [[Javakurs2007/Zweierpotenzen | Zweierpotenzen]] (Michael)
# [[Javakurs2007/Schleifen_und_Modulo | Schleifen und Modulo]] (Björn L.)
# [[Javakurs2007/Methoden | Quickies zu Methoden]] (Björn B.)
# [[Javakurs2007/MathematischeMethoden | Eigene Methoden]] (Björn B.)
# [[Javakurs2007/Schaltjahr | Schaltjahr]] Nadim
# [[Javakurs2007/Crack_the_Password | Crack the Password]] (Daniel K)
# [[Javakurs2007/Rekursion_vs._Iteration | Rekursion vs. Iteration]] (Martin Z.)
# [[Javakurs2007/Lineare_Funktionen | Lineare Funktionen]] (Gert)
# [[Javakurs2007/Fibonacci | Fibonaccizahlen]] Alex
# [[Javakurs2007/Brainfuck | Brainfuck vs Turingmaschine]] (Daniel K)
# [[Javakurs2007/Gau%C3%9F-Algorithmus | Gauß-Algorithmus]] Alex
# [[Javakurs2007/Zahlenumrechner | Zahlenumrechner]] (Michael)
# [[Javakurs 2007/Democracy | Der Fehler im System]] (Björn L.)
# [[Javakurs2007/Quersumme | Spaß mit Quersummen]] Nadim
# [[Javakurs2007/Appleman | Appleman und Fraktale]] Kai
# [[Javakurs2007/DiffusionLimitedAggregation | Diffusion Limited Aggregation]] Kai
# [[Javakurs2007/Palindrome | Palindrome]] Nadim
# [[Javakurs2007/Hangman | Hangman]] Alex
# [[Javakurs2007/SelectionSort | Selection Sort]] (Martin Z.)
# [[Javakurs2007/Cäsar-Chiffre | Chiffrierung/Dechiffrierung (Cäsar)]] (Cäsar, ähh.. Rbu)
# [[Javakurs2007/Abzaehlspiel | Abzählspiel]] (Björn B.)
# [[Javakurs2006/Rennschnecke | Schneckenrennen]] (Daniel K)
# [[Javakurs2007/Studentendatenbank_LE5 | Studentendatenbank]] (Dan)
# [[Javakurs2007/Multiarray| Mehrdimensionale Arrays]] (Dan)
# [[Javakurs2007/Canvas | Virtuelles Canvas mit 3D-Objekten]] Kai
# [[Javakurs2007/Doom | ASCII DOOM ]] (Dan)
# [[Javakurs2007/Textwordcount | Texte lesen und analysieren]] (Daniel K)

Javakurs2008/Tutorenportal

2008-04-07T14:02:02Z

130.149.17.41: /* Raumauslastung + Tutorenverteilung */

== Links ==

* [[Javakurs2008]]
* [[Javakurs2008/Orga]]
* [[Javakurs2008/Gliederung_Javakurs_2008]]
* [[Javakurs2008/%C3%9Cbungspool]]

== Raumauslastung + Tutorenverteilung ==
Die Auslastung der Räume mit Tutanden wird dynamisch von den jeweiligen Tutoren eingetragen, um ein "load balancing" von Tutanden zu ermöglichen.

Eine Hilfe zum Eintragen der Raumauslastung steht im Quelltext der Tabelle.

'''Rote Zeilen bedeuten dass hier die eine Umverteilung statt finden sollte ....'''

'''Montag, Dienstag, Mittwoch:'''
{| border="0" cellpadding="4" cellspacing="2"
|- bgcolor="#D8D8D8"
! Raum
! Tutoren
! Tut#
! Plätze
! Motto
! Tutanden anwesend

|- bgcolor="#F5F5F5"
| MA241
| Sebastian D, Alex, Milan
| 3
| ~40
| '''UNIX POOL'''
| 10 

|- bgcolor="#E8E8E8"
| FR2516
| Reiner, Björn B.
| 2
| ~25
| '''Notebookraum A'''
| 21 

|- bgcolor="#F5F5F5"
| FR2517
| Björn L., Michael
| 2
| 12
|
| 11(Vormittag), 9(Nachmittag) 

|- bgcolor="#E8E8E8"
| FR5083
| Florian
| 1
| 6
| yvahk ebk!
| 

|- bgcolor="#F5F5F5"
| FR5087
| Martin Z., Gert
| 2
| ~15
| '''Notebookraum B'''
| 14(Vormittag), 3(Nachmittag) 

|- bgcolor="#E8E8E8"
| FR5535
| Felix, Dan
| 2
| 14
| Sprache: Englisch, Deutsch; '''Zentrale für eventuelle Probleme und Kommunikation'''
| 

|- bgcolor="#F5F5F5"
| FR5538
| Daniel, Katrin
| 2
| 12
| Eisentölpel
| 

|- bgcolor="#E8E8E8"
| FR5539
| Kai, Nadim
| 2
| 12
| (C)Ulli
| 8 

|- bgcolor="#F5F5F5"
| FR6514
| Mario, Rbubert
| 2
| 13
| Emerge The Gimp. But the Gimp's Masked! Well, ACCEPT_KEYWORD....
| Vormittag: 7, Nachmittag: 4 
|}

'''Tabellen für jeden Tag duplizieren.'''

'''Orga-Raum:''' FR5535

== Abwesenheiten ==
* Zeiträume in denen Tutoren aus diversen Gründen vorraussichtlich nicht anwesend sein können werden hier aufgelistet (Es geht um mehrstündige Abwesenheit, nicht um früher gehen oder Mittagspäuschen ;) )

Mo. 10-12 Uhr (Nadim FR5539)

== Kommunikation ==

Zur Kommunikation während der Tutorien stehen uns mehrere Medien zur Verfügung (siehe unten). Diese wird nötig sein, um z.B. auf (gefixte) Bugs in Aufgabenstellungen aufmerksam zu machen. (!)
Solche "Broadcast"-Nachrichten sollten über die Mailingliste ( siehe unten) gehen. Andere Kommunikation, wie z.B. wenn man Mal auf eine Frage keine Antwort weiss und einen anderen Tutor fragen will, könnte übers IRC gehen.
Auch der Weg zu Fuß in einen anderen Raum um dort zu fragen, sollte natürlich nicht ausgeschlossen werden ;-)

=== Mailingliste ===
* javakurs-vl at lists.freitagsrunde.org
* javakurs-tut at lists.freitagsrunde.org

=== IRC ===
* Server: irc.freenode.net [http://freenode.net/irc_servers.shtml mehr Server...]
* Channel: #freitagsrunde

== Misc ==
* Nachbesprechung täglich 16.15 im Freitagsrundenraum ([[FR 5046]]).
* [http://docs.freitagsrunde.org/Veranstaltungen/javakurs_2007/orga/Bsp_Stunden.JPG Beispiel-Abrechnung] für Kursveranstalter/Tutoren

== Statistik ==
Zuhörer Tag 1, VL1: ca. 95-100

== Review von Aufgaben ==

# [[Javakurs2007/Von der Console zum HelloWorld | Vom Arbeiten mit der Konsole bis "Hallo Welt"]] (Felix)
# [[Javakurs2007/Variablen_und_Zuweisungen | Variablen und Zuweisungen]] (Felix)
# [[Javakurs2007/Cowsay | Cowsay oder "Wie macht die Kuh?"]] (Gert)
# [[Javakurs2007/Kassenbon | Erstellen eines Kassenbons]] (Daniel K)
# [[Javakurs2007/Javamenue | Ein eigenes Menü]] (Daniel K)
# [[Javakurs2007/Glücksspiel | Glücksspiel]] (Daniel K)
# [[Javakurs2007/Arrays | Quickies Arrays]] (Daniel K)
# [[Javakurs2007/Verschachtelte_Schleifen | Verschachtelte Schleifen]] (Gert)
# [[Javakurs2007/Primzahlenaufgabe | Primzahlen]] (Björn L.)
# [[Javakurs2007/Wetterstation | Wetterstation]] (Daniel K)
# [[Javakurs2007/Geometrie | Geometrie]] (Michael)
# [[Javakurs2007/Zweierpotenzen | Zweierpotenzen]] (Michael)
# [[Javakurs2007/Schleifen_und_Modulo | Schleifen und Modulo]] (Björn L.)
# [[Javakurs2007/Methoden | Quickies zu Methoden]] (Björn B.)
# [[Javakurs2007/MathematischeMethoden | Eigene Methoden]] (Björn B.)
# [[Javakurs2007/Schaltjahr | Schaltjahr]] Nadim
# [[Javakurs2007/Crack_the_Password | Crack the Password]] (Daniel K)
# [[Javakurs2007/Rekursion_vs._Iteration | Rekursion vs. Iteration]] (Martin Z.)
# [[Javakurs2007/Lineare_Funktionen | Lineare Funktionen]] (Gert)
# [[Javakurs2007/Fibonacci | Fibonaccizahlen]] Alex
# [[Javakurs2007/Brainfuck | Brainfuck vs Turingmaschine]] (Daniel K)
# [[Javakurs2007/Gau%C3%9F-Algorithmus | Gauß-Algorithmus]] Alex
# [[Javakurs2007/Zahlenumrechner | Zahlenumrechner]] (Michael)
# [[Javakurs 2007/Democracy | Der Fehler im System]] (Björn L.)
# [[Javakurs2007/Quersumme | Spaß mit Quersummen]] Nadim
# [[Javakurs2007/Appleman | Appleman und Fraktale]] Kai
# [[Javakurs2007/DiffusionLimitedAggregation | Diffusion Limited Aggregation]] Kai
# [[Javakurs2007/Palindrome | Palindrome]] Nadim
# [[Javakurs2007/Hangman | Hangman]] Alex
# [[Javakurs2007/SelectionSort | Selection Sort]] (Martin Z.)
# [[Javakurs2007/Cäsar-Chiffre | Chiffrierung/Dechiffrierung (Cäsar)]] (Cäsar, ähh.. Rbu)
# [[Javakurs2007/Abzaehlspiel | Abzählspiel]] (Björn B.)
# [[Javakurs2006/Rennschnecke | Schneckenrennen]] (Daniel K)
# [[Javakurs2007/Studentendatenbank_LE5 | Studentendatenbank]] (Dan)
# [[Javakurs2007/Multiarray| Mehrdimensionale Arrays]] (Dan)
# [[Javakurs2007/Canvas | Virtuelles Canvas mit 3D-Objekten]] Kai
# [[Javakurs2007/Doom | ASCII DOOM ]] (Dan)
# [[Javakurs2007/Textwordcount | Texte lesen und analysieren]] (Daniel K)

Javakurs/Übungsaufgaben/Wetterstation

2007-04-13T10:11:00Z

130.149.17.41:

=== Aufgabe ===

Eine Wetterstation hat für 14 Tage folgende Temperaturwerte aufgenommen.

Tag: 01 02 03 04 05 06 07 08 09 10 11 12 13 14
Temperatur: 12 14 9 12 15 16 15 15 11 8 13 13 15 12

# Speichere die folgende Tabelle mit einem geeigneten Datentyp.
# Schreibe ein Programm, welches die Durchschnittstemperatur für die zwei Wochen bestimmt.
# Schreibe ein Programm, welches die maximale und minimale Temperatur ausgibt.
# Schreibe ein Programm, welches die beiden aufeinanderfolgenden Tage angeben kann, an denen es den größten Temperaturumschwung gab.
# Schreibe ein Programm, welches die Tabelle schön tabellarisch auf der Konsole ausgibt.

== 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 ;)

==== Felix S. ====
Verwirrend fuer viele war, dass die Zahlen von 01-08 angegeben sind, weil man damit im Oktalsystem Probleme bekommt. Zudem waere es vielleicht einfacher, wenn der Tag wie ein Array bei 0 beginnt.

Javakurs/Übungsaufgaben/MathematischeMethoden

2007-04-11T09:28:09Z

130.149.17.41:

Im Folgenden wollen wir einige (mathematische)-Methoden programmieren.

* Lege eine neue Klasse "MatheAufgabe" an.
* Füge eine <code>public static void main(String[] arguments)</code> Methode hinzu.
* Deklariere innerhalb der <code>main</code>-Methode eine <code>double</code>-Variable.
* Belege diese Variable dem Wert <code>5.0/3.0</code> und gib den Inhalt der Variable auf dem Bildschirm aus.
* Schreibe nun eine Methode <code>public static double add(double x, double y)</code>, die die Summe der beiden übergebenen Zahlen <code>x</code> und <code>y</code> zurückgibt.
** Teste deine Methode mit verschiedenen Eingaben wie z.B.
<nowiki>
System.out.println(" 1.0 + 2.0 = " + add ( 1.0 , 2.0 ) );
double x = 5.0;
System.out.println( " " + x + " + 2.0 = " + add ( x , 2.0) );
System.out.println( " 2.0 + " + x + " = " + add ( 2.0 , x) );
x = add ( x , 2.0);
System.out.println( x);
</nowiki>
* Schreibe nun eine Methode <code>sub</code>, welche die Differenz zweier übergebener Werte zurückgibt.
** Teste deine Methode wie eben!
** Überprüfe, ob x == (x - y ) + y gilt! (natürlich mit deinen <code>sub</code> und <code>add</code>-Modthoden)
* Schreibe nun eine <code>mul</code>-Methode.
** Benutze dazu nicht den operator *. Rufe statt dessen deine add-Methode auf.
** Teste deine Methode wie eben!
* Schreibe nun eine <code>public static double pow ( double basis, int exponent)</code>, die <code>basis</code> hoch <code>exponent</code> zurückgibt. <code>pow(2,3)</code> wurde z.B. 2^3=8 zurückgeben.
** Benutze auch hier weder *, noch Math.pow(). Nutze statt dessen deine gerade geschriebene mul-Methode.
** Teste deine Methode wie gehabt!
**: Was liefert deine Methode wenn der Exponent 0 ist?
**: Was liefert deine Methode wenn der Exponent negativ ist?

== 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 ;)



"Füge eine public static void main(Strings[] arguments) Methode hinzu." <-- Das muss
"Füge eine public static void main(String[] arguments) Methode hinzu." heißen!

: Änder es ruhig. Nun hab ich's aber schon gemacht. -- [[Benutzer:Buchholz|Robert Buchholz]]

Javakurs/Übungsaufgaben/MathematischeMethoden

2007-04-11T08:52:19Z

130.149.17.41: /* Kommentare */

Im Folgenden wollen wir einige (mathematische)-Methoden programmieren.

* Lege eine neue Klasse "MatheAufgabe" an.
* Füge eine <code>public static void main(Strings[] arguments)</code> Methode hinzu.
* Deklariere innerhalb der <code>main</code>-Methode eine <code>double</code>-Variable.
* Belege diese Variable dem Wert <code>5/3</code> und gib den Inhalt der Variable auf dem Bildschirm aus.
* Schreibe nun eine Methode <code>public static double add(double x, double y)</code>, die die Summe der beiden übergebenen Zahlen <code>x</code> und <code>y</code> zurückgibt.
** Teste deine Methode mit verschiedenen Eingaben wie z.B.
<nowiki>
System.out.println(" 1.0 + 2.0 = " + add ( 1.0 , 2.0 ) );
double x = 5.0;
System.out.println( " " + x + " + 2.0 = " + add ( x , 2.0) );
System.out.println( " 2.0 + " + x + " = " + add ( 2.0 , x) );
x = add ( x , 2.0);
System.out.println( x);
</nowiki>
* Schreibe nun eine Methode <code>sub</code>, welche die Differenz zweier übergebener Werte zurückgibt.
** Teste deine Methode wie eben!
** Überprüfe, ob x == (x - y ) + y gilt! (natürlich mit deinen <code>sub</code> und <code>add</code>-Modthoden)
* Schreibe nun eine <code>mul</code>-Methode.
** Benutze dazu nicht den operator *. Rufe statt dessen deine add-Methode auf.
** Teste deine Methode wie eben!
* Schreibe nun eine <code>public static double pow ( double basis, int exponent)</code>, die <code>basis</code> hoch <code>exponent</code> zurückgibt. <code>pow(2,3)</code> wurde z.B. 2^3=8 zurückgeben.
** Benutze auch hier weder *, noch Math.pow(). Nutze statt dessen deine gerade geschriebene mul-Methode.
** Teste deine Methode wie gehabt!
**: Was liefert deine Methode wenn der Exponent 0 ist?
**: Was liefert deine Methode wenn der Exponent negativ ist?

== 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 ;)



"Füge eine public static void main(Strings[] arguments) Methode hinzu." <-- Das muss
"Füge eine public static void main(String[] arguments) Methode hinzu." heißen!

Basisveranstaltung

2007-04-03T10:48:02Z

130.149.17.41: neu und verbessert

==Was sind Basisveranstaltungen?==

Basisveranstaltung sind Vorlesungen im Hauptstudium des Studiengangs Informatik (Dipl.). Diese sollen die Grundlagen innerhalb eines Fachgebietes vermitteln und dem Studenten einen Überblick über den Inhalt des Fachgebiets geben.
Im [[Hauptstudium]] sind mindestens 4, maximal 6 Basisveranstaltungen zu belegen. Davon muessen wenigstens 3 aus dem [[Katalog A]] sein.

==Liste von Basisveranstaltungen==

(Erhebt keinen Anspruch auf Korrektheit und Vollständigkeit. Die Stichwortsuche des [[Vorlesungsverzeichnis]] hilft hier weiter)

====Katalog A====

* [[Grundlagen der Informationsmodellierung]] (SS)
* [[Semantik und Kalkül]] (SS)
* [[Entwurfsautomatisierung digitaler Systeme]] (SS)
* [[Algebraische Prozesskalküle]] (SS)
* [[Verteilte Systeme]] (SS)
* [[Softwaretechnik]] (WS/SS)

* [[Telekommunikationsnetze]]
* [[Programmiersprachen und -systeme]] (WS/SS)
* [[Betriebssysteme]] (WS)
* [[Kommunikationsnetze]] (WS)
* [[Rechnersysteme]] (WS)
* [[Information Rules]] (WS)
* [[Angewandte Informatik und Arbeit]] (SS)

====Katalog B====

* [[Maschinelles Lernen]] (SS)
* [[Grundlagen der Systemanalyse]] (SS)
* [[Computer Graphics / Computer Vision]] (SS)
* [[Grundlagen der Künstlichen Intelligenz]] (WS)
* [[Eingebettete Echtzeitsysteme]] (WS)

==Weblinks==

* [http://iv.tu-berlin.de/teaching/StudBeratung/informatik/BasisSS07_Katalog.pdf Basisveranstaltungen im SS07 (Studienberatung)]
* [http://iv.tu-berlin.de/teaching/StudBeratung/informatik/informatikbasis.html Liste aller Basisveranstaltungen (Studienberatung)]

[[Kategorie:Fakultäts-ABC]]

Opal für Linux/Unix

2007-01-16T14:34:09Z

130.149.17.41:

Hier gibt es fertige Pakete für die gängigsten Linux-Distributionen und andere Unix-Derivate. Wenn ihr Linux verwenden wollt und falls ihr Linux noch nicht auf eurem Rechner installiert habt, könnt ihr einfach [[Opalix]] verwenden, es liefert euch eine komplette Linuxumgebung, ohne es dauerhaft installieren zu müssen.

Falls ihr eine Distribution einsetzt, die hier nicht aufgeführt ist, und gerne ein Paket kompilieren würdet, euch aber nicht so ganz sicher seid, wie das geht, dann wendet euch an [mailto:opalix@freitagsrunde.org opalix@freitagsrunde.org]. Wir helfen euch gerne!

Allerdings muss man leider auch anmerken, dass der Opal-Buildprozess sehr schlecht organisiert ist. So wird z.B. nicht zwischen Kompilation- und Installationsphase unterschieden und die generierten Scripte unterstützen DESTDIR nicht, was aber eigentlich eine zwingende Voraussetzung für ein vernünftiges Packaging in den Distributionen ist. Diese Probleme machen es nicht einfach, Pakete zu erstellen.

= Hinweis zum Selber-Kompilieren =

Mit aktuellen gcc/glibc-Versionen (>=4.0) kompiliert OPAL <= 2.3j nicht mehr, da eine obsolete Funktion entfernt wurde. Ab Version 2.3k funktioniert es wieder.

Dirk Reckmann und Stephan Frank (ÜBB Gruppe), haben uns einen [http://opalix.freitagsrunde.org/rpm/patches/CLK_TCK.patch Patch] für die älteren Quellen zum Übersetzen des OCS mit gcc 4.1 zur Verfügung gestellt.
Diesen könnt ihr einfach einspielen durch:
cd <OPAL_UNPACK_DIRECTORY>/ocs
<nowiki>wget http://opalix.freitagsrunde.org/rpm/patches/CLK_TCK.patch</nowiki>
patch -p0 < CLK_TCK.patch

= SuSE =
Das Paket installiert OPAL nach <code>/opt/ocs</code>. Damit ihr <code>oasys</code> und <code>ocs</code> benutzen könnt, müsst ihr die folgende Zeile in die Datei <code>$HOME/.bashrc</code> eintragen:

export PATH=/opt/ocs/bin:$PATH

==Aktuelle Versionen==
Unsere Pakete für aktuelle Versionen von SuSE (siehe auch [[Opal_f%C3%BCr_Linux#C_Compiler_fehlt | Bekannte Probleme/Lösungen]] weiter unten).

* SuSE 10.1: [http://opalix.freitagsrunde.org/rpm/opal-2.3j-1.i386.suse10.1.rpm opal-2.3j-1.i386.suse10.1.rpm] ([http://opalix.freitagsrunde.org/rpm/MD5SUMS Prüfsumme])
* SuSE 10.0: [http://opalix.freitagsrunde.org/rpm/opal-2.3j-1.i386.suse10.0.rpm opal-2.3j-1.i386.suse10.0.rpm] ([http://opalix.freitagsrunde.org/rpm/MD5SUMS Prüfsumme])

== Alte Versionen ==
Zusätzlich zu den Paketen für aktuelle SuSE Versionen gibt es auch noch Pakete für ältere Versionen auf dem Server.

* SuSE 9.2: [http://opalix.freitagsrunde.org/rpm/opal-2.3j-1.i586.suse9.2.rpm opal-2.3j-1.i586.suse9.2.rpm] ([http://opalix.freitagsrunde.org/rpm/MD5SUMS Prüfsumme])
* SuSE 9.1: [http://opalix.freitagsrunde.org/rpm/opal-2.3j-1.i386.rpm opal-2.3j-1.i386.rpm] ([http://opalix.freitagsrunde.org/rpm/MD5SUMS Prüfsumme])
* SuSE 9.0: [http://opalix.freitagsrunde.org/rpm/alte_versionen/opal-2.3h-2.i686.suse9.0.rpm opal-2.3h-2.i686.suse9.0.rpm] ([http://opalix.freitagsrunde.org/rpm/alte_versionen/MD5SUMS Prüfsumme])

= Fedora =
Das Paket installiert OPAL nach <code>/opt/ocs</code>, damit ihr an der Shell die Kommandos benutzen könnt, müsst ihr die folgende Zeile in eure <code>.bashrc</code> eintragen:

export PATH=/opt/ocs/bin:$PATH

Laut Berichten gibt es Probleme zwischen SELinux und dem Opalinterpreter oasys. Vermutlich hilft hier ein Deaktivieren von SELinux für Opal bzw. das Erstellen von korrekten Regeln.
* '''Fedora Core 6''': [http://opalix.freitagsrunde.org/rpm/opal-2.3j-1.fc6.i386.rpm opal-2.3j-1.fc6.i386.rpm] ([http://opalix.freitagsrunde.org/rpm/MD5SUMS Prüfsumme]) Vielen Dank an Dennis Schickhaus.
* '''Fedora Core 5''': [http://opalix.freitagsrunde.org/rpm/opal-2.3k-1.fc5.i386.rpm opal-2.3k-1.fc5.i386.rpm] ([http://opalix.freitagsrunde.org/rpm/MD5SUMS Prüfsumme]) Vielen Dank an Christoph Höger. [http://opalix.freitagsrunde.org/rpm/opal-2.3j-1.fc5.i386.rpm opal-2.3j-1.fc5.i386.rpm] ([http://opalix.freitagsrunde.org/rpm/MD5SUMS Prüfsumme]) Vielen Dank an Dennis Schickhaus.
* '''Fedora Core 3''': [http://opalix.freitagsrunde.org/rpm/opal-2.3j-1.FC-3.i386.rpm opal-2.3j-1.FC-3.i386.rpm] ([http://opalix.freitagsrunde.org/rpm/MD5SUMS Prüfsumme]) Vielen Dank an Christoph Höger.

= Andere RPM-basierte Distributionen =

* Quellpaket: [http://opalix.freitagsrunde.org/rpm/opal-2.3j-1.src.rpm opal-2.3j-1.src.rpm] ([http://opalix.freitagsrunde.org/rpm/MD5SUMS Prüfsumme])

Wenn Ihr Opal auf einer anderen RPM-basierten Distribution neukompilieren wollt, könnt Ihr das SRPM-Paket benutzen. Einfach an der Shell

rpmbuild --rebuild --target i386 opal-2.3j-1.src.rpm

ausführen. Ihr benötigt dabei die Pakete <code>tcl-devel</code>, <code>tk-devel</code>, <code>xfree86-devel</code>, <code>flex</code> und <code>readline-devel</code>. Wenn ihr neue Pakete baut, wäre es nett, wenn ihr sie hier anderen zur Verfügung stellt. Sagt einfach unter [mailto:opalix@freitagsrunde.org opalix@freitagsrunde.org] Bescheid, wo sie zu finden sind.

Alternativ könnt ihr auch das Paket komplett neu aus den Sourcen erstellen. Dazu benötigt ihr das so genannte spec-file. Falls ihr Fragen habt, wie ihr damit ein Paket kompiliert, wendet euch einfach an [mailto:opalix@freitagsrunde.org opalix@freitagsrunde.org]

* spec file: [http://opalix.freitagsrunde.org/rpm/opal-2.3j-1.spec opal-2.3j-1.spec]

= Debian =
Das Paket für Debian enthält die aktuelle Version 2.3j.
Es gibt ein <code>apt-get</code> Repository, das man mit folgenden Zeilen in der Datei /etc/apt/sources.list einstellen kann:
<pre>
deb http://opalix.freitagsrunde.org/debian-rep ./
deb-src http://opalix.freitagsrunde.org/debian-rep ./
</pre>
Das Package heißt ocs und lässt sich mit
<pre>
sudo apt-get install ocs
</pre>
installieren.
Vielen Dank an Marco Ziech für seine Zeit und Mühe, das Paket und Repository zu erstellen!

= Ubuntu =
Prinzipiell könnt ihr das [http://opalix.freitagsrunde.org/debian-rep/ocs_2.3j-1_i386.deb Paket für Debian] unter Ubuntu einsetzen. In Einzelfällen kann es zu Problemen kommen, die ein [[Opal unter Ubuntu kompilieren|Kompilieren aus den Quellen]] erforderlich machen. Generell ist das Verwenden des Pakets vorzuziehen, da das Selbst-Kompilieren nicht immer einfach ist. In jedem Fall ist es erforderlich, das Paket "build-essential" installiert zu haben.

* '''6.10 (Edgy Eft)''': Das Paket für Debian, bezogen über das Repository, funktioniert gut. Selbstkompilieren wurde nicht getestet.
* '''6.06 (Dapper Drake)''': Das Paket für Debian funktioniert definitv unter Dapper Drake. Es ist dem Selbstkompilieren vorzuziehen, da es mehrere Berichte über Compiler-Inkompatibilitäten unter Dapper Drake gibt.
* '''5.10 (Breezy Badger)''': Da es anscheinend Probleme mit den Paketen von Debian unter Ubuntu 5.10 gibt, ist hier anscheinend eine Installationen aus den Quellen nötig. Nähere Informationen findet ihr auf der Seite [[Opal unter Ubuntu kompilieren]].

== Paket Installation ==
Es gibt zwei Möglichkeiten, dass Paket für Debian zu Installieren.

Entweder man lädt das Paket manuell herunter und installiert es mit dpkg:
<pre>
wget http://opalix.freitagsrunde.org/debian-rep/ocs_2.3j-1_i386.deb
dpkg -i ocs_2.3j-1_i386.deb
</pre>

Alternativ kann man wie bei Debian das Repository
<pre>
deb http://opalix.freitagsrunde.org/debian-rep ./
deb-src http://opalix.freitagsrunde.org/debian-rep ./
</pre>

hinzufügen.

'''Per GUI''':
* Startleiste -> System -> Systemverwaltung -> Synaptic-Paketverwaltung starte
* In der Synaptic-Paketverwaltung im Menu Einstellungen -> Paketquellen
* Im Paketquellen-Fenster auf hinzufügen und benutzerdefiniert anklicken
* Repository-Zeilen nacheinadner eintragen und FERTIG

'''Zu Fuß''':
* Datei /etc/apt/source.list im Editor öffnen
* Repository-Zeilen (siehe oben) in die Datei eintragen und FERTIG

Nach diesem Prozedere muß Opal noch installiert werden:
<pre>
user@ubuntulinux > sudo apt-get install ocs
</pre>

Vielleicht muß vorher noch ein apt-get update gemacht werden:
<pre>
user@ubuntulinux > sudo apt-get update
</pre>

FERTIG.

Sollte es Probleme geben, stellt bitte sicher, dass die zur Funktion notwendigen Pakete installiert sind:
<pre>
apt-get install gcc make libc6-dev tk8.3-dev libreadline4-dev gcc flex
</pre>

= Gentoo =
Ebuilds von Opal und der Opal-Dokumentation finden sich unter [http://user.cs.tu-berlin.de/~jensb/opal-ebuilds.tar.bz2].

(Alternativ gibt es im Gentoo-Bugzilla ein [https://bugs.gentoo.org/show_bug.cgi?id=46379 anderes Ebuild] für den Opal-Compiler. [http://gentoo-wiki.com/HOWTO_Installing_3rd_Party_Ebuilds Dieser Link] zeigt euch, wie man es installiert.)

Hinweis: Keines der Gentoo Ebuilds funktioniert im Moment, da das Opal-Makesystem die Sandbox verletzt.

'''Hinweise zur Installation des Opal-Ebuilds'''
Hierbei muss das Gentoo-System angepasst werden.

Innerhalb von <code>/etc/make.conf</code> ist der Eintrag der <code>PORTDIR_OVERLAY</code>-Variable nötig. Dafür ist ein eigenes Verzeichnis zu erstellen (im Allgemeinen und im Weiteren <code>/usr/local/portage</code>) und der Variable zuzuordnen:
mkdir -m 755 /usr/local/portage
echo 'PORTDIR_OVERLAY="/usr/local/portage"' >> /etc/make.conf

Unterhalb des Verzeichnisses <code>/usr/local/portage</code> das Verzeichnis <code>dev-lang</code> und darin die Verzeichnisse <code>opal</code> und <code>opaldoc</code> anlegen und dann in diese beiden Verzeichnisse die nötigen Ebuilds kopieren:
mkdir -m 755 /usr/local/portage/dev-lang{,/opal,/opaldoc}
cp opal-2.3i.ebuild /usr/local/portage/dev-lang/opal/
cp opaldoc-2.3i.ebuild /usr/local/portage/dev-lang/opaldoc/

Da beide Ebuilds maskiert sind, sind an dieser Stelle eventuell noch weitere Schritte nötig; die Installation maskierter Ebuilds ist hier sehr gut erklärt: [http://de.gentoo-wiki.com/Masked Maskierte Ebuilds].

Jetzt einfach:
emerge opal opaldoc

Um die neue Version von Opal (2.3''j''), die auch mit den neuen binutils klarkommt, zu emergen, sind folgende Schritte nötig:
cd /usr/local/portage/dev-lang/opal/
cp opal-2.3i.ebuild opal-2.3j.ebuild
ebuild opal-2.3j.ebuild digest
emerge opal

= FreeBSD =
Für all die, die OCS und Opal unter FreeBSD kompilieren wollen, gibt
es eine kurze Anleitung unter: [http://user.cs.tu-berlin.de/~pdmef/opal/freebsd.html]; fertige Packages für 5.3-RELEASE werden bei größerer Nachfrage erstellt.

= Bekannte Probleme/Lösungen =

== C Compiler fehlt ==
'''Symptom''': Ihr erhaltet eine Fehlermeldung, die ungefähr so aussieht:

checking Binom.sign
checking Binom.impl
compiling Binom.impl
/opt/ocs/lib/oasys/ccompiler: line 17: /usr/local/bin/gcc: No such file or directory
/opt/ocs/lib/oasys/ccompiler: line 17: exec: /usr/local/bin/gcc: cannot execute: No such file or directory
ERROR [C compiler]: /opt/ocs/lib/oasys/ccompiler exited abnormally
aborted

Auf einigen neueren Systemen (Ubuntu 5.10, SuSE 10.0) kommt es zu noch nicht genau geklärten Problemen von OCS mit der [[WikiPedia:GNU_Compiler_Collection|Gnu Compiler Collection (gcc)]]. OCS benötigt den C Compiler (ggf. zusätzlich installiern) und kann ihn dennoch nicht finden, so dass es zu diesem Fehler kommt. Wir haben noch nicht herausgefunden, woher der Fehler genau rührt, da er nicht auf allen Systemen reproduzierbar ist, aber es gibt einen Workaround.

'''Lösung/Workaround''': Das Paket gcc installieren. Eventuell muss noch ein Symlink gesetzt werden, damit Opal den Compiler auch findet.
ln -s `which gcc` /usr/local/bin/gcc # als root

== Libraries fehlen ==

$ oasys
oasys version 1.1e (ocs version 2.3j), (c) 1989-2001 The OPAL Group, TU Berlin
> a WhatsThat.sign
loading WhatsThat.sign
loading WhatsThat.impl
>f WhatsThat.impl
WhatsThat.impl>e WhatsThat(2)
starting evaluator process
/usr/bin/ld: crti.o: No such file: No such file or directory
collect2: ld returned 1 exit status
evaluator: cannot create transient shared object `/tmp/file7HXogh.so' for `./OCS/WhatsThat.o'
connection lost

Lösung: Paket '''build-essential''' installieren, z.B. mittels
apt-get install build-essential

[[Kategorie:Opal]]

Javakurs2006/Umfrage

2006-07-17T13:15:09Z

130.149.17.41: Checkin der Fragen von Martin

== Fragen für die Javakurs-Teilnehmer ==

* Konntet Ihr anderen Teilnehmern von Info 2 mit eurem Wissen helfen?
* Konntet Ihr der Veranstaltung besser folgen als Mitstudenten, die nicht am Kurs teilgenommen haben?
* Hat euch der Kurs beim Verstehen und Lösen der Hausaufgaben geholfen?
* Was ist eure allgemeine Meinung zu dem Kurs?
** Würdet ihr ihn noch einmal besuchen?
** Würdet ihr ihn weiterempfehlen?

Welche Art, den Javakurs zu organisieren, hätte dir mehr gebracht:
* Jeden Tag zwei Vorträge und dazugehörige Aufgaben.
* Vorträge und Aufgaben sind voneinander entkoppelt, d.h. man hat so lange für die Aufgaben Zeit, wie man braucht.

* Wie war die Stoff-Menge in der Vorlesung?
** Zu wenig?
** Genau richtig?
** Zu viel?

* Wie war die Stoff-Menge in der Übung?
** Sollten wir eher mehr Stoff bringen? (Geplant war noch mehr)
*** Sollte mehr Stoff vorgetragen werden als geübt wird?
** War die Stoff-Menge ausreichend?
** Eher zu viel und wir hätten die Grundlagen noch genauer üben sollen?

* Welchen Stoff habt ihr für Info 2 vermisst?

* An was könnt ihr euch von den Vorträgen noch erinnern?

* Hättet ihr Lust beim nächsten mal als Tutor mitzumachen?

Javakurs2006/Tag 2/Vorlesung 2

2006-04-05T12:30:48Z

130.149.17.41: felix: Syntax korrigiert

==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 e) {
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/Uebungsaufgaben

2006-04-05T07:35:05Z

130.149.17.41: else hinzugefuegt

= Variablen =
== Variablendeklaration und Initialisierung ==
<nowiki>
class Beispiel {
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>
* An welcher Stelle im Programm wird die Variable ''aWholeNumber'' definiert?
* An welcher Stelle im 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.

== Selber Deklarationen und Definitionen durchführen ==
<nowiki>
class Beispiel {
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 fünf zu dem Wert

// System.out.println("7 erwartet: " + birnen);
// deklariere eine Variable "aepfel" und weise ihr den Wert fünf zu

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

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

}
}
</nowiki>

== Zuweisung an Variablen ==
<nowiki>
class Beispiel {
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>

Überlege dir was dieses Code-Fragment ausgeben würde.
Führe es aus und vergleiche die Resultate. (Kopiere
* Was sind die Unterschiede?
* Warum?
Erkläre einem Tutor zu welchem Schluss du gekommen bist und frage ihn ob du Recht hast.

== Variablen ändern ihre Werte ==
<nowiki>
class Test {
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>

Überlege dir was dieser Code ausgeben würde.
Schreibe ihn in eine Datei, kompiliere ihn und führe ihn aus.
* Was gibt er tatsächlich aus?
* Gibt es unterschiede?

== Formatierung ==
Wieso haben wir das Beispiel nach den geschweiften Klammern eingerückt und die Variablen so gestellt wie wir es gestellt haben 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>
Nenne mindestens einen Grund und erkläre ihn deinem Tutor.

Etwas weniger Extrem, wieso haben wir unser zweites Beispiel nicht so gestellt?
<nowiki>
class Beispiel {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>
Nenne mindestens einen Grund und erkläre ihn deinem Tutor.

Wieso haben wir unser zweites Beispiel nicht so gestellt?
<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>
Nenne mindestens einen Grund und erkläre ihn deinem Tutor.

== Variablen mit verschiedenen Typen zuweisen ==
<nowiki>
class Test {
public static void main(String [] ignored) {

}
}
</nowiki>

= If =
== Einfache if-Bedingung ==
<nowiki>
public class If_Uebung1 {
/* Eure Aufgabe:
* Versucht nachzuvollziehen, was dieses Programm macht
* und schaut Euch den Code an.
*/

public static void main(String[] args) {

/*
* wir erzeugen uns hier eine Zufallszahl im
* Bereich 1-6. Warum funktioniert das so?
* Math.random ist eine statische Funktion im
* Math-Paket, dass und eine double-Zahl, die kleiner
* als 1.0 aber groesser oder gleich 0 ist.
* Mit 6 multipliziert und um eins erhöht erhalten wir
* Zahlen von 1.0 bis 6.99999...
* Durch das Umwandeln in int werden die Nachkommastellen abgeschnitten
* und wir erhalten ein int von 1 bis 6.
*/
int wuerfelzahl = (int) (1 + (6 * Math.random()));

/*
* Zur Kontrolle geben wir das Ergebnis aus
*/
System.out.println("Der Würfel hat " + wuerfelzahl + " ergeben.");

/*
* Ist das Ergebnis groesser als 3 ?
*/
if (wuerfelzahl > 3) {
// Wenn ja gib diesen Text aus:
System.out.println("mehr als 3!");
}

}

}
</nowiki>

== if-else-Konstrukt ==

<nowiki>
public class If_Uebung2 {

public static void main (String[] args){

int x=10;
if (x>5) {
System.out.println("x ist groesser als 5");
} else {
System.out.println("x ist kleiner/gleich 5");
}

}
}
</nowiki>

== Mehrere if-Bedingungen ==

<nowiki>
public class If_Uebung3 {

/*
* Eure Aufgabe:
* Schaut Euch das Programm an und überlegt, was fuer verschiedene
* Werte passiert.
* Welche If-Abfragen sind unnötig, weil man die Ausgaben in else-Zweige von
* bereits vorhandenen schreiben könnte?
*/

public static void main(String[] args) {

int wert;

wert = 5;

if (wert<5){
System.out.println("Der Wert ist echt kleiner 5.");
}

if (wert>5){
System.out.println("Der Wert ist echt groesser 5.");
}

if (wert==5){
System.out.println("Der Wert ist gleich 5");
}

if (wert>=5){
System.out.println("Der Wert ist groesser oder gleich 5");
}

if (wert<=5){
System.out.println("Der Wert ist kleiner oder gleich 5");
}

}

}
</nowiki>

= For =
== for-Schleifen zum Zählen ==
<nowiki>
public class For_Uebung1 {
/*
* Eure Aufgabe:
* Schaut Euch dieses Programm an und überlegt, welche Zahlen
* es ausgeben wird.
* Anschliessend kompiliert das Programm, führt es aus und überprüft
* Eure Vermutungen.
*
*/

public static void main(String[] args) {

System.out.println("erste for Schleife:");
for (int i = 1; i <= 10; i = i + 1) {
System.out.print(" " + i);
}
System.out.println(); // Zeilenumbruch

System.out.println("zweite for Schleife:");
for (int i = 1; i <= 10; i = i + 2) {
System.out.print(" " + i);
}
System.out.println(); // Zeilenumbruch

System.out.println("dritte for Schleife:");
for (int i = 1; i <= 10; i = i * 2) {
System.out.print(" " + i);
}
System.out.println(); // Zeilenumbruch

}

}
</nowiki>

== for-Schleife und if-Bedingung ==
<nowiki>
public class ForIf_Uebung {

// Welche Zahlen gibt dieses Programm aus ?

public static void main(String[] args) {
for (int i=1;i<10;i++){
if ((i % 2)==0){ // % ist der Modulo-Operator
System.out.println("Die Zahl "+i+" ist gerade.");
}
}
}
}
</nowiki>

= While =
== einfache while-Schleife ==
<nowiki>

public class While_Uebung1 {

public static void main(String[] args) {

int x=10;
while (x>0){
System.out.println(" x=" + x); // Anhaengen von x an den String
x=x-1;
}
}
}
</nowiki>

= Methoden =
== Was tut das? ==

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

public static double gibMirNeZahl() {
return 15.3;
}
}

//file: Methoden2.java
class Methoden3 {
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);
}
}

//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);
}
}

//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);
}
}

== Tue selbst etwas! ==

Die folgende Aufgabe ist eine Schritt-für-Schritt Anleitung. Sie soll euch die Möglickeit geben einmal genau angeleitet zu sehen, wie man an eine Aufgabe herangehen könnte.

Zuerst stellen wir einen denkbaren Aufgabentext vor, der später ausreichen müsste um selbst ein Programm zu schreiben.

Aufgabe: Erstelle ein Modul, das die mathematischen Operationen Addition, Subtraktion, und Potenzieren jeweils in einer Methode anbieten. Probiere deine Methoden in der main-Methode aus.

//TODO: Schritt für Schritt Anleitung, wie, in welcher Reihenfolge und wo genau welche Methode implementiert werden soll. Voraussetzung: Verständnis von Schleifen. Rudimentäres Verständnis von Methoden.

= Arrays (eindimensional und n-dimensional) =
== Eindimensionale Arrays ==
Folgendes Array-Konstrukt wird initialisiert
<nowiki>
int[] meinArray1 = new int[5];
meinArray1[0] = 0;
meinArray1[1] = 1;
meinArray1[2] = 2;
meinArray1[3] = 3;
meinArray1[4] = 4;

int[] meinArray2 = new int[3];
meinArray2[0] = 0;
meinArray2[1] = 1;
meinArray2[2] = 2;
</nowiki>

Was geben die folgenden "system.out.println" jeweils aus?
Vergleiche die Ausgabe mit Deinem Ergebnis.

1.1.
System.out.println(meinArray1.length);

1.2.
System.out.println(meinArray2.length);

1.3.
System.out.println("Ergebnis:"+meinArray1[1]);

1.4.
System.out.println("Ergebnis:"+meinArray2[1]);

1.5.
System.out.println("Ergebnis:"+meinArray1[4]);

1.6.
System.out.println("Ergebnis:"+meinArray2[4]);

1.7.
System.out.println(meinArray1.length-1);

1.8.
System.out.println(meinArray2.length-1);

1.9.
System.out.println("Ergebnis:"+meinArray1[0]);

1.10.
System.out.println("Ergebnis:"+meinArray2[0]);

== Zweidimensionale Arrays ==
Folgendes Array-Konstrukt wird initialisiert
<nowiki>
int[][] meinArray3 = new int[2][3];
meinArray3[0][0] = 1;
meinArray3[1][1] = 2;
meinArray3[0][2] = 1;
meinArray3[1][0] = 2;
meinArray3[0][1] = 1;
meinArray3[1][2] = 2;
</nowiki>

Was geben die folgenden "system.out.println" jeweils aus?
Vergleiche die Ausgabe mit Deinem Ergebnis.

Tipp: Aus der Mathematik kennst Du Matrizen. Ihre Größe wird mit (n x m) angegeben.

System.out.println(meinArray3[0][0]+meinArray3[0][1]+meinArray3[0][2]);
System.out.println(meinArray3[1][0]+meinArray3[1][1]+meinArray3[1][2]);

== Dreidimensionale Arrays ==
Folgendes Array-Konstrukt wird initialisiert
<nowiki>
int[][][] meinArray3D = new int[2][2][2];
meinArray3D[0][0][0] = 1;
meinArray3D[0][1][1] = 2;
meinArray3D[0][1][0] = 2;
meinArray3D[0][0][1] = 1;

meinArray3D[1][0][0] = 3;
meinArray3D[1][1][1] = 4;
meinArray3D[1][1][0] = 4;
meinArray3D[1][0][1] = 3;
</nowiki>

Was geben die folgenden "system.out.println" jeweils aus?
Vergleiche die Ausgabe mit Deinem Ergebnis.

Tipp: Aus der Mathematik kennst Du mehrdimensionale Obejekte.
<nowiki>
System.out.println(meinArray3D[0][0][0]+meinArray3D[0][0][1]);
System.out.println(meinArray3D[0][1][0]+meinArray3D[0][1][1]);
System.out.println(meinArray3D[1][0][0]+meinArray3D[1][0][1]);
System.out.println(meinArray3D[1][1][0]+meinArray3D[1][1][1]);
</nowiki>

Javakurs2006/Uebungsaufgaben

2006-04-05T07:29:03Z

130.149.17.41: erste while hinzugefuegt

= Variablen =
== Variablendeklaration und Initialisierung ==
<nowiki>
class Beispiel {
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>
* An welcher Stelle im Programm wird die Variable ''aWholeNumber'' definiert?
* An welcher Stelle im 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.

== Selber Deklarationen und Definitionen durchführen ==
<nowiki>
class Beispiel {
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 fünf zu dem Wert

// System.out.println("7 erwartet: " + birnen);
// deklariere eine Variable "aepfel" und weise ihr den Wert fünf zu

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

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

}
}
</nowiki>

== Zuweisung an Variablen ==
<nowiki>
class Beispiel {
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>

Überlege dir was dieses Code-Fragment ausgeben würde.
Führe es aus und vergleiche die Resultate. (Kopiere
* Was sind die Unterschiede?
* Warum?
Erkläre einem Tutor zu welchem Schluss du gekommen bist und frage ihn ob du Recht hast.

== Variablen ändern ihre Werte ==
<nowiki>
class Test {
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>

Überlege dir was dieser Code ausgeben würde.
Schreibe ihn in eine Datei, kompiliere ihn und führe ihn aus.
* Was gibt er tatsächlich aus?
* Gibt es unterschiede?

== Formatierung ==
Wieso haben wir das Beispiel nach den geschweiften Klammern eingerückt und die Variablen so gestellt wie wir es gestellt haben 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>
Nenne mindestens einen Grund und erkläre ihn deinem Tutor.

Etwas weniger Extrem, wieso haben wir unser zweites Beispiel nicht so gestellt?
<nowiki>
class Beispiel {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>
Nenne mindestens einen Grund und erkläre ihn deinem Tutor.

Wieso haben wir unser zweites Beispiel nicht so gestellt?
<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>
Nenne mindestens einen Grund und erkläre ihn deinem Tutor.

== Variablen mit verschiedenen Typen zuweisen ==
<nowiki>
class Test {
public static void main(String [] ignored) {

}
}
</nowiki>

= If =
== Einfache if-Bedingung ==
<nowiki>
public class If_Uebung1 {
/* Eure Aufgabe:
* Versucht nachzuvollziehen, was dieses Programm macht
* und schaut Euch den Code an.
*/

public static void main(String[] args) {

/*
* wir erzeugen uns hier eine Zufallszahl im
* Bereich 1-6. Warum funktioniert das so?
* Math.random ist eine statische Funktion im
* Math-Paket, dass und eine double-Zahl, die kleiner
* als 1.0 aber groesser oder gleich 0 ist.
* Mit 6 multipliziert und um eins erhöht erhalten wir
* Zahlen von 1.0 bis 6.99999...
* Durch das Umwandeln in int werden die Nachkommastellen abgeschnitten
* und wir erhalten ein int von 1 bis 6.
*/
int wuerfelzahl = (int) (1 + (6 * Math.random()));

/*
* Zur Kontrolle geben wir das Ergebnis aus
*/
System.out.println("Der Würfel hat " + wuerfelzahl + " ergeben.");

/*
* Ist das Ergebnis groesser als 3 ?
*/
if (wuerfelzahl > 3) {
// Wenn ja gib diesen Text aus:
System.out.println("mehr als 3!");
}

}

}
</nowiki>

== Mehrere if-Bedingungen ==

<nowiki>
public class If_Uebung2 {

/*
* Eure Aufgabe:
* Schaut Euch das Programm an und überlegt, was fuer verschiedene
* Werte passiert.
* Welche If-Abfragen sind unnötig, weil man die Ausgaben in else-Zweige von
* bereits vorhandenen schreiben könnte?
*/

public static void main(String[] args) {

int wert;

wert = 5;

if (wert<5){
System.out.println("Der Wert ist echt kleiner 5.");
}

if (wert>5){
System.out.println("Der Wert ist echt groesser 5.");
}

if (wert==5){
System.out.println("Der Wert ist gleich 5");
}

if (wert>=5){
System.out.println("Der Wert ist groesser oder gleich 5");
}

if (wert<=5){
System.out.println("Der Wert ist kleiner oder gleich 5");
}

}

}
</nowiki>

= For =
== for-Schleifen zum Zählen ==
<nowiki>
public class For_Uebung1 {
/*
* Eure Aufgabe:
* Schaut Euch dieses Programm an und überlegt, welche Zahlen
* es ausgeben wird.
* Anschliessend kompiliert das Programm, führt es aus und überprüft
* Eure Vermutungen.
*
*/

public static void main(String[] args) {

System.out.println("erste for Schleife:");
for (int i = 1; i <= 10; i = i + 1) {
System.out.print(" " + i);
}
System.out.println(); // Zeilenumbruch

System.out.println("zweite for Schleife:");
for (int i = 1; i <= 10; i = i + 2) {
System.out.print(" " + i);
}
System.out.println(); // Zeilenumbruch

System.out.println("dritte for Schleife:");
for (int i = 1; i <= 10; i = i * 2) {
System.out.print(" " + i);
}
System.out.println(); // Zeilenumbruch

}

}
</nowiki>

== for-Schleife und if-Bedingung ==
<nowiki>
public class ForIf_Uebung {

// Welche Zahlen gibt dieses Programm aus ?

public static void main(String[] args) {
for (int i=1;i<10;i++){
if ((i % 2)==0){ // % ist der Modulo-Operator
System.out.println("Die Zahl "+i+" ist gerade.");
}
}
}
}
</nowiki>

= While =
== einfache while-Schleife ==
<nowiki>

public class While_Uebung1 {

public static void main(String[] args) {

int x=10;
while (x>0){
System.out.println(" x=" + x); // Anhaengen von x an den String
x=x-1;
}
}
}
</nowiki>

= Methoden =
== Was tut das? ==

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

public static double gibMirNeZahl() {
return 15.3;
}
}

//file: Methoden2.java
class Methoden3 {
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);
}
}

//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);
}
}

//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);
}
}

== Tue selbst etwas! ==

Die folgende Aufgabe ist eine Schritt-für-Schritt Anleitung. Sie soll euch die Möglickeit geben einmal genau angeleitet zu sehen, wie man an eine Aufgabe herangehen könnte.

Zuerst stellen wir einen denkbaren Aufgabentext vor, der später ausreichen müsste um selbst ein Programm zu schreiben.

Aufgabe: Erstelle ein Modul, das die mathematischen Operationen Addition, Subtraktion, und Potenzieren jeweils in einer Methode anbieten. Probiere deine Methoden in der main-Methode aus.

//TODO: Schritt für Schritt Anleitung, wie, in welcher Reihenfolge und wo genau welche Methode implementiert werden soll. Voraussetzung: Verständnis von Schleifen. Rudimentäres Verständnis von Methoden.

= Arrays (eindimensional und n-dimensional) =
== Eindimensionale Arrays ==
Folgendes Array-Konstrukt wird initialisiert
<nowiki>
int[] meinArray1 = new int[5];
meinArray1[0] = 0;
meinArray1[1] = 1;
meinArray1[2] = 2;
meinArray1[3] = 3;
meinArray1[4] = 4;

int[] meinArray2 = new int[3];
meinArray2[0] = 0;
meinArray2[1] = 1;
meinArray2[2] = 2;
</nowiki>

Was geben die folgenden "system.out.println" jeweils aus?
Vergleiche die Ausgabe mit Deinem Ergebnis.

1.1.
System.out.println(meinArray1.length);

1.2.
System.out.println(meinArray2.length);

1.3.
System.out.println("Ergebnis:"+meinArray1[1]);

1.4.
System.out.println("Ergebnis:"+meinArray2[1]);

1.5.
System.out.println("Ergebnis:"+meinArray1[4]);

1.6.
System.out.println("Ergebnis:"+meinArray2[4]);

1.7.
System.out.println(meinArray1.length-1);

1.8.
System.out.println(meinArray2.length-1);

1.9.
System.out.println("Ergebnis:"+meinArray1[0]);

1.10.
System.out.println("Ergebnis:"+meinArray2[0]);

== Zweidimensionale Arrays ==
Folgendes Array-Konstrukt wird initialisiert
<nowiki>
int[][] meinArray3 = new int[2][3];
meinArray3[0][0] = 1;
meinArray3[1][1] = 2;
meinArray3[0][2] = 1;
meinArray3[1][0] = 2;
meinArray3[0][1] = 1;
meinArray3[1][2] = 2;
</nowiki>

Was geben die folgenden "system.out.println" jeweils aus?
Vergleiche die Ausgabe mit Deinem Ergebnis.

Tipp: Aus der Mathematik kennst Du Matrizen. Ihre Größe wird mit (n x m) angegeben.

System.out.println(meinArray3[0][0]+meinArray3[0][1]+meinArray3[0][2]);
System.out.println(meinArray3[1][0]+meinArray3[1][1]+meinArray3[1][2]);

== Dreidimensionale Arrays ==
Folgendes Array-Konstrukt wird initialisiert
<nowiki>
int[][][] meinArray3D = new int[2][2][2];
meinArray3D[0][0][0] = 1;
meinArray3D[0][1][1] = 2;
meinArray3D[0][1][0] = 2;
meinArray3D[0][0][1] = 1;

meinArray3D[1][0][0] = 3;
meinArray3D[1][1][1] = 4;
meinArray3D[1][1][0] = 4;
meinArray3D[1][0][1] = 3;
</nowiki>

Was geben die folgenden "system.out.println" jeweils aus?
Vergleiche die Ausgabe mit Deinem Ergebnis.

Tipp: Aus der Mathematik kennst Du mehrdimensionale Obejekte.
<nowiki>
System.out.println(meinArray3D[0][0][0]+meinArray3D[0][0][1]);
System.out.println(meinArray3D[0][1][0]+meinArray3D[0][1][1]);
System.out.println(meinArray3D[1][0][0]+meinArray3D[1][0][1]);
System.out.println(meinArray3D[1][1][0]+meinArray3D[1][1][1]);
</nowiki>