FreitagsrundenWiki - Benutzerbeiträge [de]

Javakurs2008/Vortrag05

2008-04-08T10:10:28Z

Robert L: Folien + Beispiel

= LE 5 (45 min), Tag 3 =

*'''Vortragende''': Katrin Lange, Robert Lubkoll

* Was ist ein Objekt?
* Wie funktioniert die Java-Syntax für Objekte?
* Welche Fehler treten beim Programmieren mit Objekten häufig auf?
* Was ist Kapselung?

== Folien ==
* [http://docs.freitagsrunde.org/Veranstaltungen/javakurs_2008/vorlesungen/LE05.pdf LE05.pdf], 1.75MB

== Beispiel ==

* [http://docs.freitagsrunde.org/Veranstaltungen/javakurs_2008/vorgaben/le05/Human.java Human.java]
* [http://docs.freitagsrunde.org/Veranstaltungen/javakurs_2008/vorgaben/le05/Testprogramm_Human.java Testprogramm_Human.java]

Javakurs2008/Vortrag05

2008-04-03T19:23:25Z

Robert L:

Javakurs2008/Gliederung

2008-03-28T13:30:18Z

Robert L: /* LE 5 (45 min), Tag 3 */

== Tagesplahn ==

Bitte ladet eure Vortrage auf die jeweiligen Seiten hoch.

Die alten Vorträge findet ihr hier: [[Javakurs2007]]

{| border="0" cellpadding="4" cellspacing="2"
|- bgcolor="#D8D8D8"
!Zeit
!Di
!Mi
!Do
!Fr
|- bgcolor="#E8E8E8"
|9:00 [[C.t.]]
|bgcolor="#E8E8E8" |[[Javakurs2008/Vortrag01 | Vortrag]] (MA 042)
|bgcolor="#E8E8E8" |[[Javakurs2008/Vortrag03 | Vortrag]] (MA 042)
|bgcolor="#E8E8E8" |[[Javakurs2008/Vortrag04 | Vortrag]] (MA 042)
|bgcolor="#E8E8E8" |[[Javakurs2008/Vortrag06 | Vortrag]] (MA 042)
|- bgcolor="#F5F5F5"
|10:00
|rowspan=2 |Übung
|rowspan=2 |Übung
|rowspan=2 |Übung
|rowspan=2 |Übung
|- bgcolor="#F5F5F5"
|11.00
|- bgcolor="#FFFFFF"
|12:00
|Mittagspause
|Mittagspause
|Mittagspause
|Mittagspause
|- bgcolor="#E8E8E8"
|13:00 [[C.t.]]
|[[Javakurs2008/Vortrag02 | Vortrag]] (MA 042)
| bgcolor="#F5F5F5" rowspan=3 |Übung
|[[Javakurs2008/Vortrag05 | Vortrag]] (MA 042)
| bgcolor="#F5F5F5" rowspan=3 |Übung
|- bgcolor="#F5F5F5"
|14:00
|rowspan=2 | Übung
|rowspan=2 | Übung
|- bgcolor="#F5F5F5"
|15:00

|}

=== LE 1 (45 min), Tag 1 ===
*'''Vortragende''': Milan Mehner, Felix Friedrich
*'''Interessenten''': Milan Mehner, Felix Friedrich

* Organisatorisches
* HelloWorld
* Wie wird ein iteratives Programm verarbeitet?
* Variablen
** Deklaration und Zuweisung
** wichtige Basistypen
* Fallunterscheidungen
* Blöcke und Einrückung
* Kommentare
* compilieren und ausführen
* Fehlermeldungen

=== LE 2 (45 min), Tag 1 ===
*'''Vortragende''': Robert Buchholz, Sebastian Dyroff
*'''Interessenten''': Robert Buchholz, Sebastian Dyroff

* Arrays
* Schleifen
** Opal beispiel
** while
** for
** Schleifenbedingungen
** Endlosschleifen vermeiden (Gleitkommazahlen, >=, ...)

=== LE 3 (45 min), Tag 2 ===
*'''Vortragende''': Kai Dietrich, Nadim El Sayid
*'''Interessenten''': Kai Dietrich, Nadim El Sayid

* Methoden
** Warum benutzen wir Methoden?
** Wie werden sie deklariert?
** Call by Value
** Unterschied Methode/Funktion

* Java API (Wo kommen Methoden her)

* sprechende Namen
* Debugging

* Testen
** Testwerte finden
** Was kann man mit Testen erreichen, warum trotzdem essentiell

=== LE 4 (45 min), Tag 3 ===
*'''Vortragende''': Robert Lubkoll, Daniel Käs
*'''Interessenten''': Robert Lubkoll, Daniel Käs

* Wie bearbeiten geübte Programmierer eine Aufgabenstellung ?
* Wo fange ich mit dem Schreiben eines Programms an ?
* Wie behalte ich den Überblick in meinem Code ?
* Warum ist cooler Code schlechter Code ?

=== LE 5 (45 min), Tag 3 ===
*'''Vortragende''': Katrin Lange, Robert Lubkoll
*'''Interessenten''': Martin Häcker, Katrin Lange, Robert Lubkoll

* Was ist ein Objekt?
* Wie funktioniert die Java-Syntax für Objekte?
* Welche Fehler treten beim Programmieren mit Objekten häufig auf?
* Wie verwendet man Objekte um seinen Code aufzuteilen?

* Objektorientierung
** Gruppierung von Daten/eigene Datentypen
** Zugriffsschutz
** Daten bringen ihre Methoden mit

=== LE 6 (45 min), Tag 4 ===
*'''Vortragende''': Mario Bodemann, Björn Lohrmann
*'''Interessenten''': Kai Dietrich

* Wiederholung LE 5
* Kapselung /Information Hiding
* Standardmethoden (ohne Vererbung)
** Aber schon polymorphie, also ''(Object)myFancyOwnObject.toString()'' tut das richtige
** toString
** equals
* == versus equals
* Motivierung
** Beispiele mit Datentyperstellung und erzeugten Instanzen in C++, C#, J++, ...

== Abschlussveranstaltung ==
* Bedankung bei IRB, Teilnehmer, etc.
* Ellen hält, wie jedes Jahr, eine Rede ;)

== Links ==

[[Javakurs2008]]

[[Javakurs2008/Orga]]

[[Javakurs2008/Tutorenportal_Javakurs_2008]]

[[Javakurs2008/%C3%9Cbungspool]]
( [[Javakurs2008/%C3%9Cbungspool_Entw%C3%BCrfe]],
[[Javakurs2008/Musterloesungen]])

Javakurs2008/Vortrag04

2008-03-28T12:25:41Z

Robert L: /* Folien */ link

= LE 4 (45 min), Tag 3 =

*'''Vortragende''': Robert Lubkoll, Daniel Käs

== Themen ==
* Wie bearbeiten geübte Programmierer eine Aufgabenstellung ?
* Wo fange ich mit dem Schreiben eines Programms an ?
* Wie behalte ich den Überblick in meinem Code ?
* Warum ist cooler Code schlechter Code ?

== Folien ==

[http://www.freitagsrunde.org/docs/javakurs/2008/vorlesungen/LE04.pdf LE04.pdf]

Javakurs2008/Vortrag04

2008-03-26T20:22:48Z

Robert L:

Javakurs2008/Tutorenportal

2008-03-20T21:27:07Z

Robert L: redundanz entfernt

== TODO ==

# Übungsaufgaben sowie Musterlösungen korrekturlesen, gegebenenfalls ändern oder erweitern.

== Links ==

[[Javakurs2008]]

[[Javakurs2008/Orga]]

[[Javakurs2008/Gliederung_Javakurs_2008]]

[[Javakurs2008/%C3%9Cbungspool]]
( [[Javakurs2008/%C3%9Cbungspool_Entw%C3%BCrfe]],
[[Javakurs2008/Musterloesungen]])

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

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

'''Dienstag:'''
{| border="0" cellpadding="4" cellspacing="2"
|- bgcolor="#D8D8D8"
! Raum
! Tutoren
! Plätze
! Tutanten anwesend

|- bgcolor="#E8E8E8"
|
|
|
| 

|- bgcolor="#F5F5F5"
|
|
|
| 

|- bgcolor="#E8E8E8"
|
|
|
| 

|- bgcolor="#F5F5F5"
|
|
|
| 

|- bgcolor="#E8E8E8"
|
|
|
| 

|- bgcolor="#F5F5F5"
|
|
|
| 

|}

'''Historie:'''
* Die Tabelle wird nach jedem Tag kopiert, um einen Überblick über die Teilnehmerzahl zu gewinnen

* [[Javakurs2008/Raumauslastung_Montag | Montag]]
* [[Javakurs2008/Raumauslastung_Dienstag | Dienstag]]
* [[Javakurs2008/Raumauslastung_Mittwoch | Mittwoch]]
* [[Javakurs2008/Raumauslastung_Donnerstag | Donnerstag]]

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

== Entwurf der Übungsaufgaben ==

* Alte Übungsaufgaben:
*''' Übernehmen wir die so, oder machen wir Änderungen? '''
[[Javakurs2007/%C3%9Cbungspool_Entw%C3%BCrfe]]

[[Javakurs2007/Musterloesungen]]

[[Javakurs2007/%C3%9Cbungspool]]

* Neue Übungsaufgaben

[[Javakurs2008/%C3%9Cbungspool_Entw%C3%BCrfe]]

[[Javakurs2008/Musterloesungen]]

[[Javakurs2008/%C3%9Cbungspool]]

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

Javakurs2008/Orga

2008-03-13T14:48:16Z

Robert L: /* Vortragende */

== Lings Plahnungsseiten ==

[[Javakurs2008/Gliederung_Javakurs_2008]]

[[Javakurs2008/Tutorenportal_Javakurs_2008]]

[[Javakurs2008/%C3%9Cbungspool]]
( [[Javakurs2008/%C3%9Cbungspool_Entw%C3%BCrfe]],
[[Javakurs2008/Musterloesungen]])

[[Javakurs2008]]

== TODOS ==

== Orga Team ==
* Mario B.
* Björn L.
* Felix F.
* Sebastian L.

== Vortragende ==
* Mario B.
* Robert B.
* Kai D.
* Nadim E. S.
* Felix F.
* Martin H.
* Daniel K.
* Björn L.
* Katrin L.
* Robert L.
* Milan M.

== Tutoren ==
* Gert G.
* Dan L.
* Alexander K.
* Martin Z.
* Björn B.
* Nadim E. S.
* Robert B.
* Mario B.
* Björn L.
* Felix F.
* Michael G.
* Katrin L.
* <s>Robert L.</s>
* Kai D.
* Milan M.
* Daniel K.
* Thaddäus K.
* Reiner C.

== Räume ==
* H 1058 vom 07. bis 8. April von 9 - 16 Uhr
* MA 004 vom 09. bis 10. April von 9 - 16 Uhr

Javakurs2008/Gliederung

2008-03-13T14:42:11Z

Robert L: /* LE 2 (45 min), Tag 1 */ Interessenten

== Tagesplahn des letzen Jahres ==

Hier sind auch die '''Folien des letzen Jahres''' verlinkt.

{| border="0" cellpadding="4" cellspacing="2"
|- bgcolor="#D8D8D8"
!Zeit
!Di
!Mi
!Do
!Fr
|- bgcolor="#E8E8E8"
|9:00 [[C.t.]]
|bgcolor="#E8E8E8" |[[Javakurs2007/Vortrag01 | Vortrag]] (MA 042)
|bgcolor="#E8E8E8" |[[Javakurs2007/Vortrag03 | Vortrag]] (MA 042)
|bgcolor="#E8E8E8" |[[Javakurs2007/Vortrag04 | Vortrag]] (MA 042)
|bgcolor="#E8E8E8" |[[Javakurs2007/Vortrag06 | Vortrag]] (MA 042)
|- bgcolor="#F5F5F5"
|10:00
|rowspan=2 |Übung
|rowspan=2 |Übung
|rowspan=2 |Übung
|rowspan=2 |Übung
|- bgcolor="#F5F5F5"
|11.00
|- bgcolor="#FFFFFF"
|12:00
|Mittagspause
|Mittagspause
|Mittagspause
|Mittagspause
|- bgcolor="#E8E8E8"
|13:00 [[C.t.]]
|[[Javakurs2007/Vortrag02 | Vortrag]] (MA 042)
| bgcolor="#F5F5F5" rowspan=3 |Übung
|[[Javakurs2007/Vortrag05 | Vortrag]] (MA 042)
| bgcolor="#F5F5F5" rowspan=3 |Übung
|- bgcolor="#F5F5F5"
|14:00
|rowspan=2 | Übung
|rowspan=2 | Übung
|- bgcolor="#F5F5F5"
|15:00

|}

=== LE 1 (45 min), Tag 1 ===
*'''Vortragende''':
*'''Interessenten''': Milan Mehner, Felix Friedrich

* Organisatorisches
* HelloWorld
* Wie wird ein iteratives Programm verarbeitet?
* Variablen
** Deklaration und Zuweisung
** wichtige Basistypen
* Fallunterscheidungen
* Blöcke und Einrückung
* Kommentare
* compilieren und ausführen
* Fehlermeldungen

=== LE 2 (45 min), Tag 1 ===
*'''Vortragende''':
*'''Interessenten''': Robert Buchholz

* Arrays
* Schleifen
** Opal beispiel
** while
** for
** Schleifenbedingungen
** Endlosschleifen vermeiden (Gleitkommazahlen, >=, ...)

=== LE 3 (45 min), Tag 2 ===
*'''Vortragende''':
*'''Interessenten''':

* Methoden
** Warum benutzen wir Methoden?
** Wie werden sie deklariert?
** Call by Value
** Unterschied Methode/Funktion
* sprechende Namen
* Testen
** Testwerte finden
** Was kann man mit Testen erreichen, warum trotzdem essentiell
* Debugging

=== LE 4 (45 min), Tag 3 ===
*'''Vortragende''':
*'''Interessenten''': Robert Lubkoll

* Wie bearbeiten geübte Programmierer eine Aufgabenstellung ?
* Wo fange ich mit dem Schreiben eines Programms an ?
* Wie behalte ich den Überblick in meinem Code ?
* Warum ist cooler Code schlechter Code ?

=== LE 5 (45 min), Tag 3 ===
*'''Vortragende''':
*'''Interessenten''': Robert Lubkoll

* Was ist ein Objekt?
* Wie funktioniert die Java-Syntax für Objekte?
* Welche Fehler treten beim Programmieren mit Objekten häufig auf?
* Wie verwendet man Objekte um seinen Code aufzuteilen?

* Objektorientierung
** Gruppierung von Daten/eigene Datentypen
** Zugriffsschutz
** Daten bringen ihre Methoden mit

=== LE 6 (45 min), Tag 4 ===
*'''Vortragende''':
*'''Interessenten''':

* Wiederholung LE 5
* Kapselung /Information Hiding
* Java API
* Standardmethoden (ohne Vererbung)
** Aber schon polymorphie, also ''(Object)myFancyOwnObject.toString()'' tut das richtige
** toString
** equals
* == versus equals
* Motivierung
** Beispiele mit Datentyperstellung und erzeugten Instanzen in C++, C#, J++, ...

== Abschlussveranstaltung ==
* Bedankung bei IRB, Teilnehmer, etc.
* Ellen hält, wie jedes Jahr, eine Rede ;)

== Links ==

[[Javakurs2008]]

[[Javakurs2008/Orga]]

[[Javakurs2008/Tutorenportal_Javakurs_2008]]

[[Javakurs2008/%C3%9Cbungspool]]
( [[Javakurs2008/%C3%9Cbungspool_Entw%C3%BCrfe]],
[[Javakurs2008/Musterloesungen]])

Javakurs2008/Gliederung

2008-03-13T14:40:39Z

Robert L: /* LE 1 (45 min), Tag 1 */ interessanten

== Tagesplahn des letzen Jahres ==

Hier sind auch die '''Folien des letzen Jahres''' verlinkt.

{| border="0" cellpadding="4" cellspacing="2"
|- bgcolor="#D8D8D8"
!Zeit
!Di
!Mi
!Do
!Fr
|- bgcolor="#E8E8E8"
|9:00 [[C.t.]]
|bgcolor="#E8E8E8" |[[Javakurs2007/Vortrag01 | Vortrag]] (MA 042)
|bgcolor="#E8E8E8" |[[Javakurs2007/Vortrag03 | Vortrag]] (MA 042)
|bgcolor="#E8E8E8" |[[Javakurs2007/Vortrag04 | Vortrag]] (MA 042)
|bgcolor="#E8E8E8" |[[Javakurs2007/Vortrag06 | Vortrag]] (MA 042)
|- bgcolor="#F5F5F5"
|10:00
|rowspan=2 |Übung
|rowspan=2 |Übung
|rowspan=2 |Übung
|rowspan=2 |Übung
|- bgcolor="#F5F5F5"
|11.00
|- bgcolor="#FFFFFF"
|12:00
|Mittagspause
|Mittagspause
|Mittagspause
|Mittagspause
|- bgcolor="#E8E8E8"
|13:00 [[C.t.]]
|[[Javakurs2007/Vortrag02 | Vortrag]] (MA 042)
| bgcolor="#F5F5F5" rowspan=3 |Übung
|[[Javakurs2007/Vortrag05 | Vortrag]] (MA 042)
| bgcolor="#F5F5F5" rowspan=3 |Übung
|- bgcolor="#F5F5F5"
|14:00
|rowspan=2 | Übung
|rowspan=2 | Übung
|- bgcolor="#F5F5F5"
|15:00

|}

=== LE 1 (45 min), Tag 1 ===
*'''Vortragende''':
*'''Interessenten''': Milan Mehner, Felix Friedrich

* Organisatorisches
* HelloWorld
* Wie wird ein iteratives Programm verarbeitet?
* Variablen
** Deklaration und Zuweisung
** wichtige Basistypen
* Fallunterscheidungen
* Blöcke und Einrückung
* Kommentare
* compilieren und ausführen
* Fehlermeldungen

=== LE 2 (45 min), Tag 1 ===
*'''Vortragende''':
*'''Interessenten''':

* Arrays
* Schleifen
** Opal beispiel
** while
** for
** Schleifenbedingungen
** Endlosschleifen vermeiden (Gleitkommazahlen, >=, ...)

=== LE 3 (45 min), Tag 2 ===
*'''Vortragende''':
*'''Interessenten''':

* Methoden
** Warum benutzen wir Methoden?
** Wie werden sie deklariert?
** Call by Value
** Unterschied Methode/Funktion
* sprechende Namen
* Testen
** Testwerte finden
** Was kann man mit Testen erreichen, warum trotzdem essentiell
* Debugging

=== LE 4 (45 min), Tag 3 ===
*'''Vortragende''':
*'''Interessenten''': Robert Lubkoll

* Wie bearbeiten geübte Programmierer eine Aufgabenstellung ?
* Wo fange ich mit dem Schreiben eines Programms an ?
* Wie behalte ich den Überblick in meinem Code ?
* Warum ist cooler Code schlechter Code ?

=== LE 5 (45 min), Tag 3 ===
*'''Vortragende''':
*'''Interessenten''': Robert Lubkoll

* Was ist ein Objekt?
* Wie funktioniert die Java-Syntax für Objekte?
* Welche Fehler treten beim Programmieren mit Objekten häufig auf?
* Wie verwendet man Objekte um seinen Code aufzuteilen?

* Objektorientierung
** Gruppierung von Daten/eigene Datentypen
** Zugriffsschutz
** Daten bringen ihre Methoden mit

=== LE 6 (45 min), Tag 4 ===
*'''Vortragende''':
*'''Interessenten''':

* Wiederholung LE 5
* Kapselung /Information Hiding
* Java API
* Standardmethoden (ohne Vererbung)
** Aber schon polymorphie, also ''(Object)myFancyOwnObject.toString()'' tut das richtige
** toString
** equals
* == versus equals
* Motivierung
** Beispiele mit Datentyperstellung und erzeugten Instanzen in C++, C#, J++, ...

== Abschlussveranstaltung ==
* Bedankung bei IRB, Teilnehmer, etc.
* Ellen hält, wie jedes Jahr, eine Rede ;)

== Links ==

[[Javakurs2008]]

[[Javakurs2008/Orga]]

[[Javakurs2008/Tutorenportal_Javakurs_2008]]

[[Javakurs2008/%C3%9Cbungspool]]
( [[Javakurs2008/%C3%9Cbungspool_Entw%C3%BCrfe]],
[[Javakurs2008/Musterloesungen]])

Javakurs2008/Orga

2008-03-13T14:28:08Z

Robert L: /* Plahnungsseiten */ Links

== Lings Plahnungsseiten ==

[[Javakurs2008/Gliederung_Javakurs_2008]]

[[Javakurs2008/Tutorenportal_Javakurs_2008]]

[[Javakurs2008/%C3%9Cbungspool]]
( [[Javakurs2008/%C3%9Cbungspool_Entw%C3%BCrfe]],
[[Javakurs2008/Musterloesungen]])

[[Javakurs2008]]

== TODOS ==

== Orga Team ==
* Mario B.
* Björn L.
* Felix F.
* Sebastian L.

== Vortragende ==
* Mario B.
* Kai D.
* Felix F.
* Milan M.
* Robert L.
* Daniel K.
* Robert B.
* Nadim E. S.
* Katrin L.
* Björn L.

== Tutoren ==
* Gert G.
* Dan L.
* Alexander K.
* Martin Z.
* Björn B.
* Nadim E. S.
* Robert B.
* Mario B.
* Björn L.
* Felix F.
* Michael G.
* Katrin L.
* <s>Robert L.</s>
* Kai D.
* Milan M.
* Daniel K.
* Thaddäus K.
* Reiner C.

== Räume ==
* H 1058 vom 07. bis 8. April von 9 - 16 Uhr
* MA 004 vom 09. bis 10. April von 9 - 16 Uhr

Javakurs2008/Tutorenportal

2008-03-13T14:27:08Z

Robert L: Links

== TODO ==

# Übungsaufgaben sowie Musterlösungen korrekturlesen, gegebenenfalls ändern oder erweitern.

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

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

'''Dienstag:'''
{| border="0" cellpadding="4" cellspacing="2"
|- bgcolor="#D8D8D8"
! Raum
! Tutoren
! Plätze
! Tutanten anwesend

|- bgcolor="#E8E8E8"
|
|
|
| 

|- bgcolor="#F5F5F5"
|
|
|
| 

|- bgcolor="#E8E8E8"
|
|
|
| 

|- bgcolor="#F5F5F5"
|
|
|
| 

|- bgcolor="#E8E8E8"
|
|
|
| 

|- bgcolor="#F5F5F5"
|
|
|
| 

|}

'''Historie:'''
* Die Tabelle wird nach jedem Tag kopiert, um einen Überblick über die Teilnehmerzahl zu gewinnen

* [[Javakurs2008/Raumauslastung_Montag | Montag]]
* [[Javakurs2008/Raumauslastung_Dienstag | Dienstag]]
* [[Javakurs2008/Raumauslastung_Mittwoch | Mittwoch]]
* [[Javakurs2008/Raumauslastung_Donnerstag | Donnerstag]]

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

== Entwurf der Übungsaufgaben ==

* Alte Übungsaufgaben:
*''' Übernehmen wir die so, oder machen wir Änderungen? '''
[[Javakurs2007/%C3%9Cbungspool_Entw%C3%BCrfe]]

[[Javakurs2007/Musterloesungen]]

[[Javakurs2007/%C3%9Cbungspool]]

* Neue Übungsaufgaben

[[Javakurs2008/%C3%9Cbungspool_Entw%C3%BCrfe]]

[[Javakurs2008/Musterloesungen]]

[[Javakurs2008/%C3%9Cbungspool]]

== Planung der Vorträge ==
[[Gliederung_Javakurs_2007]]

== 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 ===
javakurs2008 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

== Links ==

[[Javakurs2008]]

[[Javakurs2008/Orga]]

[[Javakurs2008/Gliederung_Javakurs_2008]]

[[Javakurs2008/%C3%9Cbungspool]]
( [[Javakurs2008/%C3%9Cbungspool_Entw%C3%BCrfe]],
[[Javakurs2008/Musterloesungen]])

Javakurs2008/Gliederung

2008-03-13T14:26:15Z

Robert L: Links

== Tagesplahn des letzen Jahres ==

Hier sind auch die '''Folien des letzen Jahres''' verlinkt.

{| border="0" cellpadding="4" cellspacing="2"
|- bgcolor="#D8D8D8"
!Zeit
!Di
!Mi
!Do
!Fr
|- bgcolor="#E8E8E8"
|9:00 [[C.t.]]
|bgcolor="#E8E8E8" |[[Javakurs2007/Vortrag01 | Vortrag]] (MA 042)
|bgcolor="#E8E8E8" |[[Javakurs2007/Vortrag03 | Vortrag]] (MA 042)
|bgcolor="#E8E8E8" |[[Javakurs2007/Vortrag04 | Vortrag]] (MA 042)
|bgcolor="#E8E8E8" |[[Javakurs2007/Vortrag06 | Vortrag]] (MA 042)
|- bgcolor="#F5F5F5"
|10:00
|rowspan=2 |Übung
|rowspan=2 |Übung
|rowspan=2 |Übung
|rowspan=2 |Übung
|- bgcolor="#F5F5F5"
|11.00
|- bgcolor="#FFFFFF"
|12:00
|Mittagspause
|Mittagspause
|Mittagspause
|Mittagspause
|- bgcolor="#E8E8E8"
|13:00 [[C.t.]]
|[[Javakurs2007/Vortrag02 | Vortrag]] (MA 042)
| bgcolor="#F5F5F5" rowspan=3 |Übung
|[[Javakurs2007/Vortrag05 | Vortrag]] (MA 042)
| bgcolor="#F5F5F5" rowspan=3 |Übung
|- bgcolor="#F5F5F5"
|14:00
|rowspan=2 | Übung
|rowspan=2 | Übung
|- bgcolor="#F5F5F5"
|15:00

|}

=== LE 1 (45 min), Tag 1 ===
*'''Vortragende''':
*'''Interessenten''':

* Organisatorisches
* HelloWorld
* Wie wird ein iteratives Programm verarbeitet?
* Variablen
** Deklaration und Zuweisung
** wichtige Basistypen
* Fallunterscheidungen
* Blöcke und Einrückung
* Kommentare
* compilieren und ausführen
* Fehlermeldungen

=== LE 2 (45 min), Tag 1 ===
*'''Vortragende''':
*'''Interessenten''':

* Arrays
* Schleifen
** Opal beispiel
** while
** for
** Schleifenbedingungen
** Endlosschleifen vermeiden (Gleitkommazahlen, >=, ...)

=== LE 3 (45 min), Tag 2 ===
*'''Vortragende''':
*'''Interessenten''':

* Methoden
** Warum benutzen wir Methoden?
** Wie werden sie deklariert?
** Call by Value
** Unterschied Methode/Funktion
* sprechende Namen
* Testen
** Testwerte finden
** Was kann man mit Testen erreichen, warum trotzdem essentiell
* Debugging

=== LE 4 (45 min), Tag 3 ===
*'''Vortragende''':
*'''Interessenten''': Robert Lubkoll

* Wie bearbeiten geübte Programmierer eine Aufgabenstellung ?
* Wo fange ich mit dem Schreiben eines Programms an ?
* Wie behalte ich den Überblick in meinem Code ?
* Warum ist cooler Code schlechter Code ?

=== LE 5 (45 min), Tag 3 ===
*'''Vortragende''':
*'''Interessenten''': Robert Lubkoll

* Was ist ein Objekt?
* Wie funktioniert die Java-Syntax für Objekte?
* Welche Fehler treten beim Programmieren mit Objekten häufig auf?
* Wie verwendet man Objekte um seinen Code aufzuteilen?

* Objektorientierung
** Gruppierung von Daten/eigene Datentypen
** Zugriffsschutz
** Daten bringen ihre Methoden mit

=== LE 6 (45 min), Tag 4 ===
*'''Vortragende''':
*'''Interessenten''':

* Wiederholung LE 5
* Kapselung /Information Hiding
* Java API
* Standardmethoden (ohne Vererbung)
** Aber schon polymorphie, also ''(Object)myFancyOwnObject.toString()'' tut das richtige
** toString
** equals
* == versus equals
* Motivierung
** Beispiele mit Datentyperstellung und erzeugten Instanzen in C++, C#, J++, ...

== Abschlussveranstaltung ==
* Bedankung bei IRB, Teilnehmer, etc.
* Ellen hält, wie jedes Jahr, eine Rede ;)

== Links ==

[[Javakurs2008]]

[[Javakurs2008/Orga]]

[[Javakurs2008/Tutorenportal_Javakurs_2008]]

[[Javakurs2008/%C3%9Cbungspool]]
( [[Javakurs2008/%C3%9Cbungspool_Entw%C3%BCrfe]],
[[Javakurs2008/Musterloesungen]])

Javakurs2008/Gliederung

2008-03-13T14:21:53Z

Robert L: Links

== Links ==

[[Javakurs2008/Orga]]

[[Javakurs2008/Tutorenportal_Javakurs_2008]]

== Tagesplahn des letzen Jahres ==

Hier sind auch die '''Folien des letzen Jahres''' verlinkt.

{| border="0" cellpadding="4" cellspacing="2"
|- bgcolor="#D8D8D8"
!Zeit
!Di
!Mi
!Do
!Fr
|- bgcolor="#E8E8E8"
|9:00 [[C.t.]]
|bgcolor="#E8E8E8" |[[Javakurs2007/Vortrag01 | Vortrag]] (MA 042)
|bgcolor="#E8E8E8" |[[Javakurs2007/Vortrag03 | Vortrag]] (MA 042)
|bgcolor="#E8E8E8" |[[Javakurs2007/Vortrag04 | Vortrag]] (MA 042)
|bgcolor="#E8E8E8" |[[Javakurs2007/Vortrag06 | Vortrag]] (MA 042)
|- bgcolor="#F5F5F5"
|10:00
|rowspan=2 |Übung
|rowspan=2 |Übung
|rowspan=2 |Übung
|rowspan=2 |Übung
|- bgcolor="#F5F5F5"
|11.00
|- bgcolor="#FFFFFF"
|12:00
|Mittagspause
|Mittagspause
|Mittagspause
|Mittagspause
|- bgcolor="#E8E8E8"
|13:00 [[C.t.]]
|[[Javakurs2007/Vortrag02 | Vortrag]] (MA 042)
| bgcolor="#F5F5F5" rowspan=3 |Übung
|[[Javakurs2007/Vortrag05 | Vortrag]] (MA 042)
| bgcolor="#F5F5F5" rowspan=3 |Übung
|- bgcolor="#F5F5F5"
|14:00
|rowspan=2 | Übung
|rowspan=2 | Übung
|- bgcolor="#F5F5F5"
|15:00

|}

=== LE 1 (45 min), Tag 1 ===
*'''Vortragende''':
*'''Interessenten''':

* Organisatorisches
* HelloWorld
* Wie wird ein iteratives Programm verarbeitet?
* Variablen
** Deklaration und Zuweisung
** wichtige Basistypen
* Fallunterscheidungen
* Blöcke und Einrückung
* Kommentare
* compilieren und ausführen
* Fehlermeldungen

=== LE 2 (45 min), Tag 1 ===
*'''Vortragende''':
*'''Interessenten''':

* Arrays
* Schleifen
** Opal beispiel
** while
** for
** Schleifenbedingungen
** Endlosschleifen vermeiden (Gleitkommazahlen, >=, ...)

=== LE 3 (45 min), Tag 2 ===
*'''Vortragende''':
*'''Interessenten''':

* Methoden
** Warum benutzen wir Methoden?
** Wie werden sie deklariert?
** Call by Value
** Unterschied Methode/Funktion
* sprechende Namen
* Testen
** Testwerte finden
** Was kann man mit Testen erreichen, warum trotzdem essentiell
* Debugging

=== LE 4 (45 min), Tag 3 ===
*'''Vortragende''':
*'''Interessenten''': Robert Lubkoll

* Wie bearbeiten geübte Programmierer eine Aufgabenstellung ?
* Wo fange ich mit dem Schreiben eines Programms an ?
* Wie behalte ich den Überblick in meinem Code ?
* Warum ist cooler Code schlechter Code ?

=== LE 5 (45 min), Tag 3 ===
*'''Vortragende''':
*'''Interessenten''': Robert Lubkoll

* Was ist ein Objekt?
* Wie funktioniert die Java-Syntax für Objekte?
* Welche Fehler treten beim Programmieren mit Objekten häufig auf?
* Wie verwendet man Objekte um seinen Code aufzuteilen?

* Objektorientierung
** Gruppierung von Daten/eigene Datentypen
** Zugriffsschutz
** Daten bringen ihre Methoden mit

=== LE 6 (45 min), Tag 4 ===
*'''Vortragende''':
*'''Interessenten''':

* Wiederholung LE 5
* Kapselung /Information Hiding
* Java API
* Standardmethoden (ohne Vererbung)
** Aber schon polymorphie, also ''(Object)myFancyOwnObject.toString()'' tut das richtige
** toString
** equals
* == versus equals
* Motivierung
** Beispiele mit Datentyperstellung und erzeugten Instanzen in C++, C#, J++, ...

== Übungen ==

*[[Javakurs2007/%C3%9Cbungspool_Entw%C3%BCrfe]]
*[[Javakurs2008/%C3%9Cbungspool_Entw%C3%BCrfe]]

== Abschlussveranstaltung ==
* Bedankung bei IRB, Teilnehmer, etc.
* Ellen hält, wie jedes Jahr, eine Rede ;)

Javakurs2008/Tutorenportal

2008-03-13T14:19:24Z

Robert L: /* Mailingliste */ 2007 -> 2008

Javakurs2008/Gliederung

2008-03-13T14:17:00Z

Robert L: /* LE 5 (45 min), Tag 3 */

== Tagesplahn des letzen Jahres ==

Hier sind auch die '''Folien des letzen Jahres''' verlinkt.

{| border="0" cellpadding="4" cellspacing="2"
|- bgcolor="#D8D8D8"
!Zeit
!Di
!Mi
!Do
!Fr
|- bgcolor="#E8E8E8"
|9:00 [[C.t.]]
|bgcolor="#E8E8E8" |[[Javakurs2007/Vortrag01 | Vortrag]] (MA 042)
|bgcolor="#E8E8E8" |[[Javakurs2007/Vortrag03 | Vortrag]] (MA 042)
|bgcolor="#E8E8E8" |[[Javakurs2007/Vortrag04 | Vortrag]] (MA 042)
|bgcolor="#E8E8E8" |[[Javakurs2007/Vortrag06 | Vortrag]] (MA 042)
|- bgcolor="#F5F5F5"
|10:00
|rowspan=2 |Übung
|rowspan=2 |Übung
|rowspan=2 |Übung
|rowspan=2 |Übung
|- bgcolor="#F5F5F5"
|11.00
|- bgcolor="#FFFFFF"
|12:00
|Mittagspause
|Mittagspause
|Mittagspause
|Mittagspause
|- bgcolor="#E8E8E8"
|13:00 [[C.t.]]
|[[Javakurs2007/Vortrag02 | Vortrag]] (MA 042)
| bgcolor="#F5F5F5" rowspan=3 |Übung
|[[Javakurs2007/Vortrag05 | Vortrag]] (MA 042)
| bgcolor="#F5F5F5" rowspan=3 |Übung
|- bgcolor="#F5F5F5"
|14:00
|rowspan=2 | Übung
|rowspan=2 | Übung
|- bgcolor="#F5F5F5"
|15:00

|}

=== LE 1 (45 min), Tag 1 ===
*'''Vortragende''':
*'''Interessenten''':

* Organisatorisches
* HelloWorld
* Wie wird ein iteratives Programm verarbeitet?
* Variablen
** Deklaration und Zuweisung
** wichtige Basistypen
* Fallunterscheidungen
* Blöcke und Einrückung
* Kommentare
* compilieren und ausführen
* Fehlermeldungen

=== LE 2 (45 min), Tag 1 ===
*'''Vortragende''':
*'''Interessenten''':

* Arrays
* Schleifen
** Opal beispiel
** while
** for
** Schleifenbedingungen
** Endlosschleifen vermeiden (Gleitkommazahlen, >=, ...)

=== LE 3 (45 min), Tag 2 ===
*'''Vortragende''':
*'''Interessenten''':

* Methoden
** Warum benutzen wir Methoden?
** Wie werden sie deklariert?
** Call by Value
** Unterschied Methode/Funktion
* sprechende Namen
* Testen
** Testwerte finden
** Was kann man mit Testen erreichen, warum trotzdem essentiell
* Debugging

=== LE 4 (45 min), Tag 3 ===
*'''Vortragende''':
*'''Interessenten''': Robert Lubkoll

* Wie bearbeiten geübte Programmierer eine Aufgabenstellung ?
* Wo fange ich mit dem Schreiben eines Programms an ?
* Wie behalte ich den Überblick in meinem Code ?
* Warum ist cooler Code schlechter Code ?

=== LE 5 (45 min), Tag 3 ===
*'''Vortragende''':
*'''Interessenten''': Robert Lubkoll

* Was ist ein Objekt?
* Wie funktioniert die Java-Syntax für Objekte?
* Welche Fehler treten beim Programmieren mit Objekten häufig auf?
* Wie verwendet man Objekte um seinen Code aufzuteilen?

* Objektorientierung
** Gruppierung von Daten/eigene Datentypen
** Zugriffsschutz
** Daten bringen ihre Methoden mit

=== LE 6 (45 min), Tag 4 ===
*'''Vortragende''':
*'''Interessenten''':

* Wiederholung LE 5
* Kapselung /Information Hiding
* Java API
* Standardmethoden (ohne Vererbung)
** Aber schon polymorphie, also ''(Object)myFancyOwnObject.toString()'' tut das richtige
** toString
** equals
* == versus equals
* Motivierung
** Beispiele mit Datentyperstellung und erzeugten Instanzen in C++, C#, J++, ...

== Übungen ==

*[[Javakurs2007/%C3%9Cbungspool_Entw%C3%BCrfe]]
*[[Javakurs2008/%C3%9Cbungspool_Entw%C3%BCrfe]]

== Abschlussveranstaltung ==
* Bedankung bei IRB, Teilnehmer, etc.
* Ellen hält, wie jedes Jahr, eine Rede ;)

Javakurs2008/Gliederung

2008-03-13T14:15:26Z

Robert L: /* LE 1 (45 min), Tag 1 */

== Tagesplahn des letzen Jahres ==

Hier sind auch die '''Folien des letzen Jahres''' verlinkt.

{| border="0" cellpadding="4" cellspacing="2"
|- bgcolor="#D8D8D8"
!Zeit
!Di
!Mi
!Do
!Fr
|- bgcolor="#E8E8E8"
|9:00 [[C.t.]]
|bgcolor="#E8E8E8" |[[Javakurs2007/Vortrag01 | Vortrag]] (MA 042)
|bgcolor="#E8E8E8" |[[Javakurs2007/Vortrag03 | Vortrag]] (MA 042)
|bgcolor="#E8E8E8" |[[Javakurs2007/Vortrag04 | Vortrag]] (MA 042)
|bgcolor="#E8E8E8" |[[Javakurs2007/Vortrag06 | Vortrag]] (MA 042)
|- bgcolor="#F5F5F5"
|10:00
|rowspan=2 |Übung
|rowspan=2 |Übung
|rowspan=2 |Übung
|rowspan=2 |Übung
|- bgcolor="#F5F5F5"
|11.00
|- bgcolor="#FFFFFF"
|12:00
|Mittagspause
|Mittagspause
|Mittagspause
|Mittagspause
|- bgcolor="#E8E8E8"
|13:00 [[C.t.]]
|[[Javakurs2007/Vortrag02 | Vortrag]] (MA 042)
| bgcolor="#F5F5F5" rowspan=3 |Übung
|[[Javakurs2007/Vortrag05 | Vortrag]] (MA 042)
| bgcolor="#F5F5F5" rowspan=3 |Übung
|- bgcolor="#F5F5F5"
|14:00
|rowspan=2 | Übung
|rowspan=2 | Übung
|- bgcolor="#F5F5F5"
|15:00

|}

=== LE 1 (45 min), Tag 1 ===
*'''Vortragende''':
*'''Interessenten''':

* Organisatorisches
* HelloWorld
* Wie wird ein iteratives Programm verarbeitet?
* Variablen
** Deklaration und Zuweisung
** wichtige Basistypen
* Fallunterscheidungen
* Blöcke und Einrückung
* Kommentare
* compilieren und ausführen
* Fehlermeldungen

=== LE 2 (45 min), Tag 1 ===
*'''Vortragende''':
*'''Interessenten''':

* Arrays
* Schleifen
** Opal beispiel
** while
** for
** Schleifenbedingungen
** Endlosschleifen vermeiden (Gleitkommazahlen, >=, ...)

=== LE 3 (45 min), Tag 2 ===
*'''Vortragende''':
*'''Interessenten''':

* Methoden
** Warum benutzen wir Methoden?
** Wie werden sie deklariert?
** Call by Value
** Unterschied Methode/Funktion
* sprechende Namen
* Testen
** Testwerte finden
** Was kann man mit Testen erreichen, warum trotzdem essentiell
* Debugging

=== LE 4 (45 min), Tag 3 ===
*'''Vortragende''':
*'''Interessenten''': Robert Lubkoll

* Wie bearbeiten geübte Programmierer eine Aufgabenstellung ?
* Wo fange ich mit dem Schreiben eines Programms an ?
* Wie behalte ich den Überblick in meinem Code ?
* Warum ist cooler Code schlechter Code ?

=== LE 5 (45 min), Tag 3 ===
*'''Vortragende''':
*'''Interessenten''': Robert Lubkoll

* Objektorientierung
** Gruppierung von Daten/eigene Datentypen
** Zugriffsschutz
** Daten bringen ihre Methoden mit

=== LE 6 (45 min), Tag 4 ===
*'''Vortragende''':
*'''Interessenten''':

* Wiederholung LE 5
* Kapselung /Information Hiding
* Java API
* Standardmethoden (ohne Vererbung)
** Aber schon polymorphie, also ''(Object)myFancyOwnObject.toString()'' tut das richtige
** toString
** equals
* == versus equals
* Motivierung
** Beispiele mit Datentyperstellung und erzeugten Instanzen in C++, C#, J++, ...

== Übungen ==

*[[Javakurs2007/%C3%9Cbungspool_Entw%C3%BCrfe]]
*[[Javakurs2008/%C3%9Cbungspool_Entw%C3%BCrfe]]

== Abschlussveranstaltung ==
* Bedankung bei IRB, Teilnehmer, etc.
* Ellen hält, wie jedes Jahr, eine Rede ;)

Javakurs2008/Gliederung

2008-03-13T14:14:53Z

Robert L: /* LE 4 (45 min), Tag 3 */

== Tagesplahn des letzen Jahres ==

Hier sind auch die '''Folien des letzen Jahres''' verlinkt.

{| border="0" cellpadding="4" cellspacing="2"
|- bgcolor="#D8D8D8"
!Zeit
!Di
!Mi
!Do
!Fr
|- bgcolor="#E8E8E8"
|9:00 [[C.t.]]
|bgcolor="#E8E8E8" |[[Javakurs2007/Vortrag01 | Vortrag]] (MA 042)
|bgcolor="#E8E8E8" |[[Javakurs2007/Vortrag03 | Vortrag]] (MA 042)
|bgcolor="#E8E8E8" |[[Javakurs2007/Vortrag04 | Vortrag]] (MA 042)
|bgcolor="#E8E8E8" |[[Javakurs2007/Vortrag06 | Vortrag]] (MA 042)
|- bgcolor="#F5F5F5"
|10:00
|rowspan=2 |Übung
|rowspan=2 |Übung
|rowspan=2 |Übung
|rowspan=2 |Übung
|- bgcolor="#F5F5F5"
|11.00
|- bgcolor="#FFFFFF"
|12:00
|Mittagspause
|Mittagspause
|Mittagspause
|Mittagspause
|- bgcolor="#E8E8E8"
|13:00 [[C.t.]]
|[[Javakurs2007/Vortrag02 | Vortrag]] (MA 042)
| bgcolor="#F5F5F5" rowspan=3 |Übung
|[[Javakurs2007/Vortrag05 | Vortrag]] (MA 042)
| bgcolor="#F5F5F5" rowspan=3 |Übung
|- bgcolor="#F5F5F5"
|14:00
|rowspan=2 | Übung
|rowspan=2 | Übung
|- bgcolor="#F5F5F5"
|15:00

|}

=== LE 1 (45 min), Tag 1 ===
*'''Vortragende''':
*'''Interessenten''':

* Organisatorisches
* HelloWorld
* Wie wird ein iteratives Programm verarbeitet?
* Variablen
** Deklaration und Zuweisung
** wichtige Basistypen
* Fallunterscheidungen
* Blöcke und Einrückung
* Kommentare
* compilieren und ausführen
* Compilermeldungen lesen

=== LE 2 (45 min), Tag 1 ===
*'''Vortragende''':
*'''Interessenten''':

* Arrays
* Schleifen
** Opal beispiel
** while
** for
** Schleifenbedingungen
** Endlosschleifen vermeiden (Gleitkommazahlen, >=, ...)

=== LE 3 (45 min), Tag 2 ===
*'''Vortragende''':
*'''Interessenten''':

* Methoden
** Warum benutzen wir Methoden?
** Wie werden sie deklariert?
** Call by Value
** Unterschied Methode/Funktion
* sprechende Namen
* Testen
** Testwerte finden
** Was kann man mit Testen erreichen, warum trotzdem essentiell
* Debugging

=== LE 4 (45 min), Tag 3 ===
*'''Vortragende''':
*'''Interessenten''': Robert Lubkoll

* Wie bearbeiten geübte Programmierer eine Aufgabenstellung ?
* Wo fange ich mit dem Schreiben eines Programms an ?
* Wie behalte ich den Überblick in meinem Code ?
* Warum ist cooler Code schlechter Code ?

=== LE 5 (45 min), Tag 3 ===
*'''Vortragende''':
*'''Interessenten''': Robert Lubkoll

* Objektorientierung
** Gruppierung von Daten/eigene Datentypen
** Zugriffsschutz
** Daten bringen ihre Methoden mit

=== LE 6 (45 min), Tag 4 ===
*'''Vortragende''':
*'''Interessenten''':

* Wiederholung LE 5
* Kapselung /Information Hiding
* Java API
* Standardmethoden (ohne Vererbung)
** Aber schon polymorphie, also ''(Object)myFancyOwnObject.toString()'' tut das richtige
** toString
** equals
* == versus equals
* Motivierung
** Beispiele mit Datentyperstellung und erzeugten Instanzen in C++, C#, J++, ...

== Übungen ==

*[[Javakurs2007/%C3%9Cbungspool_Entw%C3%BCrfe]]
*[[Javakurs2008/%C3%9Cbungspool_Entw%C3%BCrfe]]

== Abschlussveranstaltung ==
* Bedankung bei IRB, Teilnehmer, etc.
* Ellen hält, wie jedes Jahr, eine Rede ;)

Javakurs2008/Gliederung

2008-03-13T14:11:35Z

Robert L: /* Tagesplahn des letzen Jahres */

== Tagesplahn des letzen Jahres ==

Hier sind auch die '''Folien des letzen Jahres''' verlinkt.

{| border="0" cellpadding="4" cellspacing="2"
|- bgcolor="#D8D8D8"
!Zeit
!Di
!Mi
!Do
!Fr
|- bgcolor="#E8E8E8"
|9:00 [[C.t.]]
|bgcolor="#E8E8E8" |[[Javakurs2007/Vortrag01 | Vortrag]] (MA 042)
|bgcolor="#E8E8E8" |[[Javakurs2007/Vortrag03 | Vortrag]] (MA 042)
|bgcolor="#E8E8E8" |[[Javakurs2007/Vortrag04 | Vortrag]] (MA 042)
|bgcolor="#E8E8E8" |[[Javakurs2007/Vortrag06 | Vortrag]] (MA 042)
|- bgcolor="#F5F5F5"
|10:00
|rowspan=2 |Übung
|rowspan=2 |Übung
|rowspan=2 |Übung
|rowspan=2 |Übung
|- bgcolor="#F5F5F5"
|11.00
|- bgcolor="#FFFFFF"
|12:00
|Mittagspause
|Mittagspause
|Mittagspause
|Mittagspause
|- bgcolor="#E8E8E8"
|13:00 [[C.t.]]
|[[Javakurs2007/Vortrag02 | Vortrag]] (MA 042)
| bgcolor="#F5F5F5" rowspan=3 |Übung
|[[Javakurs2007/Vortrag05 | Vortrag]] (MA 042)
| bgcolor="#F5F5F5" rowspan=3 |Übung
|- bgcolor="#F5F5F5"
|14:00
|rowspan=2 | Übung
|rowspan=2 | Übung
|- bgcolor="#F5F5F5"
|15:00

|}

=== LE 1 (45 min), Tag 1 ===
*'''Vortragende''':
*'''Interessenten''':

* Organisatorisches
* HelloWorld
* Wie wird ein iteratives Programm verarbeitet?
* Variablen
** Deklaration und Zuweisung
** wichtige Basistypen
* Fallunterscheidungen
* Blöcke und Einrückung
* Kommentare
* compilieren und ausführen
* Compilermeldungen lesen

=== LE 2 (45 min), Tag 1 ===
*'''Vortragende''':
*'''Interessenten''':

* Arrays
* Schleifen
** Opal beispiel
** while
** for
** Schleifenbedingungen
** Endlosschleifen vermeiden (Gleitkommazahlen, >=, ...)

=== LE 3 (45 min), Tag 2 ===
*'''Vortragende''':
*'''Interessenten''':

* Methoden
** Warum benutzen wir Methoden?
** Wie werden sie deklariert?
** Call by Value
** Unterschied Methode/Funktion
* sprechende Namen
* Testen
** Testwerte finden
** Was kann man mit Testen erreichen, warum trotzdem essentiell
* Debugging

=== LE 4 (45 min), Tag 3 ===
*'''Vortragende''':
*'''Interessenten''': Robert Lubkoll

* Wie löse ich Aufgaben
* Strukturelle Programmierung

=== LE 5 (45 min), Tag 3 ===
*'''Vortragende''':
*'''Interessenten''': Robert Lubkoll

* Objektorientierung
** Gruppierung von Daten/eigene Datentypen
** Zugriffsschutz
** Daten bringen ihre Methoden mit

=== LE 6 (45 min), Tag 4 ===
*'''Vortragende''':
*'''Interessenten''':

* Wiederholung LE 5
* Kapselung /Information Hiding
* Java API
* Standardmethoden (ohne Vererbung)
** Aber schon polymorphie, also ''(Object)myFancyOwnObject.toString()'' tut das richtige
** toString
** equals
* == versus equals
* Motivierung
** Beispiele mit Datentyperstellung und erzeugten Instanzen in C++, C#, J++, ...

== Übungen ==

*[[Javakurs2007/%C3%9Cbungspool_Entw%C3%BCrfe]]
*[[Javakurs2008/%C3%9Cbungspool_Entw%C3%BCrfe]]

== Abschlussveranstaltung ==
* Bedankung bei IRB, Teilnehmer, etc.
* Ellen hält, wie jedes Jahr, eine Rede ;)

Javakurs2008/Tutorenportal

2008-03-13T14:10:08Z

Robert L:

== TODO ==

# Übungsaufgaben sowie Musterlösungen korrekturlesen, gegebenenfalls ändern oder erweitern.

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

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

'''Dienstag:'''
{| border="0" cellpadding="4" cellspacing="2"
|- bgcolor="#D8D8D8"
! Raum
! Tutoren
! Plätze
! Tutanten anwesend

|- bgcolor="#E8E8E8"
|
|
|
| 

|- bgcolor="#F5F5F5"
|
|
|
| 

|- bgcolor="#E8E8E8"
|
|
|
| 

|- bgcolor="#F5F5F5"
|
|
|
| 

|- bgcolor="#E8E8E8"
|
|
|
| 

|- bgcolor="#F5F5F5"
|
|
|
| 

|}

'''Historie:'''
* Die Tabelle wird nach jedem Tag kopiert, um einen Überblick über die Teilnehmerzahl zu gewinnen

* [[Javakurs2008/Raumauslastung_Montag | Montag]]
* [[Javakurs2008/Raumauslastung_Dienstag | Dienstag]]
* [[Javakurs2008/Raumauslastung_Mittwoch | Mittwoch]]
* [[Javakurs2008/Raumauslastung_Donnerstag | Donnerstag]]

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

== Entwurf der Übungsaufgaben ==

* Alte Übungsaufgaben:
*''' Übernehmen wir die so, oder machen wir Änderungen? '''
[[Javakurs2007/%C3%9Cbungspool_Entw%C3%BCrfe]]

[[Javakurs2007/Musterloesungen]]

[[Javakurs2007/%C3%9Cbungspool]]

* Neue Übungsaufgaben

[[Javakurs2008/%C3%9Cbungspool_Entw%C3%BCrfe]]

[[Javakurs2008/Musterloesungen]]

[[Javakurs2008/%C3%9Cbungspool]]

== Planung der Vorträge ==
[[Gliederung_Javakurs_2007]]

== 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 ===
javakurs2007 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

Javakurs2008/Orga

2008-03-13T13:59:50Z

Robert L: Links zu Orgaseiten

== Plahnungsseiten ==

[[Javakurs2008/Gliederung_Javakurs_2008]]

[[Javakurs2008/Tutorenportal_Javakurs_2008]]

== TODOS ==

== Orga Team ==
* Mario B.
* Björn L.
* Felix F.
* Sebastian L.

== Vortragende ==
* Mario B.
* Kai D.
* Felix F.
* Milan M.
* Robert L.
* Daniel K.
* Robert B.
* Nadim E. S.
* Katrin L.
* Björn L.

== Tutoren ==
* Gert G.
* Dan L.
* Alexander K.
* Martin Z.
* Björn B.
* Nadim E. S.
* Robert B.
* Mario B.
* Björn L.
* Felix F.
* Michael G.
* Katrin L.
* <s>Robert L.</s>
* Kai D.
* Milan M.
* Daniel K.
* Thaddäus K.
* Reiner C.

== Räume ==
* H 1058 vom 07. bis 8. April von 9 - 16 Uhr
* MA 004 vom 09. bis 10. April von 9 - 16 Uhr

Javakurs2008/Gliederung

2008-03-13T13:56:30Z

Robert L:

== Tagesplahn des letzen Jahres ==

{| border="0" cellpadding="4" cellspacing="2"
|- bgcolor="#D8D8D8"
!Zeit
!Di
!Mi
!Do
!Fr
|- bgcolor="#E8E8E8"
|9:00 [[C.t.]]
|bgcolor="#E8E8E8" |[[Javakurs2007/Vortrag01 | Vortrag]] (MA 042)
|bgcolor="#E8E8E8" |[[Javakurs2007/Vortrag03 | Vortrag]] (MA 042)
|bgcolor="#E8E8E8" |[[Javakurs2007/Vortrag04 | Vortrag]] (MA 042)
|bgcolor="#E8E8E8" |[[Javakurs2007/Vortrag06 | Vortrag]] (MA 042)
|- bgcolor="#F5F5F5"
|10:00
|rowspan=2 |Übung
|rowspan=2 |Übung
|rowspan=2 |Übung
|rowspan=2 |Übung
|- bgcolor="#F5F5F5"
|11.00
|- bgcolor="#FFFFFF"
|12:00
|Mittagspause
|Mittagspause
|Mittagspause
|Mittagspause
|- bgcolor="#E8E8E8"
|13:00 [[C.t.]]
|[[Javakurs2007/Vortrag02 | Vortrag]] (MA 042)
| bgcolor="#F5F5F5" rowspan=3 |Übung
|[[Javakurs2007/Vortrag05 | Vortrag]] (MA 042)
| bgcolor="#F5F5F5" rowspan=3 |Übung
|- bgcolor="#F5F5F5"
|14:00
|rowspan=2 | Übung
|rowspan=2 | Übung
|- bgcolor="#F5F5F5"
|15:00

|}

* Hier sind auch die Folien des letzten Jahres abgelegt

=== LE 1 (45 min), Tag 1 ===
*'''Vortragende''':
*'''Interessenten''':

* Organisatorisches
* HelloWorld
* Wie wird ein iteratives Programm verarbeitet?
* Variablen
** Deklaration und Zuweisung
** wichtige Basistypen
* Fallunterscheidungen
* Blöcke und Einrückung
* Kommentare
* compilieren und ausführen
* Compilermeldungen lesen

=== LE 2 (45 min), Tag 1 ===
*'''Vortragende''':
*'''Interessenten''':

* Arrays
* Schleifen
** Opal beispiel
** while
** for
** Schleifenbedingungen
** Endlosschleifen vermeiden (Gleitkommazahlen, >=, ...)

=== LE 3 (45 min), Tag 2 ===
*'''Vortragende''':
*'''Interessenten''':

* Methoden
** Warum benutzen wir Methoden?
** Wie werden sie deklariert?
** Call by Value
** Unterschied Methode/Funktion
* sprechende Namen
* Testen
** Testwerte finden
** Was kann man mit Testen erreichen, warum trotzdem essentiell
* Debugging

=== LE 4 (45 min), Tag 3 ===
*'''Vortragende''':
*'''Interessenten''': Robert Lubkoll

* Wie löse ich Aufgaben
* Strukturelle Programmierung

=== LE 5 (45 min), Tag 3 ===
*'''Vortragende''':
*'''Interessenten''': Robert Lubkoll

* Objektorientierung
** Gruppierung von Daten/eigene Datentypen
** Zugriffsschutz
** Daten bringen ihre Methoden mit

=== LE 6 (45 min), Tag 4 ===
*'''Vortragende''':
*'''Interessenten''':

* Wiederholung LE 5
* Kapselung /Information Hiding
* Java API
* Standardmethoden (ohne Vererbung)
** Aber schon polymorphie, also ''(Object)myFancyOwnObject.toString()'' tut das richtige
** toString
** equals
* == versus equals
* Motivierung
** Beispiele mit Datentyperstellung und erzeugten Instanzen in C++, C#, J++, ...

== Übungen ==

*[[Javakurs2007/%C3%9Cbungspool_Entw%C3%BCrfe]]
*[[Javakurs2008/%C3%9Cbungspool_Entw%C3%BCrfe]]

== Abschlussveranstaltung ==
* Bedankung bei IRB, Teilnehmer, etc.
* Ellen hält, wie jedes Jahr, eine Rede ;)

Javakurs2008/Gliederung

2008-03-13T13:55:03Z

Robert L: Plahnung des J-Kurses 2008

== Tagesplahn des letzen Jahres ==

{| border="0" cellpadding="4" cellspacing="2"
|- bgcolor="#D8D8D8"
!Zeit
!Di
!Mi
!Do
!Fr
|- bgcolor="#E8E8E8"
|9:00 [[C.t.]]
|bgcolor="#E8E8E8" |[[Javakurs2007/Vortrag01 | Vortrag]] (MA 042)
|bgcolor="#E8E8E8" |[[Javakurs2007/Vortrag03 | Vortrag]] (MA 042)
|bgcolor="#E8E8E8" |[[Javakurs2007/Vortrag04 | Vortrag]] (MA 042)
|bgcolor="#E8E8E8" |[[Javakurs2007/Vortrag06 | Vortrag]] (MA 042)
|- bgcolor="#F5F5F5"
|10:00
|rowspan=2 |Übung
|rowspan=2 |Übung
|rowspan=2 |Übung
|rowspan=2 |Übung
|- bgcolor="#F5F5F5"
|11.00
|- bgcolor="#FFFFFF"
|12:00
|Mittagspause
|Mittagspause
|Mittagspause
|Mittagspause
|- bgcolor="#E8E8E8"
|13:00 [[C.t.]]
|[[Javakurs2007/Vortrag02 | Vortrag]] (MA 042)
| bgcolor="#F5F5F5" rowspan=3 |Übung
|[[Javakurs2007/Vortrag05 | Vortrag]] (MA 042)
| bgcolor="#F5F5F5" rowspan=3 |Übung
|- bgcolor="#F5F5F5"
|14:00
|rowspan=2 | Übung
|rowspan=2 | Übung
|- bgcolor="#F5F5F5"
|15:00

|}

* Hier sind auch die Folien des letzten Jahres abgelegt

=== LE 1 (45 min), Tag 1 ===
'''Vortragende''':
'''Interessenten''':

* Organisatorisches
* HelloWorld
* Wie wird ein iteratives Programm verarbeitet?
* Variablen
** Deklaration und Zuweisung
** wichtige Basistypen
* Fallunterscheidungen
* Blöcke und Einrückung
* Kommentare
* compilieren und ausführen
* Compilermeldungen lesen

=== LE 2 (45 min), Tag 1 ===
'''Vortragende''':
'''Interessenten''':

* Arrays
* Schleifen
** Opal beispiel
** while
** for
** Schleifenbedingungen
** Endlosschleifen vermeiden (Gleitkommazahlen, >=, ...)

=== LE 3 (45 min), Tag 2 ===
'''Vortragende''':
'''Interessenten''':

* Methoden
** Warum benutzen wir Methoden?
** Wie werden sie deklariert?
** Call by Value
** Unterschied Methode/Funktion
* sprechende Namen
* Testen
** Testwerte finden
** Was kann man mit Testen erreichen, warum trotzdem essentiell
* Debugging

=== LE 4 (45 min), Tag 3 ===
'''Vortragende''':
'''Interessenten''':
* Wie löse ich Aufgaben
* Strukturelle Programmierung

=== LE 5 (45 min), Tag 3 ===
'''Vortragende''':
'''Interessenten''':

* Objektorientierung
** Gruppierung von Daten/eigene Datentypen
** Zugriffsschutz
** Daten bringen ihre Methoden mit

=== LE 6 (45 min), Tag 4 ===
'''Vortragende''':
'''Interessenten''':

* Wiederholung LE 5
* Kapselung /Information Hiding
* Java API
* Standardmethoden (ohne Vererbung)
** Aber schon polymorphie, also ''(Object)myFancyOwnObject.toString()'' tut das richtige
** toString
** equals
* == versus equals
* Motivierung
** Beispiele mit Datentyperstellung und erzeugten Instanzen in C++, C#, J++, ...

== Übungen ==

*[[Javakurs2007/%C3%9Cbungspool_Entw%C3%BCrfe]]
*[[Javakurs2008/%C3%9Cbungspool_Entw%C3%BCrfe]]

== Abschlussveranstaltung ==
* Bedankung bei IRB, Teilnehmer, etc.
* Ellen hält, wie jedes Jahr, eine Rede ;)

Gliederung Javakurs 2007

2007-03-05T14:20:28Z

Robert L: /* Übungen */ noch mehr Links

== Vorlesungen ==
Nach einem Gespräch mit Herrn Pepper haben wir uns entschlossen im Kurs mehr Zeit für die Grundlagen der Javaprogrammierung aufzuwenden und weniger stark auf Objektorientierung und weiterführende Konzepte einzugehen.

Im Folgenden sind die Lehreinheiten der einzelnen Tage und ihre Inhalte aufgelistet.
Die Verteilung der Themen an Vortragende würden wir gerne hier übers Wiki regeln. Ich denke wenn sich jeder bei mindestens zwei LEs als Interessent einträgr und vermerkt wie viele LEs er insgesamt halten möchte, sollte sich bis zum 11.03.2007 für jede LE auf diesem Wege ein Team gefunden haben.

=== LE 1 (45 min), Tag 1 ===
'''Interessenten:''' RobertL (max 2LE),
* Organisatorisches
* HelloWorld
* Wie wird ein iteratives Programm verarbeitet?
* Variablen
** Deklaration und Zuweisung
** wichtige Basistypen
* Fallunterscheidungen
* Blöcke und Einrückung
* Kommentare
* compilieren und ausführen
* Compilermeldungen lesen

=== LE 2 (45 min), Tag 1 ===
'''Interessenten:''' RobertB,
* Arrays
* Schleifen
** while
** for
** Schleifenbedingungen
** Endlosschleifen vermeiden (Gleitkommazahlen, >=, ...)

=== LE 3 (45 min), Tag 2 ===
'''Interessenten:''' RobertB,
* Methoden
** Warum benutzen wir Methoden?
** Wie werden sie deklariert?
** Call by Value
* sprechende Namen
* Testen
** Testwerte finden
** Was kann man mit Testen erreichen, warum trotzdem essentiell
* Debugging

=== LE 4 (45 min), Tag 3 ===
'''Interessenten:'''RobertL (max 2LE)
* Wie löse ich Aufgaben
* Strukturelle Programmierung

=== LE 5 (45 min), Tag 3 ===
'''Interessenten:''' RobertL (max 2LE),
* Objektorientierung
** Gruppierung von Daten/eigene Datentypen
** Daten bringen ihre Methoden mit

=== LE 6 (45 min), Tag 4 ===
'''Interessenten:'''
* Wiederholung LE 5
* Kapselung /Information Hiding
* Java API
* Standardmethoden (ohne Vererbung)
** toString
** equals
* == versus equals

== Übungen ==

=== LE 1 (2h), Tag 1 ===
[[Javakurs2007 Aufgabe RL01 | Vom Arbeiten mit der Konsole bis "Hallo Welt"]]

[[Javakurs2007 Aufgabe RL02 | Fallunterscheidungen in einem Textbasierten Fantasyspiel]]

=== LE 2 (2h), Tag 1 ===

=== LE 3 (4h), Tag 2 ===

=== LE 4 (2h), Tag 3 ===

=== LE 5 (2h), Tag 3 ===

[[Javakurs2006/Rennschnecke | Objektorientierung am Beispiel eines Schneckenrennens]]

=== LE 6 (4h), Tag 4 ===

=== Fortgeschritten ===
[[Javakurs2006/Cäsar-Chiffre | Eigenständiges Programmieren eines Chiffriersystems]]

== Abschlussveranstaltung ==
* bedankung bei IRB, Teilnehmer, etc.
* ellen hält eine Rede ;)

Javakurs/Übungsaufgaben/Von der Console zum HelloWorld

2007-03-05T13:31:57Z

Robert L: Aus Javakurs 2006 übernommen

=== Getting started ===
* Melde dich an einer der Suns in den Rechnerräumen mit deinem CS-Account an. Solltest du selbst keinen CS-Account haben wende dich an einen der Tutoren.
* Sollte das Arbeiten unter Unix neu für dich sein, dann nimm dir etwas Zeit um dich mit den elementaren Konsolenkommandos vertraut zu machen. <br>Erste Hilfe zu den Kommandows gibt es unter [https://wiki.freitagsrunde.org/Robert_Lubkoll/Java_Kurs/Tag1/Teil1/Kommandohilfe https://wiki.freitagsrunde.org/Robert_Lubkoll/Java_Kurs/Tag1/Teil1/Kommandohilfe]
* Lege dir ein Verzeichnis Javakurs an und kopiere die Vorgaben für die erste Lehreinheit von [[TODO]] an diesen Ort.
* Entpacke die Vorgaben, die sich nun in deinem Verzeichnis befinden.
* Lösche im entstandenen Verzeichnis LE1/ die Datei WegMitDieserDatei und das Verzeichnis WegMitDiesemVerzeichnis.
* Benenne im selben Verzeichnis die Datei GibMirEinenNamen.txt in CompiliereMich.java um.
* Compiliere die soeben entstandene Datei CompiliereMich.java mit Hilfe von javac.
* Führe das Programm in der entstandenen Datei CompiliereMich.class mit Hilfe von java aus.
* Öffne einen Texteditor deiner Wahl. Schreibe ein Programm das "HalloWelt" auf der Konsole ausgibt und teste es.

TODO: https://wiki.freitagsrunde.org/Robert_Lubkoll/Java_Kurs/Tag1/Teil1/Kommandohilfe verschieben

TODO: Vorgaben erstellen und geeignet ablegen

Gliederung Javakurs 2007

2007-03-05T13:08:13Z

Robert L: /* LE 1 (2h), Tag 1 */ Aufgabe LE1 verlinkt

== Vorlesungen ==
Nach einem Gespräch mit Herrn Pepper haben wir uns entschlossen im Kurs mehr Zeit für die Grundlagen der Javaprogrammierung aufzuwenden und weniger stark auf Objektorientierung und weiterführende Konzepte einzugehen.

Im Folgenden sind die Lehreinheiten der einzelnen Tage und ihre Inhalte aufgelistet.
Die Verteilung der Themen an Vortragende würden wir gerne hier übers Wiki regeln. Ich denke wenn sich jeder bei mindestens zwei LEs als Interessent einträgr und vermerkt wie viele LEs er insgesamt halten möchte, sollte sich bis zum 11.03.2007 für jede LE auf diesem Wege ein Team gefunden haben.

=== LE 1 (45 min), Tag 1 ===
'''Interessenten:''' RobertL (max 2LE),
* Organisatorisches
* HelloWorld
* Wie wird ein iteratives Programm verarbeitet?
* Variablen
** Deklaration und Zuweisung
** wichtige Basistypen
* Fallunterscheidungen
* Blöcke und Einrückung
* Kommentare
* compilieren und ausführen
* Compilermeldungen lesen

=== LE 2 (45 min), Tag 1 ===
'''Interessenten:''' RobertB,
* Arrays
* Schleifen
** while
** for
** Schleifenbedingungen
** Endlosschleifen vermeiden (Gleitkommazahlen, >=, ...)

=== LE 3 (45 min), Tag 2 ===
'''Interessenten:''' RobertB,
* Methoden
** Warum benutzen wir Methoden?
** Wie werden sie deklariert?
** Call by Value
* sprechende Namen
* Testen
** Testwerte finden
** Was kann man mit Testen erreichen, warum trotzdem essentiell
* Debugging

=== LE 4 (45 min), Tag 3 ===
'''Interessenten:'''RobertL (max 2LE)
* Wie löse ich Aufgaben
* Strukturelle Programmierung

=== LE 5 (45 min), Tag 3 ===
'''Interessenten:''' RobertL (max 2LE),
* Objektorientierung
** Gruppierung von Daten/eigene Datentypen
** Daten bringen ihre Methoden mit

=== LE 6 (45 min), Tag 4 ===
'''Interessenten:'''
* Wiederholung LE 5
* Kapselung /Information Hiding
* Java API
* Standardmethoden (ohne Vererbung)
** toString
** equals
* == versus equals

== Übungen ==

=== LE 1 (2h), Tag 1 ===
[[Javakurs2007 Aufgabe RL01 | Vom Arbeiten mit de Konsole bis "Hallo Welt"]]

=== LE 2 (2h), Tag 1 ===

=== LE 3 (4h), Tag 2 ===

=== LE 4 (2h), Tag 3 ===

=== LE 5 (2h), Tag 3 ===

=== LE 6 (4h), Tag 4 ===

== Abschlussveranstaltung ==
* bedankung bei IRB, Teilnehmer, etc.
* ellen hält eine Rede ;)

Eclipsekurs 2006/Tag 1

2006-05-05T14:27:49Z

Robert L: /* Aufgabe 2 (für Experten) */

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

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

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

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

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

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

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

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

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

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

== Übungsaufgaben ==

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

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

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

Viel Spaß!

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

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

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

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

'''Cäsar-Chiffre'''

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

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

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

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

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

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

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

----

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

Eclipsekurs 2006/Tag 1

2006-05-05T14:16:28Z

Robert L: /* Aufgabe 2 (für Experten) */

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

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

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

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

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

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

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

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

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

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

== Übungsaufgaben ==

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

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

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

Viel Spaß!

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

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

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

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

'''Cäsar-Chiffre'''

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

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

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

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

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

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

Wenn du willst, kannst du deinen Chiffrieralgorithmus auch verändern oder einen anderen implementieren, 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 gegebenem Schlüssel zu entschlüsseln ;)

----

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

Eclipsekurs 2006/Tag 1

2006-05-05T14:07:42Z

Robert L: /* Aufgabe 2 (für Experten) */

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

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

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

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

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

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

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

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

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

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

== Übungsaufgaben ==

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

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

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

Viel Spaß!

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

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

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

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

'''Cäsar-Chiffre'''

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

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

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

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

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

Wenn du willst, kannst du deinen Chiffrieralgorithmus auch verändern oder einen anderen implementieren, 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 gegebenem Schlüssel zu entschlüsseln ;)

----

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

Eclipsekurs 2006/Tag 1

2006-05-05T14:01:23Z

Robert L: /* Übungsaufgaben */

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

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

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

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

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

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

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

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

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

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

== Übungsaufgaben ==

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

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

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

Viel Spaß!

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

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

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

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

'''Cäsar-Chiffre'''

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

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

#Erstelle ein Programm, das einen Text aus einer Datei einliest, mit einem Schlüssel (einer Zahl zwischen 1 und 25) durch eine [http://de.wikipedia.org/wiki/Caesar-Chiffre#Sicherheit Cäsar-Chiffre] verschlüsselt und in einer neuen Datei (z.B. mit anderer Änderung) speichert.
#* Für mehr Komfort, aber nicht notwendig: Sowohl der Dateiname als auch der Schlüssel sollen über die Console eingegeben werden können.
#Erweitere dein Programm so, dass es einen mit der selben Chiffre verschlüsselten Text bei gegebenem Schlüssel entschlüsseln kann und in einer separaten Datei speichert.
#Erweitere dein Programm so, dass es in der Lage ist einen beliebigen mit einer [http://de.wikipedia.org/wiki/Caesar-Chiffre#Sicherheit Cäsar-Chiffre] verschlüsselten Text mit Hilfe von [http://de.wikipedia.org/wiki/H%C3%A4ufigkeitsanalyse Häufigkeitsanalyse] ohne Schlüssel zu kennen zu entschlüsseln. Gib auch den gefundenen Schlüssel 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.

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

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

Wenn du willst, kannst du deinen Chiffrieralgorithmus auch verändern oder einen anderen implementieren, 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 gegebenem Schlüssel zu entschlüsseln ;)

----

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

Eclipsekurs 2006/Tag 1

2006-05-05T12:28:48Z

Robert L: /* Erste Schritte */ templates hinzugefügt

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

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

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

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

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

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

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

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

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

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

== Übungsaufgaben ==

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

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

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

Viel Spaß!

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

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

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

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

'''Cäsar-Chiffre'''

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

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

#Erstelle ein Programm das einen Text aus einer Datei einliest, mit einem Passwort durch eine [http://de.wikipedia.org/wiki/Caesar-Chiffre#Sicherheit Cäsar-Chiffre] verschlüsselt und in einer neuen Datei (z.B. mit anderer Änderung) speichert.
#* Für mehr Komfort, aber nicht notwendig: Sowohl der Dateiname als auch das Passwort sollen über die Console eingegeben werden können.
#Erweitere dein Programm so, dass es einen mit der selben Chiffre verschlüsselten Text bei gegebenem Passwort entschlüsseln kann und in einer separaten Datei speichert.
#Erweitere dein Programm so, dass es in der Lage ist einen beliebigen mit einer [http://de.wikipedia.org/wiki/Caesar-Chiffre#Sicherheit Cäsar-Chiffre] verschlüsselten Text mit Hilfe von [http://de.wikipedia.org/wiki/H%C3%A4ufigkeitsanalyse Häufigkeitsanalyse] ohne das Passwort zu kennen zu entschlüsseln. 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.

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

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

Wenn du willst, kannst du deinen Chiffrieralgorithmus auch verändern oder einen anderen implementieren, 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 gegebenem Passwort zu entschlüsseln ;)

----

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

Eclipsekurs 2006/Tag 1

2006-05-05T09:49:08Z

Robert L: /* Übungsaufgaben */ Tippfehler

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

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

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

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

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

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

=== Programmabbruch ===
* Lege eine Methode "void keepLooping()" an welche eine Endlosschleife mit einer Consolenausgabe (z.B. "still looping") enthält. Führe diese Methode aus und brich die Ausführung mit einem der roten Stopbuttons ab.

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

=== Javadoc ===
* Kommentiere deinen beiden Funktionen mit Javadoc.
''Tipp:'' /**[Enter] in der Zeile vor einer Methode oder Klasse legt automatisch einen Javadoc-Rumpf mit allen benutzten Parametern an.
* Bewege die Maus in deinem Hauptprogramm auf eine Stelle, an der du eine der kommentierten Funktionen verwendest (die Maus muss mit der Spitze über dem Methoden-Aufruf sein) und sieh dir die Javadoc-Ansicht an.

== Übungsaufgaben ==

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

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

Aufgabe zwei ist auschließlich für diejenigen die schon Einiges an Erfahrung in Java mitbringen und einfach nur ein wenig mit Eclipse programmieren wollen.

Viel Spaß!

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

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

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

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

'''Cäsar-Chiffre'''

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

Macht dir auch Geanken darüber wie du die einzelnden Teile frühzeitig testen kannst.

#Erstelle ein Programm das einen Text aus einer Datei einliest, mit einem Passwort durch eine [http://de.wikipedia.org/wiki/Caesar-Chiffre#Sicherheit Cäsar-Chiffre] verschlüsselt und in einer neuen Datei (z.B. mit anderer Änderung) speichert.
#* Für mehr Komfort, aber nicht notwendig: Sowohl der Dateiname als auch das Passwort sollen über die Console eingegeben werden können.
#Erweitere dein Programm so, dass es einen mit der selben Chiffre verschlüsselten Text bei gegebendem Passwort entschlüsseln kann und in einer seperaten Datei speichert.
#Erweitere dein Programm so, dass es in der Lage ist einen beliebigen mit einer [http://de.wikipedia.org/wiki/Caesar-Chiffre#Sicherheit Cäsar-Chiffre] verschlüsselten Text mit Hilfe von [http://de.wikipedia.org/wiki/H%C3%A4ufigkeitsanalyse Häufigkeitsanalyse] ohne das Passwort zu kennen zu entschlüsseln. 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.

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

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

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

==Aufgabe: Glücksspiel (wird vielleicht weggelassen)==

Bei diesem Spiel gibt es 37 Felder, auf die der Spieler 200 Euro (in Einheiten von 1 Euro) verteilt. Danach wird eine Zufallszahl n ermittelt und an den Spieler wird der Gewinn ausgezahlt. Die Gewinnsumme errechnet sich wie folgt:

Summe( von i=0, bis 36,(board[i]*(6 − | i − n |)))

wobei board[i] den Wert der Belegung des Feldes i darstellt.
Allerdings sollen nur positive Summanden in die Summe eingehen.

===Berechnung der Gewinnsumme===
Vervollständige die ''play''-Funktion, welche bei der Eingabe
eines ''boards'' die Gewinnsumme errechnet. Die Funktion soll also die Aufgabe eines Spielleiters
bei einem Roulettespiel einnehmen.

''Tipp:'' Es wird sinnvoll sein, eine Methoden '''static int abs(int x)''' und eine Methode
'''static int max(int x, int y)''' zu implementieren. '''abs()''' liefert dabei den Betrag
der übergebenen Zahl zurück, während '''max()''' den größeren der beiden übergebenen
Werte zurückliefert.

===Ideale Boardbelegungen===
Erstelle ein paar Board-Belegungen und versuche Deinen Gewinn
zu maximieren. Hierbei ist es nützlich, die Gewinnfunktion zu verstehen. Mache Dir also klar
unter welchen Umständen man wieviel gewinnt.

* Gibt es Zahlen die günstiger sind als andere?
* Lohnt es sich auf einzelne Felder besonders viel zu setzen?
* Ist es besser den Einsatz gleichmäßig zu verteilen?

Versuche eine möglichst ideale Board-Belegung zu finden, indem du viele (z.B. 100 000) Spiele
mit Deiner festen Belegung simulierst. Falls Du magst, kannst Du auch andere Gewinnfunktionen
ausprobieren. z.B. ∗36 bei einem Volltreffer und ∗6 falls eines der acht benachbarten Felder
getroffen wurde. Die Praktikabilität einer neuen Gewinnfunktion kannst Du mit der Lösung aus
Aufgabe 3.1 überprüfen. Der durchschnittliche Gewinn sollte den Einsatz nicht überschreiten!

----

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

Eclipsekurs 2006/Tag 1

2006-05-05T09:44:33Z

Robert L: Format

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

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

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

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

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

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

=== Programmabbruch ===
* Lege eine Methode "void keepLooping()" an welche eine Endlosschleife mit einer Consolenausgabe (z.B. "still looping") enthält. Führe diese Methode aus und brich die Ausführung mit einem der roten Stopbuttons ab.

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

=== Javadoc ===
* Kommentiere deinen beiden Funktionen mit Javadoc.
''Tipp:'' /**[Enter] in der Zeile vor einer Methode oder Klasse legt automatisch einen Javadoc-Rumpf mit allen benutzten Parametern an.
* Bewege die Maus in deinem Hauptprogramm auf eine Stelle, an der du eine der kommentierten Funktionen verwendest (die Maus muss mit der Spitze über dem Methoden-Aufruf sein) und sieh dir die Javadoc-Ansicht an.

== Übungsaufgaben ==

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

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

Aufgabe zwei ist auschließlich für diejenigen die schon Einiges an Erfahrung in Java mitbringen undeinfach nur ein wenig mit Eclipse programmieren wollen.

Viel Spaß!

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

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

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

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

'''Cäsar-Chiffre'''

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

Macht dir auch Geanken darüber wie du die einzelnden Teile frühzeitig testen kannst.

#Erstelle ein Programm das einen Text aus einer Datei einliest, mit einem Passwort durch eine [http://de.wikipedia.org/wiki/Caesar-Chiffre#Sicherheit Cäsar-Chiffre] verschlüsselt und in einer neuen Datei (z.B. mit anderer Änderung) speichert.
#* Für mehr Komfort, aber nicht notwendig: Sowohl der Dateiname als auch das Passwort sollen über die Console eingegeben werden können.
#Erweitere dein Programm so, dass es einen mit der selben Chiffre verschlüsselten Text bei gegebendem Passwort entschlüsseln kann und in einer seperaten Datei speichert.
#Erweitere dein Programm so, dass es in der Lage ist einen beliebigen mit einer [http://de.wikipedia.org/wiki/Caesar-Chiffre#Sicherheit Cäsar-Chiffre] verschlüsselten Text mit Hilfe von [http://de.wikipedia.org/wiki/H%C3%A4ufigkeitsanalyse Häufigkeitsanalyse] ohne das Passwort zu kennen zu entschlüsseln. 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.

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

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

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

==Aufgabe: Glücksspiel (wird vielleicht weggelassen)==

Bei diesem Spiel gibt es 37 Felder, auf die der Spieler 200 Euro (in Einheiten von 1 Euro) verteilt. Danach wird eine Zufallszahl n ermittelt und an den Spieler wird der Gewinn ausgezahlt. Die Gewinnsumme errechnet sich wie folgt:

Summe( von i=0, bis 36,(board[i]*(6 − | i − n |)))

wobei board[i] den Wert der Belegung des Feldes i darstellt.
Allerdings sollen nur positive Summanden in die Summe eingehen.

===Berechnung der Gewinnsumme===
Vervollständige die ''play''-Funktion, welche bei der Eingabe
eines ''boards'' die Gewinnsumme errechnet. Die Funktion soll also die Aufgabe eines Spielleiters
bei einem Roulettespiel einnehmen.

''Tipp:'' Es wird sinnvoll sein, eine Methoden '''static int abs(int x)''' und eine Methode
'''static int max(int x, int y)''' zu implementieren. '''abs()''' liefert dabei den Betrag
der übergebenen Zahl zurück, während '''max()''' den größeren der beiden übergebenen
Werte zurückliefert.

===Ideale Boardbelegungen===
Erstelle ein paar Board-Belegungen und versuche Deinen Gewinn
zu maximieren. Hierbei ist es nützlich, die Gewinnfunktion zu verstehen. Mache Dir also klar
unter welchen Umständen man wieviel gewinnt.

* Gibt es Zahlen die günstiger sind als andere?
* Lohnt es sich auf einzelne Felder besonders viel zu setzen?
* Ist es besser den Einsatz gleichmäßig zu verteilen?

Versuche eine möglichst ideale Board-Belegung zu finden, indem du viele (z.B. 100 000) Spiele
mit Deiner festen Belegung simulierst. Falls Du magst, kannst Du auch andere Gewinnfunktionen
ausprobieren. z.B. ∗36 bei einem Volltreffer und ∗6 falls eines der acht benachbarten Felder
getroffen wurde. Die Praktikabilität einer neuen Gewinnfunktion kannst Du mit der Lösung aus
Aufgabe 3.1 überprüfen. Der durchschnittliche Gewinn sollte den Einsatz nicht überschreiten!

----

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

Eclipsekurs 2006/Tag 1

2006-05-05T09:25:22Z

Robert L: /* Autocomplition */

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

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

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

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

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

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

=== Programmabbruch ===
* Lege eine Methode "void keepLooping()" an welche eine Endlosschleife mit einer Consolenausgabe (z.B. "still looping") enthält. Führe diese Methode aus und brich die Ausführung mit einem der roten Stopbuttons ab.

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

=== Javadoc ===
* Kommentiere deinen beiden Funktionen mit Javadoc.
''Tipp:'' /**[Enter] in der Zeile vor einer Methode oder Klasse legt automatisch einen Javadoc-Rumpf mit allen benutzten Parametern an.
* Bewege die Maus in deinem Hauptprogramm auf eine Stelle, an der du eine der kommentierten Funktionen verwendest (die Maus muss mit der Spitze über dem Methoden-Aufruf sein) und sieh dir die Javadoc-Ansicht an.

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

Wer schon einige Erfahrung mit Java hat, die Herrausforderung sucht oder die erste Aufgabe im Javakurs vor einigen Wochen schon bearbeitet hat kann übrigens getrost zur Zweiten springen.

Viel Spaß!

==Aufgabe1 (entspannt)==

Für alle die sie noch nicht kennen, die [[Javakurs2006/Rennschnecke| Rennschnecken]].

==Aufgabe 2 (schon kniffeliger) ==

=== Cäsar-Chiffre ===

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

Macht dir auch Geanken darüber wie du die einzelnden Teile frühzeitig testen kannst.

#Erstelle ein Programm das einen Text aus einer Datei einliest, mit einem Passwort durch eine [http://de.wikipedia.org/wiki/Caesar-Chiffre#Sicherheit Cäsar-Chiffre] verschlüsselt und in einer neuen Datei (z.B. mit anderer Änderung) speichert.
#* Für mehr Komfort, aber nicht notwendig: Sowohl der Dateiname als auch das Passwort sollen über die Console eingegeben werden können.
#Erweitere dein Programm so, dass es einen mit der selben Chiffre verschlüsselten Text bei gegebendem Passwort entschlüsseln kann und in einer seperaten Datei speichert.
#Erweitere dein Programm so, dass es in der Lage ist einen beliebigen mit einer [http://de.wikipedia.org/wiki/Caesar-Chiffre#Sicherheit Cäsar-Chiffre] verschlüsselten Text mit Hilfe von [http://de.wikipedia.org/wiki/H%C3%A4ufigkeitsanalyse Häufigkeitsanalyse] ohne das Passwort zu kennen zu entschlüsseln. 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.

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

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

==Aufgabe: Glücksspiel (wird vielleicht weggelassen)==

Bei diesem Spiel gibt es 37 Felder, auf die der Spieler 200 Euro (in Einheiten von 1 Euro) verteilt. Danach wird eine Zufallszahl n ermittelt und an den Spieler wird der Gewinn ausgezahlt. Die Gewinnsumme errechnet sich wie folgt:

Summe( von i=0, bis 36,(board[i]*(6 − | i − n |)))

wobei board[i] den Wert der Belegung des Feldes i darstellt.
Allerdings sollen nur positive Summanden in die Summe eingehen.

===Berechnung der Gewinnsumme===
Vervollständige die ''play''-Funktion, welche bei der Eingabe
eines ''boards'' die Gewinnsumme errechnet. Die Funktion soll also die Aufgabe eines Spielleiters
bei einem Roulettespiel einnehmen.

''Tipp:'' Es wird sinnvoll sein, eine Methoden '''static int abs(int x)''' und eine Methode
'''static int max(int x, int y)''' zu implementieren. '''abs()''' liefert dabei den Betrag
der übergebenen Zahl zurück, während '''max()''' den größeren der beiden übergebenen
Werte zurückliefert.

===Ideale Boardbelegungen===
Erstelle ein paar Board-Belegungen und versuche Deinen Gewinn
zu maximieren. Hierbei ist es nützlich, die Gewinnfunktion zu verstehen. Mache Dir also klar
unter welchen Umständen man wieviel gewinnt.

* Gibt es Zahlen die günstiger sind als andere?
* Lohnt es sich auf einzelne Felder besonders viel zu setzen?
* Ist es besser den Einsatz gleichmäßig zu verteilen?

Versuche eine möglichst ideale Board-Belegung zu finden, indem du viele (z.B. 100 000) Spiele
mit Deiner festen Belegung simulierst. Falls Du magst, kannst Du auch andere Gewinnfunktionen
ausprobieren. z.B. ∗36 bei einem Volltreffer und ∗6 falls eines der acht benachbarten Felder
getroffen wurde. Die Praktikabilität einer neuen Gewinnfunktion kannst Du mit der Lösung aus
Aufgabe 3.1 überprüfen. Der durchschnittliche Gewinn sollte den Einsatz nicht überschreiten!

----

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

Eclipsekurs 2006/Tag 1

2006-05-05T09:20:26Z

Robert L: /* Erste Schritte */ Format

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

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

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

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

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

=== Autocomplition ===
* Lege eine neue Klasse "TinyObject" an, welche '''keine''' main Methode enthält.
* "TinyObject" soll drei Klassenvariablen enthalten. Wenn ein Objekt dieser Art erzeugt wird, weden diese mit einem beliebigen Wert initialisiert.
* Erweitere "TinyObject" um eine Methode "void printYouselfAndThis(String text)", die den übergebenen Text sowie den Inhalt der Klassenvariablen auf der Konsole ausgibt.
''Hinweis:'' Sieh dir an, was passiert, wenn du in dieser Funktion "this." schreibst und anschließend kurz wartest oder die Autocomplition mit [Str+Space] aktivierst.

* Zum Testen dieser Methode kannst du in der Klasse "Spielwiese" ein "TinyObject" erzeugen und darauf die Methode aufrufen.

=== Programmabbruch ===
* Lege eine Methode "void keepLooping()" an welche eine Endlosschleife mit einer Consolenausgabe (z.B. "still looping") enthält. Führe diese Methode aus und brich die Ausführung mit einem der roten Stopbuttons ab.

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

=== Javadoc ===
* Kommentiere deinen beiden Funktionen mit Javadoc.
''Tipp:'' /**[Enter] in der Zeile vor einer Methode oder Klasse legt automatisch einen Javadoc-Rumpf mit allen benutzten Parametern an.
* Bewege die Maus in deinem Hauptprogramm auf eine Stelle, an der du eine der kommentierten Funktionen verwendest (die Maus muss mit der Spitze über dem Methoden-Aufruf sein) und sieh dir die Javadoc-Ansicht an.

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

Wer schon einige Erfahrung mit Java hat, die Herrausforderung sucht oder die erste Aufgabe im Javakurs vor einigen Wochen schon bearbeitet hat kann übrigens getrost zur Zweiten springen.

Viel Spaß!

==Aufgabe1 (entspannt)==

Für alle die sie noch nicht kennen, die [[Javakurs2006/Rennschnecke| Rennschnecken]].

==Aufgabe 2 (schon kniffeliger) ==

=== Cäsar-Chiffre ===

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

Macht dir auch Geanken darüber wie du die einzelnden Teile frühzeitig testen kannst.

#Erstelle ein Programm das einen Text aus einer Datei einliest, mit einem Passwort durch eine [http://de.wikipedia.org/wiki/Caesar-Chiffre#Sicherheit Cäsar-Chiffre] verschlüsselt und in einer neuen Datei (z.B. mit anderer Änderung) speichert.
#* Für mehr Komfort, aber nicht notwendig: Sowohl der Dateiname als auch das Passwort sollen über die Console eingegeben werden können.
#Erweitere dein Programm so, dass es einen mit der selben Chiffre verschlüsselten Text bei gegebendem Passwort entschlüsseln kann und in einer seperaten Datei speichert.
#Erweitere dein Programm so, dass es in der Lage ist einen beliebigen mit einer [http://de.wikipedia.org/wiki/Caesar-Chiffre#Sicherheit Cäsar-Chiffre] verschlüsselten Text mit Hilfe von [http://de.wikipedia.org/wiki/H%C3%A4ufigkeitsanalyse Häufigkeitsanalyse] ohne das Passwort zu kennen zu entschlüsseln. 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.

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

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

==Aufgabe: Glücksspiel (wird vielleicht weggelassen)==

Bei diesem Spiel gibt es 37 Felder, auf die der Spieler 200 Euro (in Einheiten von 1 Euro) verteilt. Danach wird eine Zufallszahl n ermittelt und an den Spieler wird der Gewinn ausgezahlt. Die Gewinnsumme errechnet sich wie folgt:

Summe( von i=0, bis 36,(board[i]*(6 − | i − n |)))

wobei board[i] den Wert der Belegung des Feldes i darstellt.
Allerdings sollen nur positive Summanden in die Summe eingehen.

===Berechnung der Gewinnsumme===
Vervollständige die ''play''-Funktion, welche bei der Eingabe
eines ''boards'' die Gewinnsumme errechnet. Die Funktion soll also die Aufgabe eines Spielleiters
bei einem Roulettespiel einnehmen.

''Tipp:'' Es wird sinnvoll sein, eine Methoden '''static int abs(int x)''' und eine Methode
'''static int max(int x, int y)''' zu implementieren. '''abs()''' liefert dabei den Betrag
der übergebenen Zahl zurück, während '''max()''' den größeren der beiden übergebenen
Werte zurückliefert.

===Ideale Boardbelegungen===
Erstelle ein paar Board-Belegungen und versuche Deinen Gewinn
zu maximieren. Hierbei ist es nützlich, die Gewinnfunktion zu verstehen. Mache Dir also klar
unter welchen Umständen man wieviel gewinnt.

* Gibt es Zahlen die günstiger sind als andere?
* Lohnt es sich auf einzelne Felder besonders viel zu setzen?
* Ist es besser den Einsatz gleichmäßig zu verteilen?

Versuche eine möglichst ideale Board-Belegung zu finden, indem du viele (z.B. 100 000) Spiele
mit Deiner festen Belegung simulierst. Falls Du magst, kannst Du auch andere Gewinnfunktionen
ausprobieren. z.B. ∗36 bei einem Volltreffer und ∗6 falls eines der acht benachbarten Felder
getroffen wurde. Die Praktikabilität einer neuen Gewinnfunktion kannst Du mit der Lösung aus
Aufgabe 3.1 überprüfen. Der durchschnittliche Gewinn sollte den Einsatz nicht überschreiten!

----

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

Eclipsekurs 2006/Tag 1

2006-05-04T08:06:37Z

Robert L: /* Aufgaben */

== Erste Schritte ==
#Starte die Eclipse-Umgebung mit dem Kommando '''/home/pub/lib/eclipse/eclipse'''
#Projekt anlegen
#*Erstelle ein Java-Projekt "eclipseTutorial" mit getrennten Ordnern für den Quellcode (''src'') und kompilierte class-Dateien (''bin'').
#*Lege in diesem Projekt eine neue Klasse "Spielwiese" an, die eine ''main''-Methode enthält.
#*Erweitere die Klasse zu einem "Hello World"-Programm und führe dieses in Eclipse aus.
#:''Tipp:'' Mit syso[Strg+Leerzeichen] erzeugt die Eclipse-Autocompletion ein System.out.println();
#*Verändere das Programm so, dass es einen beim Start übergebenden Parameter auf dem Bildschirm ausgibt.
#:''Tipp 1:'' Die Funktion main bekommt ihre Parameter als Array von Strings. Der Name des ersten übergebenen Parameters ist also args[0] .
#:''Tipp 2:'' Die Parameter des Programms kannst du in der Run-Configuration einstellen.
#*Baue Fehler in dein Programm ein (Semikolon löschen, Klammer löschen, Tippfehler) und sieh dir an, welche Korrekturvorschläge Eclipse anbietet. Spiele mit diesem Feature ein wenig herum. Du kannst Änderungen [Strg+Z] (Undo) jederzeit rückgängig machen.
#: ''Tipp:'' Beachte die "Problems"-Ansicht, sowie die Markierungen links und rechts vom Editorfenster. Manchmal muss man Änderungen allerdings erst speichern, damit die Anzeigen aktualisiert werden.
#Lege eine neue Klasse "tinyObject" an, welche '''keine''' main Methode enthält.
#*"tinyObject" soll drei Klassenvariablen enthalten. Wenn ein Objekt dieser Art erzeugt wird, weden diese mit einem beliebigen Wert initialisiert.
#*Erweitere "tinyObject" um eine Methode "void printYouselfAndThis(String text)", die den übergebenen Text sowie den Inhalt der Klassenvariablen auf der Konsole ausgibt.
#*''Hinweis:'' Sieh dir an, was passiert, wenn du in dieser Funktion "this." schreibst und anschließend kurz wartest oder die Autocomplition mit [Str+Space] aktivierst.
#*Zum Testen dieser Methode kannst du in der Klasse "Spielwiese" ein "tinyObject" erzeugen und darauf die Methode aufrufen.
#*Lege eine Methode "void keepLooping()" an welche eine Endlosschleife mit einer Consolenausgabe (z.B. "still looping") enthält. Führe diese Methode aus und brich die Ausführung mit einem der roten Stopbuttons ab.
#*Sieh dir die "Outline" Ansicht an und probiere aus wie du mit ihr in deinen Klassen Navigieren kannst.
#*Kommentiere deinen beiden Funktionen mit Javadoc.
#:''Tipp:'' /**[Enter] in der Zeile vor einer Methode oder Klasse legt automatisch einen Javadoc-Rumpf mit allen benutzten Parametern an.
#*Gehe mit dem Cursor in deinem Hauptprogramm auf eine stelle an der du eine der kommentierten Funktionen verwendest und sieh dir die Javadoc-Ansicht an.
#*halte die [Str] Taste gedrückt und gehe mit der Maus über den Funktionsaufruf. Klicke ihn an.

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

Wer schon einige Erfahrung mit Java hat, die Herrausforderung sucht oder die erste Aufgabe im Javakurs vor einigen Wochen schon bearbeitet hat kann übrigens getrost zur Zweiten springen.

Viel Spaß!

==Aufgabe1 (entspannt)==

Für alle die sie noch nicht kennen, die [[Javakurs2006/Rennschnecke| Rennschnecken]].

==Aufgabe 2 (schon kniffeliger) ==

=== Cäsar-Chiffre ===

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

Macht dir auch Geanken darüber wie du die einzelnden Teile frühzeitig testen kannst.

#Erstelle ein Programm das einen Text aus einer Datei einliest, mit einem Passwort durch eine [http://de.wikipedia.org/wiki/Caesar-Chiffre#Sicherheit Cäsar-Chiffre] verschlüsselt und in einer neuen Datei (z.B. mit anderer Änderung) speichert.
#* Für mehr Komfort, aber nicht notwendig: Sowohl der Dateiname als auch das Passwort sollen über die Console eingegeben werden können.
#Erweitere dein Programm so, dass es einen mit der selben Chiffre verschlüsselten Text bei gegebendem Passwort entschlüsseln kann und in einer seperaten Datei speichert.
#Erweitere dein Programm so, dass es in der Lage ist einen beliebigen mit einer [http://de.wikipedia.org/wiki/Caesar-Chiffre#Sicherheit Cäsar-Chiffre] verschlüsselten Text mit Hilfe von [http://de.wikipedia.org/wiki/H%C3%A4ufigkeitsanalyse Häufigkeitsanalyse] ohne das Passwort zu kennen zu entschlüsseln. 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.

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

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

==Aufgabe: Glücksspiel (wird vielleicht weggelassen)==

Bei diesem Spiel gibt es 37 Felder, auf die der Spieler 200 Euro (in Einheiten von 1 Euro) verteilt. Danach wird eine Zufallszahl n ermittelt und an den Spieler wird der Gewinn ausgezahlt. Die Gewinnsumme errechnet sich wie folgt:

Summe( von i=0, bis 36,(board[i]*(6 − | i − n |)))

wobei board[i] den Wert der Belegung des Feldes i darstellt.
Allerdings sollen nur positive Summanden in die Summe eingehen.

===Berechnung der Gewinnsumme===
Vervollständige die ''play''-Funktion, welche bei der Eingabe
eines ''boards'' die Gewinnsumme errechnet. Die Funktion soll also die Aufgabe eines Spielleiters
bei einem Roulettespiel einnehmen.

''Tipp:'' Es wird sinnvoll sein, eine Methoden '''static int abs(int x)''' und eine Methode
'''static int max(int x, int y)''' zu implementieren. '''abs()''' liefert dabei den Betrag
der übergebenen Zahl zurück, während '''max()''' den größeren der beiden übergebenen
Werte zurückliefert.

===Ideale Boardbelegungen===
Erstelle ein paar Board-Belegungen und versuche Deinen Gewinn
zu maximieren. Hierbei ist es n¨utzlich, die Gewinnfunktion zu verstehen. Mache Dir also klar
unter welchen Umst¨anden man wieviel gewinnt.

*Gibt es Zahlen die g¨unstiger sind als andere?
*Lohnt es sich auf einzelne Felder besonders viel zu setzen?
*Ist es besser den Einsatz gleichm¨aßig zu verteilen?

Versuche eine m¨oglichst ideale Board-Belegung zu finden, indem du viele (z.B. 100 000) Spiele
mit Deiner festen Belegung simulierst. Falls Du magst, kannst Du auch andere Gewinnfunktionen
ausprobieren. z.B. ∗36 bei einem Volltreffer und ∗6 falls eines der acht benachbarten Felder
getroffen wurde. Die Praktikabilit¨at einer neuen Gewinnfunktion kannst Du mit der L¨osung aus
Aufgabe 3.1 ¨uberpr¨ufen. Der durchschnittliche Gewinn sollte den Einsatz nicht ¨uberschreiten!

----

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

Eclipsekurs 2006/Tag 1

2006-05-04T08:05:58Z

Robert L: /* Aufgabe 2 (schon kniffeliger): Cäsar-Chiffre */

== Aufgaben ==
#Starte die Eclipse-Umgebung mit dem Kommando '''/home/pub/lib/eclipse/eclipse'''
#Projekt anlegen
#*Erstelle ein Java-Projekt "eclipseTutorial" mit getrennten Ordnern für den Quellcode (''src'') und kompilierte class-Dateien (''bin'').
#*Lege in diesem Projekt eine neue Klasse "Spielwiese" an, die eine ''main''-Methode enthält.
#*Erweitere die Klasse zu einem "Hello World"-Programm und führe dieses in Eclipse aus.
#:''Tipp:'' Mit syso[Strg+Leerzeichen] erzeugt die Eclipse-Autocompletion ein System.out.println();
#*Verändere das Programm so, dass es einen beim Start übergebenden Parameter auf dem Bildschirm ausgibt.
#:''Tipp 1:'' Die Funktion main bekommt ihre Parameter als Array von Strings. Der Name des ersten übergebenen Parameters ist also args[0] .
#:''Tipp 2:'' Die Parameter des Programms kannst du in der Run-Configuration einstellen.
#*Baue Fehler in dein Programm ein (Semikolon löschen, Klammer löschen, Tippfehler) und sieh dir an, welche Korrekturvorschläge Eclipse anbietet. Spiele mit diesem Feature ein wenig herum. Du kannst Änderungen [Strg+Z] (Undo) jederzeit rückgängig machen.
#: ''Tipp:'' Beachte die "Problems"-Ansicht, sowie die Markierungen links und rechts vom Editorfenster. Manchmal muss man Änderungen allerdings erst speichern, damit die Anzeigen aktualisiert werden.
#Lege eine neue Klasse "tinyObject" an, welche '''keine''' main Methode enthält.
#*"tinyObject" soll drei Klassenvariablen enthalten. Wenn ein Objekt dieser Art erzeugt wird, weden diese mit einem beliebigen Wert initialisiert.
#*Erweitere "tinyObject" um eine Methode "void printYouselfAndThis(String text)", die den übergebenen Text sowie den Inhalt der Klassenvariablen auf der Konsole ausgibt.
#*''Hinweis:'' Sieh dir an, was passiert, wenn du in dieser Funktion "this." schreibst und anschließend kurz wartest oder die Autocomplition mit [Str+Space] aktivierst.
#*Zum Testen dieser Methode kannst du in der Klasse "Spielwiese" ein "tinyObject" erzeugen und darauf die Methode aufrufen.
#*Lege eine Methode "void keepLooping()" an welche eine Endlosschleife mit einer Consolenausgabe (z.B. "still looping") enthält. Führe diese Methode aus und brich die Ausführung mit einem der roten Stopbuttons ab.
#*Sieh dir die "Outline" Ansicht an und probiere aus wie du mit ihr in deinen Klassen Navigieren kannst.
#*Kommentiere deinen beiden Funktionen mit Javadoc.
#:''Tipp:'' /**[Enter] in der Zeile vor einer Methode oder Klasse legt automatisch einen Javadoc-Rumpf mit allen benutzten Parametern an.
#*Gehe mit dem Cursor in deinem Hauptprogramm auf eine stelle an der du eine der kommentierten Funktionen verwendest und sieh dir die Javadoc-Ansicht an.
#*halte die [Str] Taste gedrückt und gehe mit der Maus über den Funktionsaufruf. Klicke ihn an.

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

Wer schon einige Erfahrung mit Java hat, die Herrausforderung sucht oder die erste Aufgabe im Javakurs vor einigen Wochen schon bearbeitet hat kann übrigens getrost zur Zweiten springen.

Viel Spaß!

==Aufgabe1 (entspannt)==

Für alle die sie noch nicht kennen, die [[Javakurs2006/Rennschnecke| Rennschnecken]].

==Aufgabe 2 (schon kniffeliger) ==

=== Cäsar-Chiffre ===

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

Macht dir auch Geanken darüber wie du die einzelnden Teile frühzeitig testen kannst.

#Erstelle ein Programm das einen Text aus einer Datei einliest, mit einem Passwort durch eine [http://de.wikipedia.org/wiki/Caesar-Chiffre#Sicherheit Cäsar-Chiffre] verschlüsselt und in einer neuen Datei (z.B. mit anderer Änderung) speichert.
#* Für mehr Komfort, aber nicht notwendig: Sowohl der Dateiname als auch das Passwort sollen über die Console eingegeben werden können.
#Erweitere dein Programm so, dass es einen mit der selben Chiffre verschlüsselten Text bei gegebendem Passwort entschlüsseln kann und in einer seperaten Datei speichert.
#Erweitere dein Programm so, dass es in der Lage ist einen beliebigen mit einer [http://de.wikipedia.org/wiki/Caesar-Chiffre#Sicherheit Cäsar-Chiffre] verschlüsselten Text mit Hilfe von [http://de.wikipedia.org/wiki/H%C3%A4ufigkeitsanalyse Häufigkeitsanalyse] ohne das Passwort zu kennen zu entschlüsseln. 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.

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

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

==Aufgabe: Glücksspiel (wird vielleicht weggelassen)==

Bei diesem Spiel gibt es 37 Felder, auf die der Spieler 200 Euro (in Einheiten von 1 Euro) verteilt. Danach wird eine Zufallszahl n ermittelt und an den Spieler wird der Gewinn ausgezahlt. Die Gewinnsumme errechnet sich wie folgt:

Summe( von i=0, bis 36,(board[i]*(6 − | i − n |)))

wobei board[i] den Wert der Belegung des Feldes i darstellt.
Allerdings sollen nur positive Summanden in die Summe eingehen.

===Berechnung der Gewinnsumme===
Vervollständige die ''play''-Funktion, welche bei der Eingabe
eines ''boards'' die Gewinnsumme errechnet. Die Funktion soll also die Aufgabe eines Spielleiters
bei einem Roulettespiel einnehmen.

''Tipp:'' Es wird sinnvoll sein, eine Methoden '''static int abs(int x)''' und eine Methode
'''static int max(int x, int y)''' zu implementieren. '''abs()''' liefert dabei den Betrag
der übergebenen Zahl zurück, während '''max()''' den größeren der beiden übergebenen
Werte zurückliefert.

===Ideale Boardbelegungen===
Erstelle ein paar Board-Belegungen und versuche Deinen Gewinn
zu maximieren. Hierbei ist es n¨utzlich, die Gewinnfunktion zu verstehen. Mache Dir also klar
unter welchen Umst¨anden man wieviel gewinnt.

*Gibt es Zahlen die g¨unstiger sind als andere?
*Lohnt es sich auf einzelne Felder besonders viel zu setzen?
*Ist es besser den Einsatz gleichm¨aßig zu verteilen?

Versuche eine m¨oglichst ideale Board-Belegung zu finden, indem du viele (z.B. 100 000) Spiele
mit Deiner festen Belegung simulierst. Falls Du magst, kannst Du auch andere Gewinnfunktionen
ausprobieren. z.B. ∗36 bei einem Volltreffer und ∗6 falls eines der acht benachbarten Felder
getroffen wurde. Die Praktikabilit¨at einer neuen Gewinnfunktion kannst Du mit der L¨osung aus
Aufgabe 3.1 ¨uberpr¨ufen. Der durchschnittliche Gewinn sollte den Einsatz nicht ¨uberschreiten!

----

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

Eclipsekurs 2006/Tag 1

2006-05-04T08:05:27Z

Robert L: /* Aufgabe1 (entspannt) : */

== Aufgaben ==
#Starte die Eclipse-Umgebung mit dem Kommando '''/home/pub/lib/eclipse/eclipse'''
#Projekt anlegen
#*Erstelle ein Java-Projekt "eclipseTutorial" mit getrennten Ordnern für den Quellcode (''src'') und kompilierte class-Dateien (''bin'').
#*Lege in diesem Projekt eine neue Klasse "Spielwiese" an, die eine ''main''-Methode enthält.
#*Erweitere die Klasse zu einem "Hello World"-Programm und führe dieses in Eclipse aus.
#:''Tipp:'' Mit syso[Strg+Leerzeichen] erzeugt die Eclipse-Autocompletion ein System.out.println();
#*Verändere das Programm so, dass es einen beim Start übergebenden Parameter auf dem Bildschirm ausgibt.
#:''Tipp 1:'' Die Funktion main bekommt ihre Parameter als Array von Strings. Der Name des ersten übergebenen Parameters ist also args[0] .
#:''Tipp 2:'' Die Parameter des Programms kannst du in der Run-Configuration einstellen.
#*Baue Fehler in dein Programm ein (Semikolon löschen, Klammer löschen, Tippfehler) und sieh dir an, welche Korrekturvorschläge Eclipse anbietet. Spiele mit diesem Feature ein wenig herum. Du kannst Änderungen [Strg+Z] (Undo) jederzeit rückgängig machen.
#: ''Tipp:'' Beachte die "Problems"-Ansicht, sowie die Markierungen links und rechts vom Editorfenster. Manchmal muss man Änderungen allerdings erst speichern, damit die Anzeigen aktualisiert werden.
#Lege eine neue Klasse "tinyObject" an, welche '''keine''' main Methode enthält.
#*"tinyObject" soll drei Klassenvariablen enthalten. Wenn ein Objekt dieser Art erzeugt wird, weden diese mit einem beliebigen Wert initialisiert.
#*Erweitere "tinyObject" um eine Methode "void printYouselfAndThis(String text)", die den übergebenen Text sowie den Inhalt der Klassenvariablen auf der Konsole ausgibt.
#*''Hinweis:'' Sieh dir an, was passiert, wenn du in dieser Funktion "this." schreibst und anschließend kurz wartest oder die Autocomplition mit [Str+Space] aktivierst.
#*Zum Testen dieser Methode kannst du in der Klasse "Spielwiese" ein "tinyObject" erzeugen und darauf die Methode aufrufen.
#*Lege eine Methode "void keepLooping()" an welche eine Endlosschleife mit einer Consolenausgabe (z.B. "still looping") enthält. Führe diese Methode aus und brich die Ausführung mit einem der roten Stopbuttons ab.
#*Sieh dir die "Outline" Ansicht an und probiere aus wie du mit ihr in deinen Klassen Navigieren kannst.
#*Kommentiere deinen beiden Funktionen mit Javadoc.
#:''Tipp:'' /**[Enter] in der Zeile vor einer Methode oder Klasse legt automatisch einen Javadoc-Rumpf mit allen benutzten Parametern an.
#*Gehe mit dem Cursor in deinem Hauptprogramm auf eine stelle an der du eine der kommentierten Funktionen verwendest und sieh dir die Javadoc-Ansicht an.
#*halte die [Str] Taste gedrückt und gehe mit der Maus über den Funktionsaufruf. Klicke ihn an.

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

Wer schon einige Erfahrung mit Java hat, die Herrausforderung sucht oder die erste Aufgabe im Javakurs vor einigen Wochen schon bearbeitet hat kann übrigens getrost zur Zweiten springen.

Viel Spaß!

==Aufgabe1 (entspannt)==

Für alle die sie noch nicht kennen, die [[Javakurs2006/Rennschnecke| Rennschnecken]].

==Aufgabe 2 (schon kniffeliger): Cäsar-Chiffre ==

=== Cäsar ===

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

Macht dir auch Geanken darüber wie du die einzelnden Teile frühzeitig testen kannst.

#Erstelle ein Programm das einen Text aus einer Datei einliest, mit einem Passwort durch eine [http://de.wikipedia.org/wiki/Caesar-Chiffre#Sicherheit Cäsar-Chiffre] verschlüsselt und in einer neuen Datei (z.B. mit anderer Änderung) speichert.
#* Für mehr Komfort, aber nicht notwendig: Sowohl der Dateiname als auch das Passwort sollen über die Console eingegeben werden können.
#Erweitere dein Programm so, dass es einen mit der selben Chiffre verschlüsselten Text bei gegebendem Passwort entschlüsseln kann und in einer seperaten Datei speichert.
#Erweitere dein Programm so, dass es in der Lage ist einen beliebigen mit einer [http://de.wikipedia.org/wiki/Caesar-Chiffre#Sicherheit Cäsar-Chiffre] verschlüsselten Text mit Hilfe von [http://de.wikipedia.org/wiki/H%C3%A4ufigkeitsanalyse Häufigkeitsanalyse] ohne das Passwort zu kennen zu entschlüsseln. 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.

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

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

==Aufgabe: Glücksspiel (wird vielleicht weggelassen)==

Bei diesem Spiel gibt es 37 Felder, auf die der Spieler 200 Euro (in Einheiten von 1 Euro) verteilt. Danach wird eine Zufallszahl n ermittelt und an den Spieler wird der Gewinn ausgezahlt. Die Gewinnsumme errechnet sich wie folgt:

Summe( von i=0, bis 36,(board[i]*(6 − | i − n |)))

wobei board[i] den Wert der Belegung des Feldes i darstellt.
Allerdings sollen nur positive Summanden in die Summe eingehen.

===Berechnung der Gewinnsumme===
Vervollständige die ''play''-Funktion, welche bei der Eingabe
eines ''boards'' die Gewinnsumme errechnet. Die Funktion soll also die Aufgabe eines Spielleiters
bei einem Roulettespiel einnehmen.

''Tipp:'' Es wird sinnvoll sein, eine Methoden '''static int abs(int x)''' und eine Methode
'''static int max(int x, int y)''' zu implementieren. '''abs()''' liefert dabei den Betrag
der übergebenen Zahl zurück, während '''max()''' den größeren der beiden übergebenen
Werte zurückliefert.

===Ideale Boardbelegungen===
Erstelle ein paar Board-Belegungen und versuche Deinen Gewinn
zu maximieren. Hierbei ist es n¨utzlich, die Gewinnfunktion zu verstehen. Mache Dir also klar
unter welchen Umst¨anden man wieviel gewinnt.

*Gibt es Zahlen die g¨unstiger sind als andere?
*Lohnt es sich auf einzelne Felder besonders viel zu setzen?
*Ist es besser den Einsatz gleichm¨aßig zu verteilen?

Versuche eine m¨oglichst ideale Board-Belegung zu finden, indem du viele (z.B. 100 000) Spiele
mit Deiner festen Belegung simulierst. Falls Du magst, kannst Du auch andere Gewinnfunktionen
ausprobieren. z.B. ∗36 bei einem Volltreffer und ∗6 falls eines der acht benachbarten Felder
getroffen wurde. Die Praktikabilit¨at einer neuen Gewinnfunktion kannst Du mit der L¨osung aus
Aufgabe 3.1 ¨uberpr¨ufen. Der durchschnittliche Gewinn sollte den Einsatz nicht ¨uberschreiten!

----

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

Eclipsekurs 2006/Tag 1

2006-05-04T08:04:49Z

Robert L: /* Aufgabe: Cäsar-Chiffre */

== Aufgaben ==
#Starte die Eclipse-Umgebung mit dem Kommando '''/home/pub/lib/eclipse/eclipse'''
#Projekt anlegen
#*Erstelle ein Java-Projekt "eclipseTutorial" mit getrennten Ordnern für den Quellcode (''src'') und kompilierte class-Dateien (''bin'').
#*Lege in diesem Projekt eine neue Klasse "Spielwiese" an, die eine ''main''-Methode enthält.
#*Erweitere die Klasse zu einem "Hello World"-Programm und führe dieses in Eclipse aus.
#:''Tipp:'' Mit syso[Strg+Leerzeichen] erzeugt die Eclipse-Autocompletion ein System.out.println();
#*Verändere das Programm so, dass es einen beim Start übergebenden Parameter auf dem Bildschirm ausgibt.
#:''Tipp 1:'' Die Funktion main bekommt ihre Parameter als Array von Strings. Der Name des ersten übergebenen Parameters ist also args[0] .
#:''Tipp 2:'' Die Parameter des Programms kannst du in der Run-Configuration einstellen.
#*Baue Fehler in dein Programm ein (Semikolon löschen, Klammer löschen, Tippfehler) und sieh dir an, welche Korrekturvorschläge Eclipse anbietet. Spiele mit diesem Feature ein wenig herum. Du kannst Änderungen [Strg+Z] (Undo) jederzeit rückgängig machen.
#: ''Tipp:'' Beachte die "Problems"-Ansicht, sowie die Markierungen links und rechts vom Editorfenster. Manchmal muss man Änderungen allerdings erst speichern, damit die Anzeigen aktualisiert werden.
#Lege eine neue Klasse "tinyObject" an, welche '''keine''' main Methode enthält.
#*"tinyObject" soll drei Klassenvariablen enthalten. Wenn ein Objekt dieser Art erzeugt wird, weden diese mit einem beliebigen Wert initialisiert.
#*Erweitere "tinyObject" um eine Methode "void printYouselfAndThis(String text)", die den übergebenen Text sowie den Inhalt der Klassenvariablen auf der Konsole ausgibt.
#*''Hinweis:'' Sieh dir an, was passiert, wenn du in dieser Funktion "this." schreibst und anschließend kurz wartest oder die Autocomplition mit [Str+Space] aktivierst.
#*Zum Testen dieser Methode kannst du in der Klasse "Spielwiese" ein "tinyObject" erzeugen und darauf die Methode aufrufen.
#*Lege eine Methode "void keepLooping()" an welche eine Endlosschleife mit einer Consolenausgabe (z.B. "still looping") enthält. Führe diese Methode aus und brich die Ausführung mit einem der roten Stopbuttons ab.
#*Sieh dir die "Outline" Ansicht an und probiere aus wie du mit ihr in deinen Klassen Navigieren kannst.
#*Kommentiere deinen beiden Funktionen mit Javadoc.
#:''Tipp:'' /**[Enter] in der Zeile vor einer Methode oder Klasse legt automatisch einen Javadoc-Rumpf mit allen benutzten Parametern an.
#*Gehe mit dem Cursor in deinem Hauptprogramm auf eine stelle an der du eine der kommentierten Funktionen verwendest und sieh dir die Javadoc-Ansicht an.
#*halte die [Str] Taste gedrückt und gehe mit der Maus über den Funktionsaufruf. Klicke ihn an.

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

Wer schon einige Erfahrung mit Java hat, die Herrausforderung sucht oder die erste Aufgabe im Javakurs vor einigen Wochen schon bearbeitet hat kann übrigens getrost zur Zweiten springen.

Viel Spaß!

==Aufgabe1 (entspannt) :==
Für alle die sie noch nicht kennen, die [[Javakurs2006/Rennschnecke| Rennschnecken]].

==Aufgabe 2 (schon kniffeliger): Cäsar-Chiffre ==

=== Cäsar ===

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

Macht dir auch Geanken darüber wie du die einzelnden Teile frühzeitig testen kannst.

#Erstelle ein Programm das einen Text aus einer Datei einliest, mit einem Passwort durch eine [http://de.wikipedia.org/wiki/Caesar-Chiffre#Sicherheit Cäsar-Chiffre] verschlüsselt und in einer neuen Datei (z.B. mit anderer Änderung) speichert.
#* Für mehr Komfort, aber nicht notwendig: Sowohl der Dateiname als auch das Passwort sollen über die Console eingegeben werden können.
#Erweitere dein Programm so, dass es einen mit der selben Chiffre verschlüsselten Text bei gegebendem Passwort entschlüsseln kann und in einer seperaten Datei speichert.
#Erweitere dein Programm so, dass es in der Lage ist einen beliebigen mit einer [http://de.wikipedia.org/wiki/Caesar-Chiffre#Sicherheit Cäsar-Chiffre] verschlüsselten Text mit Hilfe von [http://de.wikipedia.org/wiki/H%C3%A4ufigkeitsanalyse Häufigkeitsanalyse] ohne das Passwort zu kennen zu entschlüsseln. 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.

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

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

==Aufgabe: Glücksspiel (wird vielleicht weggelassen)==

Bei diesem Spiel gibt es 37 Felder, auf die der Spieler 200 Euro (in Einheiten von 1 Euro) verteilt. Danach wird eine Zufallszahl n ermittelt und an den Spieler wird der Gewinn ausgezahlt. Die Gewinnsumme errechnet sich wie folgt:

Summe( von i=0, bis 36,(board[i]*(6 − | i − n |)))

wobei board[i] den Wert der Belegung des Feldes i darstellt.
Allerdings sollen nur positive Summanden in die Summe eingehen.

===Berechnung der Gewinnsumme===
Vervollständige die ''play''-Funktion, welche bei der Eingabe
eines ''boards'' die Gewinnsumme errechnet. Die Funktion soll also die Aufgabe eines Spielleiters
bei einem Roulettespiel einnehmen.

''Tipp:'' Es wird sinnvoll sein, eine Methoden '''static int abs(int x)''' und eine Methode
'''static int max(int x, int y)''' zu implementieren. '''abs()''' liefert dabei den Betrag
der übergebenen Zahl zurück, während '''max()''' den größeren der beiden übergebenen
Werte zurückliefert.

===Ideale Boardbelegungen===
Erstelle ein paar Board-Belegungen und versuche Deinen Gewinn
zu maximieren. Hierbei ist es n¨utzlich, die Gewinnfunktion zu verstehen. Mache Dir also klar
unter welchen Umst¨anden man wieviel gewinnt.

*Gibt es Zahlen die g¨unstiger sind als andere?
*Lohnt es sich auf einzelne Felder besonders viel zu setzen?
*Ist es besser den Einsatz gleichm¨aßig zu verteilen?

Versuche eine m¨oglichst ideale Board-Belegung zu finden, indem du viele (z.B. 100 000) Spiele
mit Deiner festen Belegung simulierst. Falls Du magst, kannst Du auch andere Gewinnfunktionen
ausprobieren. z.B. ∗36 bei einem Volltreffer und ∗6 falls eines der acht benachbarten Felder
getroffen wurde. Die Praktikabilit¨at einer neuen Gewinnfunktion kannst Du mit der L¨osung aus
Aufgabe 3.1 ¨uberpr¨ufen. Der durchschnittliche Gewinn sollte den Einsatz nicht ¨uberschreiten!

----

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

Eclipsekurs 2006/Tag 1

2006-05-04T08:04:13Z

Robert L: /* Aufgabe: Rennschnecken (wenn noch nicht gemacht) */

== Aufgaben ==
#Starte die Eclipse-Umgebung mit dem Kommando '''/home/pub/lib/eclipse/eclipse'''
#Projekt anlegen
#*Erstelle ein Java-Projekt "eclipseTutorial" mit getrennten Ordnern für den Quellcode (''src'') und kompilierte class-Dateien (''bin'').
#*Lege in diesem Projekt eine neue Klasse "Spielwiese" an, die eine ''main''-Methode enthält.
#*Erweitere die Klasse zu einem "Hello World"-Programm und führe dieses in Eclipse aus.
#:''Tipp:'' Mit syso[Strg+Leerzeichen] erzeugt die Eclipse-Autocompletion ein System.out.println();
#*Verändere das Programm so, dass es einen beim Start übergebenden Parameter auf dem Bildschirm ausgibt.
#:''Tipp 1:'' Die Funktion main bekommt ihre Parameter als Array von Strings. Der Name des ersten übergebenen Parameters ist also args[0] .
#:''Tipp 2:'' Die Parameter des Programms kannst du in der Run-Configuration einstellen.
#*Baue Fehler in dein Programm ein (Semikolon löschen, Klammer löschen, Tippfehler) und sieh dir an, welche Korrekturvorschläge Eclipse anbietet. Spiele mit diesem Feature ein wenig herum. Du kannst Änderungen [Strg+Z] (Undo) jederzeit rückgängig machen.
#: ''Tipp:'' Beachte die "Problems"-Ansicht, sowie die Markierungen links und rechts vom Editorfenster. Manchmal muss man Änderungen allerdings erst speichern, damit die Anzeigen aktualisiert werden.
#Lege eine neue Klasse "tinyObject" an, welche '''keine''' main Methode enthält.
#*"tinyObject" soll drei Klassenvariablen enthalten. Wenn ein Objekt dieser Art erzeugt wird, weden diese mit einem beliebigen Wert initialisiert.
#*Erweitere "tinyObject" um eine Methode "void printYouselfAndThis(String text)", die den übergebenen Text sowie den Inhalt der Klassenvariablen auf der Konsole ausgibt.
#*''Hinweis:'' Sieh dir an, was passiert, wenn du in dieser Funktion "this." schreibst und anschließend kurz wartest oder die Autocomplition mit [Str+Space] aktivierst.
#*Zum Testen dieser Methode kannst du in der Klasse "Spielwiese" ein "tinyObject" erzeugen und darauf die Methode aufrufen.
#*Lege eine Methode "void keepLooping()" an welche eine Endlosschleife mit einer Consolenausgabe (z.B. "still looping") enthält. Führe diese Methode aus und brich die Ausführung mit einem der roten Stopbuttons ab.
#*Sieh dir die "Outline" Ansicht an und probiere aus wie du mit ihr in deinen Klassen Navigieren kannst.
#*Kommentiere deinen beiden Funktionen mit Javadoc.
#:''Tipp:'' /**[Enter] in der Zeile vor einer Methode oder Klasse legt automatisch einen Javadoc-Rumpf mit allen benutzten Parametern an.
#*Gehe mit dem Cursor in deinem Hauptprogramm auf eine stelle an der du eine der kommentierten Funktionen verwendest und sieh dir die Javadoc-Ansicht an.
#*halte die [Str] Taste gedrückt und gehe mit der Maus über den Funktionsaufruf. Klicke ihn an.

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

Wer schon einige Erfahrung mit Java hat, die Herrausforderung sucht oder die erste Aufgabe im Javakurs vor einigen Wochen schon bearbeitet hat kann übrigens getrost zur Zweiten springen.

Viel Spaß!

==Aufgabe1 (entspannt) :==
Für alle die sie noch nicht kennen, die [[Javakurs2006/Rennschnecke| Rennschnecken]].

==Aufgabe: Cäsar-Chiffre==

=== Cäsar ===

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

Macht dir auch Geanken darüber wie du die einzelnden Teile frühzeitig testen kannst.

#Erstelle ein Programm das einen Text aus einer Datei einliest, mit einem Passwort durch eine [http://de.wikipedia.org/wiki/Caesar-Chiffre#Sicherheit Cäsar-Chiffre] verschlüsselt und in einer neuen Datei (z.B. mit anderer Änderung) speichert.
#* Für mehr Komfort, aber nicht notwendig: Sowohl der Dateiname als auch das Passwort sollen über die Console eingegeben werden können.
#Erweitere dein Programm so, dass es einen mit der selben Chiffre verschlüsselten Text bei gegebendem Passwort entschlüsseln kann und in einer seperaten Datei speichert.
#Erweitere dein Programm so, dass es in der Lage ist einen beliebigen mit einer [http://de.wikipedia.org/wiki/Caesar-Chiffre#Sicherheit Cäsar-Chiffre] verschlüsselten Text mit Hilfe von [http://de.wikipedia.org/wiki/H%C3%A4ufigkeitsanalyse Häufigkeitsanalyse] ohne das Passwort zu kennen zu entschlüsseln. 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.

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

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

==Aufgabe: Glücksspiel (wird vielleicht weggelassen)==

Bei diesem Spiel gibt es 37 Felder, auf die der Spieler 200 Euro (in Einheiten von 1 Euro) verteilt. Danach wird eine Zufallszahl n ermittelt und an den Spieler wird der Gewinn ausgezahlt. Die Gewinnsumme errechnet sich wie folgt:

Summe( von i=0, bis 36,(board[i]*(6 − | i − n |)))

wobei board[i] den Wert der Belegung des Feldes i darstellt.
Allerdings sollen nur positive Summanden in die Summe eingehen.

===Berechnung der Gewinnsumme===
Vervollständige die ''play''-Funktion, welche bei der Eingabe
eines ''boards'' die Gewinnsumme errechnet. Die Funktion soll also die Aufgabe eines Spielleiters
bei einem Roulettespiel einnehmen.

''Tipp:'' Es wird sinnvoll sein, eine Methoden '''static int abs(int x)''' und eine Methode
'''static int max(int x, int y)''' zu implementieren. '''abs()''' liefert dabei den Betrag
der übergebenen Zahl zurück, während '''max()''' den größeren der beiden übergebenen
Werte zurückliefert.

===Ideale Boardbelegungen===
Erstelle ein paar Board-Belegungen und versuche Deinen Gewinn
zu maximieren. Hierbei ist es n¨utzlich, die Gewinnfunktion zu verstehen. Mache Dir also klar
unter welchen Umst¨anden man wieviel gewinnt.

*Gibt es Zahlen die g¨unstiger sind als andere?
*Lohnt es sich auf einzelne Felder besonders viel zu setzen?
*Ist es besser den Einsatz gleichm¨aßig zu verteilen?

Versuche eine m¨oglichst ideale Board-Belegung zu finden, indem du viele (z.B. 100 000) Spiele
mit Deiner festen Belegung simulierst. Falls Du magst, kannst Du auch andere Gewinnfunktionen
ausprobieren. z.B. ∗36 bei einem Volltreffer und ∗6 falls eines der acht benachbarten Felder
getroffen wurde. Die Praktikabilit¨at einer neuen Gewinnfunktion kannst Du mit der L¨osung aus
Aufgabe 3.1 ¨uberpr¨ufen. Der durchschnittliche Gewinn sollte den Einsatz nicht ¨uberschreiten!

----

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

Eclipsekurs 2006/Tag 1

2006-05-04T08:01:22Z

Robert L: /* Aufgaben */ überleitung übungsaufgaben

== Aufgaben ==
#Starte die Eclipse-Umgebung mit dem Kommando '''/home/pub/lib/eclipse/eclipse'''
#Projekt anlegen
#*Erstelle ein Java-Projekt "eclipseTutorial" mit getrennten Ordnern für den Quellcode (''src'') und kompilierte class-Dateien (''bin'').
#*Lege in diesem Projekt eine neue Klasse "Spielwiese" an, die eine ''main''-Methode enthält.
#*Erweitere die Klasse zu einem "Hello World"-Programm und führe dieses in Eclipse aus.
#:''Tipp:'' Mit syso[Strg+Leerzeichen] erzeugt die Eclipse-Autocompletion ein System.out.println();
#*Verändere das Programm so, dass es einen beim Start übergebenden Parameter auf dem Bildschirm ausgibt.
#:''Tipp 1:'' Die Funktion main bekommt ihre Parameter als Array von Strings. Der Name des ersten übergebenen Parameters ist also args[0] .
#:''Tipp 2:'' Die Parameter des Programms kannst du in der Run-Configuration einstellen.
#*Baue Fehler in dein Programm ein (Semikolon löschen, Klammer löschen, Tippfehler) und sieh dir an, welche Korrekturvorschläge Eclipse anbietet. Spiele mit diesem Feature ein wenig herum. Du kannst Änderungen [Strg+Z] (Undo) jederzeit rückgängig machen.
#: ''Tipp:'' Beachte die "Problems"-Ansicht, sowie die Markierungen links und rechts vom Editorfenster. Manchmal muss man Änderungen allerdings erst speichern, damit die Anzeigen aktualisiert werden.
#Lege eine neue Klasse "tinyObject" an, welche '''keine''' main Methode enthält.
#*"tinyObject" soll drei Klassenvariablen enthalten. Wenn ein Objekt dieser Art erzeugt wird, weden diese mit einem beliebigen Wert initialisiert.
#*Erweitere "tinyObject" um eine Methode "void printYouselfAndThis(String text)", die den übergebenen Text sowie den Inhalt der Klassenvariablen auf der Konsole ausgibt.
#*''Hinweis:'' Sieh dir an, was passiert, wenn du in dieser Funktion "this." schreibst und anschließend kurz wartest oder die Autocomplition mit [Str+Space] aktivierst.
#*Zum Testen dieser Methode kannst du in der Klasse "Spielwiese" ein "tinyObject" erzeugen und darauf die Methode aufrufen.
#*Lege eine Methode "void keepLooping()" an welche eine Endlosschleife mit einer Consolenausgabe (z.B. "still looping") enthält. Führe diese Methode aus und brich die Ausführung mit einem der roten Stopbuttons ab.
#*Sieh dir die "Outline" Ansicht an und probiere aus wie du mit ihr in deinen Klassen Navigieren kannst.
#*Kommentiere deinen beiden Funktionen mit Javadoc.
#:''Tipp:'' /**[Enter] in der Zeile vor einer Methode oder Klasse legt automatisch einen Javadoc-Rumpf mit allen benutzten Parametern an.
#*Gehe mit dem Cursor in deinem Hauptprogramm auf eine stelle an der du eine der kommentierten Funktionen verwendest und sieh dir die Javadoc-Ansicht an.
#*halte die [Str] Taste gedrückt und gehe mit der Maus über den Funktionsaufruf. Klicke ihn an.

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

Wer schon einige Erfahrung mit Java hat, die Herrausforderung sucht oder die erste Aufgabe im Javakurs vor einigen Wochen schon bearbeitet hat kann übrigens getrost zur Zweiten springen.

Viel Spaß!

==Aufgabe: Rennschnecken (wenn noch nicht gemacht)==
Zur Wiederholung der Objektorientierten Programmierung gibt es hier eine [[Javakurs2006/Rennschnecke| Rennschneckenaufgabe]].

==Aufgabe: Cäsar-Chiffre==

=== Cäsar ===

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

Macht dir auch Geanken darüber wie du die einzelnden Teile frühzeitig testen kannst.

#Erstelle ein Programm das einen Text aus einer Datei einliest, mit einem Passwort durch eine [http://de.wikipedia.org/wiki/Caesar-Chiffre#Sicherheit Cäsar-Chiffre] verschlüsselt und in einer neuen Datei (z.B. mit anderer Änderung) speichert.
#* Für mehr Komfort, aber nicht notwendig: Sowohl der Dateiname als auch das Passwort sollen über die Console eingegeben werden können.
#Erweitere dein Programm so, dass es einen mit der selben Chiffre verschlüsselten Text bei gegebendem Passwort entschlüsseln kann und in einer seperaten Datei speichert.
#Erweitere dein Programm so, dass es in der Lage ist einen beliebigen mit einer [http://de.wikipedia.org/wiki/Caesar-Chiffre#Sicherheit Cäsar-Chiffre] verschlüsselten Text mit Hilfe von [http://de.wikipedia.org/wiki/H%C3%A4ufigkeitsanalyse Häufigkeitsanalyse] ohne das Passwort zu kennen zu entschlüsseln. 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.

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

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

==Aufgabe: Glücksspiel (wird vielleicht weggelassen)==

Bei diesem Spiel gibt es 37 Felder, auf die der Spieler 200 Euro (in Einheiten von 1 Euro) verteilt. Danach wird eine Zufallszahl n ermittelt und an den Spieler wird der Gewinn ausgezahlt. Die Gewinnsumme errechnet sich wie folgt:

Summe( von i=0, bis 36,(board[i]*(6 − | i − n |)))

wobei board[i] den Wert der Belegung des Feldes i darstellt.
Allerdings sollen nur positive Summanden in die Summe eingehen.

===Berechnung der Gewinnsumme===
Vervollständige die ''play''-Funktion, welche bei der Eingabe
eines ''boards'' die Gewinnsumme errechnet. Die Funktion soll also die Aufgabe eines Spielleiters
bei einem Roulettespiel einnehmen.

''Tipp:'' Es wird sinnvoll sein, eine Methoden '''static int abs(int x)''' und eine Methode
'''static int max(int x, int y)''' zu implementieren. '''abs()''' liefert dabei den Betrag
der übergebenen Zahl zurück, während '''max()''' den größeren der beiden übergebenen
Werte zurückliefert.

===Ideale Boardbelegungen===
Erstelle ein paar Board-Belegungen und versuche Deinen Gewinn
zu maximieren. Hierbei ist es n¨utzlich, die Gewinnfunktion zu verstehen. Mache Dir also klar
unter welchen Umst¨anden man wieviel gewinnt.

*Gibt es Zahlen die g¨unstiger sind als andere?
*Lohnt es sich auf einzelne Felder besonders viel zu setzen?
*Ist es besser den Einsatz gleichm¨aßig zu verteilen?

Versuche eine m¨oglichst ideale Board-Belegung zu finden, indem du viele (z.B. 100 000) Spiele
mit Deiner festen Belegung simulierst. Falls Du magst, kannst Du auch andere Gewinnfunktionen
ausprobieren. z.B. ∗36 bei einem Volltreffer und ∗6 falls eines der acht benachbarten Felder
getroffen wurde. Die Praktikabilit¨at einer neuen Gewinnfunktion kannst Du mit der L¨osung aus
Aufgabe 3.1 ¨uberpr¨ufen. Der durchschnittliche Gewinn sollte den Einsatz nicht ¨uberschreiten!

----

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

Eclipsekurs 2006/Tag 1

2006-05-03T14:01:47Z

Robert L: /* Aufgaben */

Eclipsekurs 2006/Tag 1

2006-05-03T13:49:44Z

Robert L: /* Aufgaben */

Eclipsekurs 2006

2006-04-28T10:29:17Z

Robert L: /* Tag 1 */ mehr Aufgaben

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

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

== Zeit und Ort ==

* Zeit
: Samstag, den 06.05.2006 von 10.00-14.00 Uhr ?
:: 10.00-11.00 Uhr Vorlesung
:: 11.00-12.00 Uhr Übung
: Samstag, den 13.05.2006 von 10.00-14.00 Uhr ?
:: 10.00-11.00 Uhr Vorlesung
:: 11.00-12.00 Uhr Übung

* Ort
** Raum reservieren -> MA043
** Technik im AVZ (am Freitag vorher) besorgen
** Rechnerräume organisieren

== Themen ==
=== 1. Termin ===
* Programm starten
** Wo ist eclipse im Uninetz zu finden?
** Wie setze ich einen Link auf eclipse?
** PATH setzen?
** applrc aktualisieren?
** Workspace wählen
** Was ist der Workspace?

* Projekt anlegen
** Was ist ein Projekt in eclipse?
** Wie erstellt man in eclipse Projekte?
** Was für Projekte kann man mit eclipse erstellen (gibt es verschiedene Projekte)?
** Was wird bei einem Projekt angelegt?
** Wie erstelle ich Klassen im Projekt?
** EXKURS: Was sind Packages in Java (eclipse)?

* Java-Program starten

* Editor
** Fensteranordnung erklären
** Was erscheint in den verschiedenen Fenstern?
** Was ist der ''Package Explorer'', ''Hierarchy'' und ''Navigator''?
** Wie ändert man die Fensteranordnung?
** Wie lasse ich zusätzliche Subfenster anzeigen?
** Was für Menüpunkte gibt es?
** Wie kann ich meine Klassen anschauen?
** Wie kann ich meine Klassen editieren?
** Wie sehe ich Fehler in meinem Sourcecode?
** Welche Möglichkeiten zur Fehlerbehebung gibt es?
*** Quickfixes
** Wie kann ich Java-Konstrukte einfach erstellen (Konstruktoren, Getter, Setter, if-Anweisung, for-Schleife, while-Schleife etc.)?
** Wie kann man Markierungen setzen (wie zum Beispiel TODO)?

=== 2. Termin ===
* Advanced Editor Features
** Refactoring: Wie kann ich Variablen-, Klassen- und Methoden-Namen in meinem kompletten Projekt ändern (umbenennen)?
* Importieren
** Wie kann man Vorgaben einbinden (Importieren)?
** Was kann man importieren?
** Wie binde ich Bytecode-Vorgaben ein?
** Wie kann ich Sourcecode einbinden?

* Exportieren
** Wie geht das Exportieren von Lösungen?
** Als was kann man expoertieren?
** Kann man einzelne Klassen exportieren?
** Kann man ausführbare Dateien exportieren?

* Debugger
** Was ist ein Debugger?
** Wie starte ich den Debugger?
** Wie kann ich ein Programm debuggen?
** Was sind Haltepunkte?
** Wie kann ich Haltepunkte setzen?
** Wie kann ich in meinem Programm navigieren (Schritt vorwärts, Schritt weiter ohne hineingehen)?
** Wie kann ich den Inhalt von Variablen sehen?
** Wie beende ich den Debugger?

* Plugins vorstellen (Möglichkeiten für Zuhause)

== Aufgaben ==
=== Tag 1 ===
#Eclipse einrichten
#*Link zu Eclipse im Uninetz
#*Info zu Link setzen
#*Info zu Path setzen
#*Info zu applrc
#*Als Workspace kannst du in deinem home Verzeichnis ein beliebiges Verzeichnis wählen.
#:
#Projekt anlegen
#*Erstelle ein Java-Projekt "eclipseTutorial" mit getrenntem source und Output Ordner.
#*Lege im src Ordner dieses Projektes ein Package "tag1" an.
#*Lege in diesem Package eine neue Klasse "Spielwiese" an die eine main Methode enthält.
#*Erweitere die Klasse zu einem simplen "Hello World" Programm und führe dieses in Eclipse aus.
#:''Tipp:'' mit sysout[str+space] erzeugt die Eclipse-Autocomplition ein System.out.println();
#*Verändere das Programm so, dass es einen beim Start übergebenden Parameter auf dem Bildschirm ausgibt.
#:''Tipp:'' Die Funktion main bekommt ihre Parameter als Array von Strings. Der Aufruf des ersten übergebenen Parameters könnte also so aussehen : ... args[0] ...
#*Baue Fehler in dein Programm ein (Semicolon löschen, Klammer löschen, Tippfehler) und sieh dir an welche Korrekturvorschläge Eclipse anbietet. Spiele mit diesem Feature ein wenig herrum. Du kannst Änderungen [Ctrl+Z] (Undo) jederzeit rückgängig machen.
#: ''Tipp:'' Sieh dir bei den Fehlern die "Problems" Ansicht an, sowie die Markierungen links und rechts vom Editorfenster. Manchmal muss man Änderungen allerdings erst speichern damit diese aktualisiert werden.
#*lege im Package Tag1 eine neue Klasse "tinyObject" an, welche '''keine''' main Methode enthält.
#*"tinyObject" soll drei Klassenvariablen enthalten die, wenn ein Objekt dieser Art erzeugt wird, mit einem beliebigen Wert innitialisiert werden.
#*Erweiter "tinyObject" um eine Methode "void printYouselfAndThis(String text)" die den übergebenen Text sowie den Inhalt der Klassenvariablen auf der Konsole ausgibt.
#*''Hinweis:'' Sieh dir an was passiert wenn du in dieser Funktion "this." schreibst und anschließend kurz wartest oder die Autocomplition mit [Str+Space] aktivierst.

=== Tag 2 ===

== Anmerkungen ==
noch keine

== Teilnehmer ==
100 geplante Teilnehmer

== Tutoren ==
# Martin Häcker
# Felix Schwarz
# Karl Wessel
# Thorsten Rimkus
# Ellen Michelsen
# Robert Lubkoll
# Marcel Grey

== TODOs ==
* Eclipse aktualisieren @Felix, @Karl
** Hemmungslos beim Javakurs bedienen
** Einfach, Einfach, Einfach: Java ist nicht im Zentrum der Aufgaben!
* Screenshots und Tutorials schreiben @Marcel @Martin
** [http://wiki.freitagsrunde.org/Eclipsekurs_2005#Anmerkungen Auf der alten Eclipsekurs Seite sind die alten Tutorials verlinkt]
* Teilnehmer aquirieren -> Sobald die Zahlen stehen
** Vorlesung Hallo sagen @Felix
** Plakate machen @Dorian @Ellen
** Plakate Drucken & Aufhängen: @Felix @Ellen @Marcel
* Vorträge @Felix @Martin
* Aufgaben erzeugen @Robert Lubkoll
** Tag 1: @Marcel @Karl @Robert Buchholz (bis Freitag 28.4.)
** Tag 2: @Karl @Hannes @Nadja (bis Freitag 5.5.)

Eclipsekurs 2006

2006-04-28T10:02:40Z

Robert L: /* Tag 1 */

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

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

== Zeit und Ort ==

* Zeit
: Samstag, den 06.05.2006 von 10.00-14.00 Uhr ?
:: 10.00-11.00 Uhr Vorlesung
:: 11.00-12.00 Uhr Übung
: Samstag, den 13.05.2006 von 10.00-14.00 Uhr ?
:: 10.00-11.00 Uhr Vorlesung
:: 11.00-12.00 Uhr Übung

* Ort
** Raum reservieren -> MA043
** Technik im AVZ (am Freitag vorher) besorgen
** Rechnerräume organisieren

== Themen ==
=== 1. Termin ===
* Programm starten
** Wo ist eclipse im Uninetz zu finden?
** Wie setze ich einen Link auf eclipse?
** PATH setzen?
** applrc aktualisieren?
** Workspace wählen
** Was ist der Workspace?

* Projekt anlegen
** Was ist ein Projekt in eclipse?
** Wie erstellt man in eclipse Projekte?
** Was für Projekte kann man mit eclipse erstellen (gibt es verschiedene Projekte)?
** Was wird bei einem Projekt angelegt?
** Wie erstelle ich Klassen im Projekt?
** EXKURS: Was sind Packages in Java (eclipse)?

* Java-Program starten

* Editor
** Fensteranordnung erklären
** Was erscheint in den verschiedenen Fenstern?
** Was ist der ''Package Explorer'', ''Hierarchy'' und ''Navigator''?
** Wie ändert man die Fensteranordnung?
** Wie lasse ich zusätzliche Subfenster anzeigen?
** Was für Menüpunkte gibt es?
** Wie kann ich meine Klassen anschauen?
** Wie kann ich meine Klassen editieren?
** Wie sehe ich Fehler in meinem Sourcecode?
** Welche Möglichkeiten zur Fehlerbehebung gibt es?
*** Quickfixes
** Wie kann ich Java-Konstrukte einfach erstellen (Konstruktoren, Getter, Setter, if-Anweisung, for-Schleife, while-Schleife etc.)?
** Wie kann man Markierungen setzen (wie zum Beispiel TODO)?

=== 2. Termin ===
* Advanced Editor Features
** Refactoring: Wie kann ich Variablen-, Klassen- und Methoden-Namen in meinem kompletten Projekt ändern (umbenennen)?
* Importieren
** Wie kann man Vorgaben einbinden (Importieren)?
** Was kann man importieren?
** Wie binde ich Bytecode-Vorgaben ein?
** Wie kann ich Sourcecode einbinden?

* Exportieren
** Wie geht das Exportieren von Lösungen?
** Als was kann man expoertieren?
** Kann man einzelne Klassen exportieren?
** Kann man ausführbare Dateien exportieren?

* Debugger
** Was ist ein Debugger?
** Wie starte ich den Debugger?
** Wie kann ich ein Programm debuggen?
** Was sind Haltepunkte?
** Wie kann ich Haltepunkte setzen?
** Wie kann ich in meinem Programm navigieren (Schritt vorwärts, Schritt weiter ohne hineingehen)?
** Wie kann ich den Inhalt von Variablen sehen?
** Wie beende ich den Debugger?

* Plugins vorstellen (Möglichkeiten für Zuhause)

== Aufgaben ==
=== Tag 1 ===
#Eclipse einrichten
#*Link zu Eclipse im Uninetz
#*Info zu Link setzen
#*Info zu Path setzen
#*Info zu applrc
#*Als Workspace kannst du in deinem home Verzeichnis ein beliebigers Verzeichnis wählen.
#:
#Projekt anlegen
#*Erstelle ein Java-Projekt "eclipseTutorial" mit getrenntem source und Output Ordner.
#*Lege im src Ordner dieses Projektes ein Package "tag1" an.
#*Lege in diesem Package eine neue Klasse "Spielwiese" an die eine Main-Funktion enthält.
#*Erweitere die Klasse zu einem simplen "Hello World" Programm und führe dieses in Eclipse aus.
#:''Tipp:'' mit sysout[str+space] erzeugt die Eclipse autocomplition ein System.out.println();
#*Verändere das Programm so, dass es einen beim Strat übergebenden Parameter auf dem Bildschirm ausgibt.
#:''Tipp:'' Die Funktion main bekommt ihre Parameter als Array von Strings. Der Aufruf des ersten übergebenden Parameters könnte also so aussehen : ... args[0] ...

=== Tag 2 ===

== Anmerkungen ==
noch keine

== Teilnehmer ==
100 geplante Teilnehmer

== Tutoren ==
# Martin Häcker
# Felix Schwarz
# Karl Wessel
# Thorsten Rimkus
# Ellen Michelsen
# Robert Lubkoll
# Marcel Grey

== TODOs ==
* Eclipse aktualisieren @Felix, @Karl
** Hemmungslos beim Javakurs bedienen
** Einfach, Einfach, Einfach: Java ist nicht im Zentrum der Aufgaben!
* Screenshots und Tutorials schreiben @Marcel @Martin
** [http://wiki.freitagsrunde.org/Eclipsekurs_2005#Anmerkungen Auf der alten Eclipsekurs Seite sind die alten Tutorials verlinkt]
* Teilnehmer aquirieren -> Sobald die Zahlen stehen
** Vorlesung Hallo sagen @Felix
** Plakate machen @Dorian @Ellen
** Plakate Drucken & Aufhängen: @Felix @Ellen @Marcel
* Vorträge @Felix @Martin
* Aufgaben erzeugen @Robert Lubkoll
** Tag 1: @Marcel @Karl @Robert Buchholz (bis Freitag 28.4.)
** Tag 2: @Karl @Hannes @Nadja (bis Freitag 5.5.)

Javakurs/Übungsaufgaben/Rennschnecke

2006-04-06T08:29:01Z

Robert L:

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

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

== Rennen ==

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

== Wettbüro ==

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

== Zusatz ==

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

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

== Zusatz Vererbung ==

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

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

Javakurs2006/Tag 4/Vier Gewinnt

2006-04-06T08:08:30Z

Robert L:

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

Informationen zum Spiel Vier gewinnt findet ihr [http://de.wikipedia.org/wiki/Vier_gewinnt hier].

* Als erstes macht es Sinn sich ein Spielbrett anzulegen.
: Lege dazu eine Klasse <code>GameBoard</code> an. Diese könnte Methoden enthalten wie:
:* <code>placeWhiteStone(int column)</code>, einen weissen Stein in die <code>column</code>te Spalte ''wirft''.
:* <code>placeBlackStone(int column)</code>, einen schwarzen Stein in die <code>column</code>te Spalte ''wirft''.
* Dieses Spielbrett sollte jetzt auf dem Bildschirm in der Form:
<nowiki>
---------------
|0|0|0|0|0|0|0|
---------------
|0|0|0|0|0|0|0|
---------------
|0|0|0|0|0|0|0|
---------------
|0|0|0|0|0|0|0|
---------------
|0|0|0|0|0|0|0|
---------------
|0|0|2|1|0|0|0|
---------------
</nowiki>

: angezeigt werden. Wobei 0 für ein leeres Feld, 1 für ein weisses Feld und 2 für ein schwarzes Feld steht. Nützlich wäre hier in der Klasse <code>GameBoard</code> eine Methode <code>toString()</code> zu implementieren.
* Benutze nun die Methode <code>String promptUserForString(String question)</code> vom API-Übungsblatt um den vom Spieler gewünschten Zug ''einzulesen''.
* Überlege dir, wo und wie du feststellen willst ob ein Spieler gewonnen hat und wenn ja wer.

=== Zusatzaufgabe ===
Verschönere die Ausgabe:
* so dass man nichts sieht, wenn ein Feld leer ist.
* so dass 1 und 2 durch "+" und "x" ersetzt wird
* überlege wie man diese Ausgabe ohne Fallunterscheidung machen kann (Tip: Array)

Erweitere das Spiel um einen Computer-Spieler, der:
* Einen Zufälligen Zug macht
* Einen Gewinn-Zug macht, wenn er kann
* Einen Zug vermeidet, der zum Gewinn des Gegners führt, wenn er kann

Hinweis: Um eine KI zu implementieren ist es sinnvoll entweder:
* einen Zug zurücknehmen zu können
* eine Kopie eines Spielfeldes machen zu können
Damit ist es für die KI einfach einen Zug auszuprobieren.

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

Javakurs/Übungsaufgaben/Cäsar-Chiffre

2006-04-06T08:08:03Z

Robert L:

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

== Cäsar ==

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

Macht dir auch Geanken darüber wie du die einzelnden Teile frühzeitig testen kannst.

#Erstelle ein Programm das einen Text aus einer Datei einliest, mit einem Passwort durch eine [http://de.wikipedia.org/wiki/Caesar-Chiffre#Sicherheit| Cäsar-Chiffre] verschlüsselt und in einer neuen Datei (z.B. mit anderer Änderung) speichert.
#* Für mehr Komfort, aber nicht notwendig: Sowohl der Dateiname als auch das Passwort sollen über die Console eingegeben werden können.
#Erweitere dein Programm so, dass es einen mit der selben Chiffre verschlüsselten Text bei gegebendem Passwort entschlüsseln kann und in einer seperaten Datei speichert.
#Erweitere dein Programm so, dass es in der Lage ist einen beliebigen mit einer [http://de.wikipedia.org/wiki/Caesar-Chiffre#Sicherheit| Cäsar-Chiffre] verschlüsselten Text mit Hilfe von [http://de.wikipedia.org/wiki/H%C3%A4ufigkeitsanalyse| Häufigkeitsanalyse] ohne das Passwort zu kennen zu entschlüsseln. 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.

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

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

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

Javakurs/Übungsaufgaben/Rennschnecke

2006-04-06T08:07:36Z

Robert L: Navilink

Javakurs2006/Tag 4

2006-04-06T08:06:08Z

Robert L: Navigationslink

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

Auch heute gibt es keine Vorlesung, weil dafür der Wissensstand der Teilnehmer zu unterschiedlich ist. Folgende Aufgabenvorschläge haben wir:

# [[Javakurs2006/Uebungsaufgaben| Übungsaufgaben für bestimmte Themengebiete]]
# Studentendatenbank: [http://docs.freitagsrunde.org/javakurs/blatt03.pdf Blatt 3 bis Aufgabe 1.5]
# [[Javakurs2006/Tag_2/Vorlesung_3/Aufgaben| IOUtility (Blatt 5)]]

= Fortgeschrittene Aufgaben =
# [[Javakurs2006/Rennschnecke| Schneckenrennen]]
# [[{{PAGENAME}}/Vier Gewinnt| Vier gewinnt]]
# [http://docs.freitagsrunde.org/javakurs/AufgabenTDDv2.pdf Fortgeschrittene Aufgaben] für alle die im Stoff schon sehr sattelfest sind und sich für Test-Driven-Development interessieren. Dafür braucht ihr noch die [http://docs.freitagsrunde.org/javakurs/junit.jar Datei junit.jar].
# [[Javakurs2006/Cäsar-Chiffre| Cäsar-Chiffre]]

= Allgemeine Links =
* [[Javakurs2006/Probleme| Lösungen für Problem mit Java]]
* Eine [[Javakurs2006/Java_Kurzreferenz| Kurzreferenz für Java ]] ist seit vorgestern Online
* Folien und Aufschriebe zu den Vorlesungen
** Variablen, if: [http://www.the-gate.de/uni/javakurs2006/Javakurs_LE1.pdf Folien], [[Robert_Lubkoll/Java_Kurs/Tag1/Teil1/Zusammenfassung| Text]]
** Schleifen, Methoden, Arrays: [http://user.cs.tu-berlin.de/~buchholz/javakurs2006-le2.pdf Folien], [[Javakurs2006/Tag_1/Vorlesung_2| Text]]
** Objekte: [http://docs.freitagsrunde.org/javakurs/Modularisierung%20und%20Objekte.pdf Folien], [[Javakurs2006/Tag_2/Objekte_Kurz| Text (Kurzfassung)]], [[Martin_Häcker/Java_Kurs/Tag_2/Handout| Text (detailiert)]]
** API: [http://docs.freitagsrunde.org/javakurs/vortrag%20le4_23.pdf Folien], [[Javakurs2006/Tag 2/Vorlesung 2| Text]]

Um 15:00 gibt es eine kleine Abschlussveranstaltung im '''FR 5516'''.

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

Javakurs/Übungsaufgaben/Cäsar-Chiffre

2006-04-06T07:52:26Z

Robert L: /* Cäsar */

== Cäsar ==

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

Macht dir auch Geanken darüber wie du die einzelnden Teile frühzeitig testen kannst.

#Erstelle ein Programm das einen Text aus einer Datei einliest, mit einem Passwort durch eine [http://de.wikipedia.org/wiki/Caesar-Chiffre#Sicherheit| Cäsar-Chiffre] verschlüsselt und in einer neuen Datei (z.B. mit anderer Änderung) speichert.
#* Für mehr Komfort, aber nicht notwendig: Sowohl der Dateiname als auch das Passwort sollen über die Console eingegeben werden können.
#Erweitere dein Programm so, dass es einen mit der selben Chiffre verschlüsselten Text bei gegebendem Passwort entschlüsseln kann und in einer seperaten Datei speichert.
#Erweitere dein Programm so, dass es in der Lage ist einen beliebigen mit einer [http://de.wikipedia.org/wiki/Caesar-Chiffre#Sicherheit| Cäsar-Chiffre] verschlüsselten Text mit Hilfe von [http://de.wikipedia.org/wiki/H%C3%A4ufigkeitsanalyse| Häufigkeitsanalyse] ohne das Passwort zu kennen zu entschlüsseln. 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.

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

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